---

matcher.hh

/*
*  Name:      matcher.hh
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   Regular expression matcher
*  Date:      $Date: 2003/04/14 00:18:35 $
*  Revision:  $Revision: 1.1 $
*
*  Copyright (C) 1994-2002  Rafael Jesus Alcantara Perez <rafa@dedalo-ing.com>
*
*  This program is free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  This program is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program; if not, write to the Free Software
*  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
*  MA 02111-1307, USA.
*/

#ifndef _MPCL_TEXT_REGEX_MATCHER__
#define _MPCL_TEXT_REGEX_MATCHER__

#include <cstring>
#include <sstream>
#include "../../util/collection/string_to_string_map.hh"
#include "../string.hh"
#include "defs.hh"


namespace mpcl
{

  namespace text
  {

    namespace regex
    {

      using util::collection::TStringToStringMap;

      class TMatcher
      {

        private:

          bool   gCaseSensitive;

          bool   gLocalStream;

          std::basic_istream<char>*   ptSourceIstream;

          TStringToStringMap   tTerminalMap;


        public:

          //
          //  C O N S T R U C T O R S
          //

          TMatcher (void)           :
            gCaseSensitive  (true)  ,
            gLocalStream    (false) ,
            ptSourceIstream (NULL)  ,
            tTerminalMap    ()      {}

          TMatcher (std::basic_istream<char>& rtISTREAM) :
            gCaseSensitive  (true)                       ,
            gLocalStream    (false)                      ,
            ptSourceIstream (&rtISTREAM)                 ,
            tTerminalMap    ()
          {
            checkStream();
          }

          TMatcher (const std::string& rySTRING)                            :
            gCaseSensitive  (true)                                          ,
            gLocalStream    (true)                                          ,
            ptSourceIstream (new std::basic_istringstream<char> (rySTRING)) ,
            tTerminalMap    ()
          {
            if ( !rySTRING.empty() )
            {
              checkStream();
            }
          }

          TMatcher (const char* pkcSTRING)                                   :
            gCaseSensitive  (true)                                           ,
            gLocalStream    (true)                                           ,
            ptSourceIstream (new std::basic_istringstream<char> (pkcSTRING)) ,
            tTerminalMap    ()
          {
            if ( pkcSTRING && std::strlen (pkcSTRING) )
            {
              checkStream();
            }
          }

          ~TMatcher (void)
          {
            clearStream();
          }

          void clearDefinitions (void);

          void define (const char* pkcTERMINAL, const char* pkcDEFINITION);

          void redefine (const char* pkcTERMINAL, const char* pkcDEFINITION);

          void setCaseSensitiveness (bool gTRUTH);

          void setInput (const char* pkcSTRING);

          void setInput (const std::string& rkySTRING)
          {
            setInput (rkySTRING.c_str());
          }

          void setInput (std::basic_istream<char>& rtISTREAM);


        public:

          //
          //  S E L E C T O R S
          //

          size_t scan (const char* pkcPATTERN_STRING...) const;

          bool match (const char* pkcPATTERN_STRING) const;


        protected:

          //
          //  C O N S T R U C T O R S
          //

          void clearStream (void);


        protected:

          //
          //  S E L E C T O R S
          //

          void checkStream (void) const;

          TString instantiate (const char* pkcPATTERN_STRING) const;

          bool matchChars (char cSOURCE, const char* pkcPATTERN_STRING ) const;

      };  // class TMatcher

    }  // namespace regex

  }  // namespace text

}  // namespace mpcl


#endif  // not _MPCL_TEXT_REGEX_MATCHER__

---