Regex.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_BASE_REGEX_H
#define ZYPP_BASE_REGEX_H
 
#include <iosfwd>
#include <string>
#include <regex.h>
 
#include <zypp/base/Exception.h>
 
namespace zypp
{
  namespace str
  {
 
    typedef Exception regex_error;
 
    class smatch;
    class regex;
 
    bool regex_match( const char * s, smatch & matches, const regex & regex );
 
    inline bool regex_match(const std::string & s, smatch & matches, const regex & regex)
    { return regex_match( s.c_str(), matches, regex ); }
 
    bool regex_match( const char * s, const regex & regex );
 
    inline bool regex_match( const std::string & s, const regex & regex )
    { return regex_match( s.c_str(), regex ); }
 
    std::string regex_substitute ( const std::string & s, const regex & regex, const std::string &replacement, bool global = true );
 
    class regex
    {
    public:
 
      enum RegFlags {
        icase           = REG_ICASE,    
        nosubs          = REG_NOSUB,    
        match_extended  = REG_EXTENDED, 
        newline         = REG_NEWLINE,  
        rxdefault       = match_extended|newline 
      };
 
      enum MatchFlags {
        none    = 0,
        not_bol = REG_NOTBOL 
      };
 
      regex();
      regex( const std::string & s, int flags = rxdefault );
      regex( const char* s, int flags = rxdefault ) : regex( std::string(s?s:""), flags ) {}
      ~regex();
 
      regex( const regex & rhs )
      { assign( rhs.m_str, rhs.m_flags ); }
 
      regex & operator=( const regex & rhs )
      { assign( rhs.m_str, rhs.m_flags ); return *this; }
 
      std::string asString() const
      { return m_str; }
 
      bool matches( const char * s, str::smatch & matches, int flags = none ) const;
      bool matches( const char * s ) const;
 
    public:
      regex_t * get()
      { return & m_preg; }
 
    private:
      void assign( const std::string & s, int flags );
 
    private:
      friend class smatch;
      std::string m_str;
      int m_flags;
      regex_t m_preg;
      bool m_valid = false;
    };
 
    inline std::ostream & operator<<( std::ostream & str, const regex & obj )
    { return str << obj.asString(); }
 
    class smatch
    {
    public:
      smatch();
 
      std::string operator[](unsigned i) const;
 
      unsigned size() const;
 
      std::string::size_type begin( unsigned i ) const;
 
      std::string::size_type end( unsigned i ) const;
 
      std::string::size_type size( unsigned i ) const;
 
      std::string match_str;
      std::vector<regmatch_t> pmatch;
    };
 
  } // namespace str
} // namespace zypp
#endif // ZYPP_BASE_STRING_H