regularExpression.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
 
#ifndef BALL_DATATYPE_REGULAREXPRESSION_H
#define BALL_DATATYPE_REGULAREXPRESSION_H
 
#ifndef BALL_COMMON_H
# include <BALL/common.h>
#endif
 
#include <boost/regex.h>
 
#if !defined(__GNUC__) && !defined(__KAI__) && defined(IRIX)
# pragma reset woff 1174
#endif
 
#ifndef BALL_DATATYPE_STRING_H
# include <BALL/DATATYPE/string.h>
#endif
 
#define BALL_REGULAR_EXPRESSION_DEFAULT_PATTERN   ""
 
namespace BALL 
{
  class BALL_EXPORT RegularExpression
  {
    public:
 
    BALL_CREATE(RegularExpression)
 
    
      
    
    static const String ALPHA;

    static const String ALPHANUMERIC;

    static const String REAL;

    static const String IDENTIFIER;

    static const String INTEGER;

    static const String HEXADECIMAL_INTEGER;

    static const String LOWERCASE;

    static const String NON_ALPHA;

    static const String NON_ALPHANUMERIC;

    static const String NON_NUMERIC;

    static const String NON_WHITESPACE;

    static const String UPPERCASE;

    static const String WHITESPACE;

      
    RegularExpression();

    RegularExpression(const RegularExpression& regular_expression);

    RegularExpression(const String& pattern, bool wildcard_pattern = false);

    virtual ~RegularExpression();

    virtual void clear();

    void destroy();


    RegularExpression& operator = (const RegularExpression& expression);

    void set(const RegularExpression& regular_expression);

    void set(const String& pattern, bool wildcard_pattern = false);

    void get(RegularExpression& regular_expression) const;


    const String& getPattern() const;

    Size countSubexpressions() const;

    static bool match(const char* text, const char* pattern,
                      int compile_flags = 0 | REG_EXTENDED | REG_NOSUB, int execute_flags = 0);
    
    bool match(const String& text, Index from = 0, int execute_flags = 0) const;
  
    bool match(const Substring& text, Index from = 0, int execute_flags = 0) const;
  
    bool match(const char* text, int execute_flags = 0) const;
  
    bool find(const String& text, Substring& found,
              Index from = 0, int execute_flags = 0) const;
      
    bool find(const String& text, vector<Substring>& subexpressions,
              Index from = 0, int execute_flags = 0) const;
            


    bool isEmpty() const;

    bool operator == (const RegularExpression& regular_expression) const;

    bool operator != (const RegularExpression& regular_expression) const;

    bool operator < (const RegularExpression& regular_expression) const;

    bool operator <= (const RegularExpression& regular_expression) const;

    bool operator >= (const RegularExpression& regular_expression) const;

    bool operator > (const RegularExpression& regular_expression) const;



    virtual bool isValid() const;

    virtual void dump(std::ostream& s = std::cout, Size depth = 0) const;



    BALL_EXPORT
    friend std::ostream& operator << (std::ostream& s, const RegularExpression& regular_expression);

    BALL_EXPORT
    friend std::istream& operator >> (std::istream& s, RegularExpression& regular_expression);

    
    private:
 
    void compilePattern_();
 
    void toExtendedRegularExpression_();
 
    regex_t regex_;
    
    String  pattern_;
    bool    valid_pattern_;
  };
 
# ifndef BALL_NO_INLINE_FUNCTIONS
#   include <BALL/DATATYPE/regularExpression.iC>
# endif
} // namespace BALL
 
#endif // BALL_DATATYPE_REGULAREXPRESSION_H