---

findtextimpl.cpp

См. документацию.

/*
 * Copyright (C) Sergey P. Derevyago, 2003-2004.
 *
 * Permission to copy, use, modify, sell and distribute this software is granted
 * provided this copyright notice appears in all copies.
 * This software is provided "as is" without express or implied warranty, and
 * with no claim as to its suitability for any purpose.
 *
 */

#include "findtext.hpp"
#include <string.h>
#include <errno.h>
#include "findfile.hpp"
#include "textfinder.hpp"
#include "autofile.hpp"
#include "stringbuf.hpp"

using namespace std;

namespace {

 struct AutoFlag {
        bool& flag;

        AutoFlag(bool& f) : flag(f) {}
        ~AutoFlag() { flag=0; }
 };

 struct OpenCloseSender;

 class FindTextImpl : public FindText, FindFileCallback, Publisher<FoundMsg>,
   Publisher<InfoMsg>, Publisher<ErrorMsg> {
       friend struct OpenCloseSender;

       bool running;
       bool shouldStop;
       sh_ptr<TextFinder> txtFnd;

       virtual void search(const std::string& dir, bool recur,
         const std::string& mask, const std::string& text);

       virtual void stopSearch();

       virtual Publisher<FoundMsg>& foundPub();

       virtual Publisher<InfoMsg>& infoPub();

       virtual Publisher<ErrorMsg>& errorPub();

       virtual bool found(const std::string& fileName);

       bool readLine(FILE* f, string& str, const std::string& file);

  public:
       FindTextImpl() : running(0), shouldStop(0) {}
 };

 struct OpenCloseSender {
        FindTextImpl& fti;
        const string& file;

        OpenCloseSender(FindTextImpl& fti_, const string& file_) : fti(fti_),
          file(file_)
        {
         fti.Publisher<InfoMsg>::send(InfoMsg(fti, InfoMsg::opened, file));
        }

        ~OpenCloseSender()
        {
         fti.Publisher<InfoMsg>::send(InfoMsg(fti, InfoMsg::closed, file));
        }
 };

 void FindTextImpl::search(const std::string& dir, bool recur,
         const std::string& mask, const std::string& text)
 {
  try {
      if (running)
         throw newCException(_FLINE_, "search() already running");
      running=1;
      
      AutoFlag autoRunning(running);
      AutoFlag autoShouldStop(shouldStop);

      txtFnd=Factory::newTextFinder(text);

      sh_ptr<FindFile> ff=Factory::newFindFile();
      ff->find(dir, recur, mask, *this);
  }
  catch (...) {
        throw newCException(_FLINE_, "Can't search", toCException(_FLINE_));
  }
 }

 void FindTextImpl::stopSearch()
 {
  if (!running) throw newCException(_FLINE_, "search() isn't running");
  shouldStop=1;
 }

 Publisher<FoundMsg>& FindTextImpl::foundPub()
 {
  return *this;
 }

 Publisher<InfoMsg>& FindTextImpl::infoPub()
 {
  return *this;
 }

 Publisher<ErrorMsg>& FindTextImpl::errorPub()
 {
  return *this;
 }

 bool FindTextImpl::found(const std::string& fileName)
 {
  try {
      if (shouldStop) return 0;

      AutoFILE f(fopen(fileName.c_str(), "r"));
      if (!f.get()) {
         Publisher<ErrorMsg>::send(ErrorMsg(*this, StringBuf("Can't open \"")+
           fileName+"\": "+strerror(errno)));
         return 1;
      }

      OpenCloseSender ocs(*this, fileName);

      string str;
      str.reserve(1024);

      for (int lineNum=1; readLine(f.get(), str, fileName); lineNum++) {
          if (txtFnd->findIn(str))
             Publisher<FoundMsg>::send(FoundMsg(*this, fileName, lineNum, str));
      }

      return 1;
  }
  catch (...) {
        throw newCException(_FLINE_, "Can't process \""+fileName+"\"", 
          toCException(_FLINE_));
  }
 }

 bool FindTextImpl::readLine(FILE* f, string& str, const std::string& file)
 {
  if (feof(f)) return 0;
  str.clear();
  
  for (int ch; ; ) {
      switch (ch=fgetc(f)) {
             case EOF: {
                  if (ferror(f)) {
                     Publisher<ErrorMsg>::send(ErrorMsg(*this,
                       StringBuf("Can't read from \"")+file+"\": "+
                       strerror(errno)));
                     return 0;
                  }

                  return (str.size()) ? 1 : 0;
             }
             case '\n': return 1;
             default: {
                      str.push_back(ch);
                      break;
             }
      }
  }
 }

}

sh_ptr<FindText> Factory::newFindText()
{
 try { return sh_ptr<FindText>(new FindTextImpl); }
 catch (...) {
       throw newCException(_FLINE_, "Can't create FindTextImpl object",
         toCException(_FLINE_));
 }
}

---