AttrMatcher.h

Go to the documentation of this file.

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

extern "C"
{
struct _Datamatcher;
}

#include <iosfwd>
#include <string>

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

namespace zypp
{ 

  //
  //    CLASS NAME : Match
  //
  class Match : private base::SafeBool<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 SKIP_KIND;
      static const Match FILES;

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

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

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

#ifndef SWIG // Swig treats it as syntax error

      using base::SafeBool<Match>::operator bool_type;
#endif

    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:
      friend base::SafeBool<Match>::operator bool_type() const;
      bool boolTest() const     { return _val; }

      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 );



  //
  //    CLASS NAME : MatchException
  //
  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 );
  };


  namespace sat
  { 

    //
    //  CLASS NAME : AttrMatcher
    //
    class AttrMatcher : private base::SafeBool<AttrMatcher>
    {
      friend std::ostream & operator<<( std::ostream & str, const AttrMatcher & obj );

      public:
        typedef MatchException Exception;

      public:
        class Impl;

      public:
        AttrMatcher();

        AttrMatcher( const std::string & search_r );

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

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

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

#ifndef SWIG // Swig treats it as syntax error

      using base::SafeBool<AttrMatcher>::operator bool_type;
#endif

      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:
        friend base::SafeBool<AttrMatcher>::operator bool_type() const;
        bool boolTest() const
        { return !searchstring().empty(); }

      private:
        RWCOW_pointer<Impl> _pimpl;
    };

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

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

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

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

  } // namespace sat
} // namespace zypp
#endif // ZYPP_SAT_ATTRMATCHER_H