regexx.cc

Go to the documentation of this file.

#define TF_REGEXX_CC_VERSION \
  "TF_REGEXX_CC   V1.1"

#include <tfxx/regexx.h>

#ifdef OLDLIBREGEXX
#include<regexx.hh>
#ifndef REGEXX_HH
#error read wrong header
#endif
#else
#include<boost/regex.hpp>
#endif

namespace tfxx {

  namespace string {

    namespace helper {

      regexxcontainer::regexxcontainer() { }
      regexxcontainer::regexxcontainer(const std::string& e) { }
      regexxcontainer::~regexxcontainer() { }

/*======================================================================*/
// use old libregexx
#ifdef OLDLIBREGEXX

      class myregexxcontainer: 
        public tfxx::string::helper::regexxcontainer {
          public:
            myregexxcontainer():
              tfxx::string::helper::regexxcontainer()
            { this->expression(std::string(".*")); }
            myregexxcontainer(const std::string& e):
              tfxx::string::helper::regexxcontainer(e)
            { this->expression(e); }
            virtual ~myregexxcontainer() { }
            virtual void expression(const std::string& e)
            { Mregex.expr(e); }
            virtual std::string expression() const
            { return(Mregex.expr()); }
            virtual bool match(const std::string s)
            {
              Mregex.str(s);
              return (Mregex.exec());
            }
          private:
            ::regexx::Regexx Mregex;
      }; // class myregexxcontainer

/*======================================================================*/
// use libboost_regex
#else

      class myregexxcontainer: 
        public tfxx::string::helper::regexxcontainer {
          public:
            myregexxcontainer():
              tfxx::string::helper::regexxcontainer()
            { this->expression(std::string(".*")); }
            myregexxcontainer(const std::string& e):
              tfxx::string::helper::regexxcontainer(e)
            { this->expression(e); }
            virtual ~myregexxcontainer() { }
            virtual void expression(const std::string& e)
            { Mregex.assign(e); }
            virtual std::string expression() const
            { return(Mregex.str()); }
            virtual bool match(const std::string s)
            { return(boost::regex_match(s, Mregex)); }
          private:
            boost::regex Mregex;
      }; // class myregexxcontainer

#endif

    } // namespace helper

/*======================================================================*/
// common code

    regexx::regexx() 
    { Mcontainer=new tfxx::string::helper::myregexxcontainer; }
    regexx::regexx(const std::string& e)
    { Mcontainer=new tfxx::string::helper::myregexxcontainer(e); }
    regexx::~regexx()
    { delete(Mcontainer); }

  } // namespace string

} // namespace tfxx

/* ----- END OF regexx.cc ----- */