StrMatcher.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_BASE_STRMATCHER_H
#define ZYPP_BASE_STRMATCHER_H

#include <iosfwd>
#include <string>

#include "zypp/base/PtrTypes.h"
#include "zypp/base/Exception.h"

namespace zypp
{
  class Match
  {
  private:
    static const int _modemask;
    static const int _flagmask;

  public:
    enum Mode
    {
      NOTHING,          
      STRING,           
      STRINGSTART,      
      STRINGEND,        
      SUBSTRING,        
      GLOB,             
      REGEX,            
      OTHER             
    };

      static const Match NOCASE;                


      static const Match NO_STORAGE_SOLVABLE;   
      static const Match SUB;                   
      static const Match ARRAYSENTINEL;         
      static const Match DISABLED_REPOS;        
      static const Match COMPLETE_FILELIST;     
      static const Match SKIP_KIND;             
      static const Match FILES;                 
      static const Match CHECKSUMS;             


  public:
    Match()
    : _val( 0 )
    {}

    Match( Mode val_r )
    : _val( modeval( val_r ) )
    {}

    explicit Match( int val_r )
    : _val( val_r )
    {}

    explicit operator bool() const
    { return _val; }

  public:
    bool test( const Match & rhs ) const
    { return ( ( flagval() & rhs.flagval() ) == rhs.flagval() ) && ( !rhs.modeval() || rhs.modeval() == modeval() ); }

    bool testAnyOf( const Match & rhs ) const
    { return ( flagval() & rhs.flagval() ) || ( rhs.modeval() && rhs.modeval() == modeval() ); }

    void set( const Match & rhs )
    {
      if ( rhs.modeval() )
        _val = rhs._val | flagval(); // also set the rhs mode
        else
          _val |= rhs._val; // just set the flags
    }

    void unset( const Match & rhs )
    {
      if ( modeval() == rhs.modeval() )
        _val = flagval() & ~rhs.flagval(); // also unset mode
        else
          _val &= ~rhs.flagval(); // just unset falgs
    }

    void turn( const Match & rhs, bool onoff )
    { onoff ? set( rhs ) : unset( rhs ); }

    Match & operator|=( const Match & rhs )
    { set( rhs ); return *this; }

    Match & operator-=( const Match & rhs )
    { unset( rhs ); return *this; }

  public:
    Mode mode() const;

    Match flags() const
    { return Match( flagval() ); }

  public:
      int get() const           { return _val; }
      int modeval() const       { return _val & _modemask; }
      int flagval() const       { return _val & _flagmask; }

  public:
      bool isMode( Mode rhs ) const
      { return modeval() == modeval( rhs ); }
      bool isModeString() const
      { return isMode( STRING ); }
      bool isModeStringstart() const
      { return isMode( STRINGSTART ); }
      bool isModeStringend() const
      { return isMode( STRINGEND ); }
      bool isModeSubstring() const
      { return isMode( SUBSTRING ); }
      bool isModeGlob() const
      { return isMode( GLOB ); }
      bool isModeRegex() const
      { return isMode( REGEX ); }

      void setMode( Mode rhs )
      { _val = modeval( rhs ) | flagval(); }
      void setModeString()
      { setMode( STRING ); }
      void setModeStringstart()
      { setMode( STRINGSTART ); }
      void setModeStringend()
      { setMode( STRINGEND ); }
      void setModeSubstring()
      { setMode( SUBSTRING ); }
      void setModeGlob()
      { setMode( GLOB ); }
      void setModeRegex()
      { setMode( REGEX ); }

      std::string asString() const;

  private:
    static int modeval( Mode mode_r );

  private:
    int _val;
  };

  inline bool operator==( const Match & lhs, const Match & rhs )
  { return lhs.get() == rhs.get(); }
  inline bool operator!=( const Match & lhs, const Match & rhs )
  { return lhs.get() != rhs.get(); }

  inline Match operator|( const Match & lhs, const Match & rhs )
  { return Match(lhs) |= rhs; }
  inline Match operator|( Match::Mode lhs, Match::Mode rhs )
  { return Match(lhs) |= rhs; }

  inline Match operator-( const Match & lhs, const Match & rhs )
  { return Match(lhs) -= rhs; }
  inline Match operator-( Match::Mode lhs, Match::Mode rhs )
  { return Match(lhs) -= rhs; }

  std::ostream & operator<<( std::ostream & str, Match::Mode obj );

  std::ostream & operator<<( std::ostream & str, const Match & obj );

  struct MatchException : public Exception
  {
    explicit MatchException( const std::string & msg_r ) : Exception( msg_r ) {}
  };

  struct MatchUnknownModeException : public MatchException
  {
    explicit MatchUnknownModeException( const std::string & msg_r ) : MatchException( msg_r ) {}

    MatchUnknownModeException( const Match & mode_r, const std::string & msg_r = std::string() );
  };

  struct MatchInvalidRegexException : public MatchException
  {
    explicit MatchInvalidRegexException( const std::string & msg_r ) : MatchException( msg_r ) {}

    MatchInvalidRegexException( const std::string & regex_r, int regcomp_r );
  };

  class StrMatcher
  {
    friend std::ostream & operator<<( std::ostream & str, const StrMatcher & obj );

  public:
    typedef MatchException Exception;

  public:
    class Impl;

  public:
    StrMatcher();

    StrMatcher( const std::string & search_r );

    StrMatcher( const std::string & search_r, const Match & flags_r );

    StrMatcher( const std::string & search_r, const Match::Mode & flags_r );

    StrMatcher( const std::string & search_r, int flags_r );

    explicit operator bool() const
    { return !searchstring().empty(); }

  public:
    template<class _Tp>
    bool operator()( const _Tp & string_r ) const
    { return doMatch( string_r.c_str() ); }
    bool operator()( const char * string_r ) const
    { return doMatch( string_r ); }

  public:
    const std::string & searchstring() const;

    void setSearchstring( const std::string & string_r );

    void setSearchstring( const std::string & string_r, const Match & flags_r );

    const Match & flags() const;

    void setFlags( const Match & flags_r );

  public:
    void compile() const;

    bool isCompiled() const;

    bool doMatch( const char * string_r ) const;

  private:
    RWCOW_pointer<Impl> _pimpl;
  };

  std::ostream & operator<<( std::ostream & str, const StrMatcher & obj );

  bool operator==( const StrMatcher & lhs, const StrMatcher & rhs );

  inline bool operator!=( const StrMatcher & lhs, const StrMatcher & rhs )
  { return !( lhs == rhs ); }

  bool operator<( const StrMatcher & lhs, const StrMatcher & rhs );

} // namespace zypp
#endif // ZYPP_BASE_STRMATCHER_H