regularExpression.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//
// $Id: regularExpression.h,v 1.3 2005/12/23 17:01:42 amoll Exp $
//

#ifndef BALL_DATATYPE_REGULAREXPRESSION_H
#define BALL_DATATYPE_REGULAREXPRESSION_H

#ifndef BALL_COMMON_H
# include <BALL/common.h>
#endif

// for SGI CC: turn of warnings #1174: function "regcomp" was declared but never referenced
#if !defined(__GNUC__) && !defined(__KAI__) && defined(IRIX)
# pragma set woff 1174
#endif

#ifdef BALL_HAS_SYS_TYPES_H
# include <sys/types.h>
#endif

#ifdef BALL_HAS_REGEX_H
  // make sure __STDC__ is set when including the
  // GNU regex headers under Windows
# ifdef BALL_COMPILER_MSVC
#   define __STDC__ 1
    extern "C" {
# endif
#     include <regex.h>
# ifdef BALL_COMPILER_MSVC
    }
# endif
#endif

#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)
      throw(Exception::NullPointer);
    
    bool match(const String& text, Index from = 0, int execute_flags = 0) const
      throw(Exception::NullPointer, Exception::IndexUnderflow, Exception::IndexOverflow);
  
    bool match(const Substring& text, Index from = 0, int execute_flags = 0) const
      throw(Substring::InvalidSubstring, Exception::IndexUnderflow, Exception::IndexOverflow);
  
    bool match(const char* text, int execute_flags = 0) const
      throw(Exception::NullPointer);
  
    bool find(const String& text, Substring& found,
              Index from = 0, int execute_flags = 0) const
              throw(Exception::IndexUnderflow, Exception::IndexOverflow);
      
    bool find(const String& text, vector<Substring>& subexpressions,
              Index from = 0, int execute_flags = 0) const
              throw(Exception::IndexUnderflow, Exception::IndexOverflow);
            


    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