simple_regex.h

Go to the documentation of this file.

#ifndef REGEX_HEADER_INCLUDED
#define REGEX_HEADER_INCLUDED

//
// Copyright 2002, 2009 Lowell Boggs Jr.
//
// This file or directory, containing source code for a computer program,
// is Copyrighted by Lowell Boggs, Jr.  987 Regency Drive, Lewisville
// TX (USA), 75067.  You may use, copy, modify, and distribute this
// source file without charge or obligation so long as you agree to
// the following:
//
//  1.  You must indemnify Lowell Boggs against any and all financial
//      obligations caused by its use, misuse, function, or malfunction.
//      Further, you acknowledge that there is no warranty of any kind,
//      whatsoever.
//
//  2.  You agree not to attempt to patent any portion of this original
//      work -- though you may attempt to patent your own extensions to
//      it if you so choose.
//
//  3.  You keep this copyright notice with the file and all copies
//      of the file and do not change it anyway except language translation.
//
// You are responsible for enforcing your own compliance with these
// conditions and may not use this source file if you cannot agree to the
// above terms and conditions.




#include <string>
#include <regex.h>

namespace cxxtls
{

//@File

class SimpleRegex
{
public:

  struct match     
  {
      int offset;  /* location in the 'string' where the regexp was found */
      int length;
  };

private:

  regex_t compiled_expression; 


  std::string expression_;     
  std::string options_;        

  enum constants_
  {
    max_matches=20
  };

  mutable match matches_[max_matches]; 

  mutable char const *error_;          

  bool ok_;                            

  mutable int match_count_;            

                                
  std::string expand(std::string const&, std::string const&) const
    ;

public:


  SimpleRegex(std::string const &expression="", std::string const &options="")
      ;


  SimpleRegex(char const *expression, char const *options="")
      ;

  SimpleRegex(SimpleRegex const &r);              

  SimpleRegex &operator=(SimpleRegex const &r); 
  SimpleRegex &operator=(std::string const &r); 
  SimpleRegex &operator=(char const *r);        


  void reset(std::string const &expression, std::string const &options)
  {
    this->SimpleRegex::~SimpleRegex();

    new(this) SimpleRegex(expression, options);

  }

  // the following operators return the number of matches.
  int operator() (char const *string, int stringLength) const;

  int operator() (std::string const &s,
                  int offset=0,
                  int length=0x7ffffff) const
   ;

  bool ok() const { return ok_ && error_ == 0; } 

  std::string const &options() const { return options_; }

  char const *error() const { return error_; } 

  bool anchored() const
    ;

  bool empty() const { return expression_.empty(); }

  operator std::string const &() const { return expression_; } 

  ~SimpleRegex();  

  match const *matches() const { return matches_; }  

  std::string substitute(std::string const &original,
                         std::string const &replacement) const
    ;

  bool replace(std::string       &rv, 
               std::string const &source, 
               std::string const &replacement, 
               int                maxIterations=0x7fffffff
              ) const
    ;

};

} // namespace cxxtls

#endif