Capability.h

Go to the documentation of this file.

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

#include <iosfwd>

#include <zypp-core/Globals.h>
#include <zypp/sat/detail/PoolMember.h>

#include <zypp/IdString.h>
#include <zypp/Edition.h>
#include <zypp/Rel.h>
#include <zypp/ResTraits.h>
#include <zypp/ResolverNamespace.h>
#include <zypp/CapMatch.h>

namespace zypp
{ 

  class Capability;
  class CapDetail;
  class Arch;

  using CapabilitySet = std::unordered_set<Capability>;

  //
  //    CLASS NAME : Capability
  //
  class ZYPP_API Capability: protected sat::detail::PoolMember
  {
    public:
      enum CtorFlag { PARSED, UNPARSED };

    public:
      Capability() : _id( sat::detail::emptyId ) {}

      explicit Capability( sat::detail::IdType id_r ) : _id( id_r ) {}

      explicit Capability( const char * str_r, const ResKind & prefix_r = ResKind(), CtorFlag flag_r = UNPARSED );
      explicit Capability( const std::string & str_r, const ResKind & prefix_r = ResKind(), CtorFlag flag_r = UNPARSED );
      Capability( const Arch & arch_r, const char * str_r, const ResKind & prefix_r = ResKind(), CtorFlag flag_r = UNPARSED );
      Capability( const Arch & arch_r, const std::string & str_r, const ResKind & prefix_r = ResKind(), CtorFlag flag_r = UNPARSED );

      Capability( const char * str_r, CtorFlag flag_r, const ResKind & prefix_r = ResKind() );
      Capability( const std::string & str_r, CtorFlag flag_r, const ResKind & prefix_r = ResKind() );
      Capability( const Arch & arch_r, const char * str_r, CtorFlag flag_r, const ResKind & prefix_r = ResKind() );
      Capability( const Arch & arch_r, const std::string & str_r, CtorFlag flag_r, const ResKind & prefix_r = ResKind() );


      Capability( const std::string & name_r, const std::string & op_r, const std::string & ed_r, const ResKind & prefix_r = ResKind() );
      Capability( const std::string & name_r, Rel op_r, const std::string & ed_r, const ResKind & prefix_r = ResKind() );
      Capability( const std::string & name_r, Rel op_r, const Edition & ed_r, const ResKind & prefix_r = ResKind() );

      Capability( const std::string & arch_r, const std::string & name_r, const std::string & op_r, const std::string & ed_r, const ResKind & prefix_r = ResKind() );
      Capability( const std::string & arch_r, const std::string & name_r, Rel op_r, const std::string & ed_r, const ResKind & prefix_r = ResKind() );
      Capability( const std::string & arch_r, const std::string & name_r, Rel op_r, const Edition & ed_r, const ResKind & prefix_r = ResKind() );
      Capability( const Arch & arch_r, const std::string & name_r, const std::string & op_r, const std::string & ed_r, const ResKind & prefix_r = ResKind() );
      Capability( const Arch & arch_r, const std::string & name_r, Rel op_r, const std::string & ed_r, const ResKind & prefix_r = ResKind() );
      Capability( const Arch & arch_r, const std::string & name_r, Rel op_r, const Edition & ed_r, const ResKind & prefix_r = ResKind() );

      Capability( ResolverNamespace namespace_r, IdString value_r = IdString::Null );
      Capability( ResolverNamespace namespace_r, const char * value_r )         : Capability( namespace_r, IdString(value_r) ) {}
      Capability( ResolverNamespace namespace_r, const std::string & value_r )  : Capability( namespace_r, IdString(value_r) ) {}

      enum CapRel
      {
        CAP_AND       = 16, 
        CAP_OR        = 17, 

        CAP_COND      = 22, 
        CAP_UNLESS    = 29, 
        CAP_ELSE      = 26, 

        CAP_WITH      = 18, 
        CAP_WITHOUT   = 28, 

        CAP_NAMESPACE = 19, 
        CAP_ARCH      = 20, 
      };

      Capability( CapRel rel_r, const Capability & lhs_r, const Capability & rhs_r );

    public:
      static const Capability Null;

      static const Capability Empty;

    public:
      explicit operator bool() const
      { return ! empty(); }

      bool empty() const
      { return( _id == sat::detail::emptyId || _id == sat::detail::noId ); }

    public:
      const char * c_str() const;

      std::string asString() const
      { return c_str(); }

    public:
      CapDetail detail() const;

    public:
      static CapMatch matches( const Capability & lhs,  const Capability & rhs )     { return _doMatch( lhs.id(), rhs.id() ); }
      static CapMatch matches( const Capability & lhs,  const IdString & rhs )       { return _doMatch( lhs.id(), rhs.id() ); }
      static CapMatch matches( const Capability & lhs,  const std::string & rhs )    { return _doMatch( lhs.id(), Capability(rhs).id() ); }
      static CapMatch matches( const Capability & lhs,  const char * rhs )           { return _doMatch( lhs.id(), Capability(rhs).id() );}

      static CapMatch matches( const IdString & lhs,    const Capability & rhs )     { return _doMatch( lhs.id(), rhs.id() ); }
      static CapMatch matches( const IdString & lhs,    const IdString & rhs )       { return _doMatch( lhs.id(), rhs.id() ); }
      static CapMatch matches( const IdString & lhs,    const std::string & rhs )    { return _doMatch( lhs.id(), Capability(rhs).id() ); }
      static CapMatch matches( const IdString & lhs,    const char * rhs )           { return _doMatch( lhs.id(), Capability(rhs).id() ); }

      static CapMatch matches( const std::string & lhs, const Capability & rhs )     { return _doMatch( Capability(lhs).id(), rhs.id() );}
      static CapMatch matches( const std::string & lhs, const IdString & rhs )       { return _doMatch( Capability(lhs).id(), rhs.id() ); }
      static CapMatch matches( const std::string & lhs, const std::string & rhs )    { return _doMatch( Capability(lhs).id(), Capability(rhs).id() ); }
      static CapMatch matches( const std::string & lhs, const char * rhs )           { return _doMatch( Capability(lhs).id(), Capability(rhs).id() ); }

      static CapMatch matches( const char * lhs,        const Capability & rhs )     { return _doMatch( Capability(lhs).id(), rhs.id() );}
      static CapMatch matches( const char * lhs,        const IdString & rhs )       { return _doMatch( Capability(lhs).id(), rhs.id() ); }
      static CapMatch matches( const char * lhs,        const std::string & rhs )    { return _doMatch( Capability(lhs).id(), Capability(rhs).id() ); }
      static CapMatch matches( const char * lhs,        const char * rhs )           { return _doMatch( Capability(lhs).id(), Capability(rhs).id() ); }

      CapMatch matches( const Capability & rhs )  const { return _doMatch( id(), rhs.id() ); }
      CapMatch matches( const IdString & rhs )    const { return _doMatch( id(), rhs.id() ); }
      CapMatch matches( const std::string & rhs ) const { return _doMatch( id(), Capability(rhs).id() ); }
      CapMatch matches( const char * rhs )        const { return _doMatch( id(), Capability(rhs).id() ); }

      struct Matches
      {
        CapMatch operator()( const Capability & lhs, const Capability & rhs ) const
        { return Capability::matches( lhs, rhs ); }
      };

    public:
      static bool isInterestingFileSpec( const IdString & name_r )    { return isInterestingFileSpec( name_r.c_str() ); }
      static bool isInterestingFileSpec( const std::string & name_r ) { return isInterestingFileSpec( name_r.c_str() ); }
      static bool isInterestingFileSpec( const char * name_r );


      static Capability guessPackageSpec( const std::string & str_r );
      static Capability guessPackageSpec( const std::string & str_r, bool & rewrote_r );

    public:
      sat::detail::IdType id() const
      { return _id; }
    private:
      static CapMatch _doMatch( sat::detail::IdType lhs,  sat::detail::IdType rhs );
    private:
      sat::detail::IdType _id;
  };

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

  std::ostream & dumpOn( std::ostream & str, const Capability & obj ) ZYPP_API;

  std::ostream & operator<<( std::ostream & str, Capability::CapRel obj ) ZYPP_API;

  inline bool operator==( const Capability & lhs, const Capability & rhs )
  { return lhs.id() == rhs.id(); }

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

  inline bool operator<( const Capability & lhs, const Capability & rhs )
  { return lhs.id() < rhs.id(); }

  struct ZYPP_API dumpCap
  {
    dumpCap( Capability cap_r )
    : _cap { cap_r }
    {}
  private:
    friend std::ostream & operator<<( std::ostream & str, const dumpCap & obj );
    std::ostream & dumpOn( std::ostream & str ) const;
  private:
    std::ostream & _dumpRec( std::ostream & str, Capability cap_r, std::string lvl_r="" ) const;
    Capability _cap;
  };
  inline std::ostream & operator<<( std::ostream & str, const dumpCap & obj )
  { return obj.dumpOn( str ); }

  //
  //    CLASS NAME : CapDetail
  //
  class ZYPP_API CapDetail: protected sat::detail::PoolMember
  {
    public:
      enum Kind
      {
        NOCAP      = 0x00,
        NAMED      = 0x01,
        VERSIONED  = 0x02,
        EXPRESSION = 0x04
      };

      enum CapRel
      {
        REL_NONE      = 0,                         
        CAP_AND       = Capability::CAP_AND,       
        CAP_OR        = Capability::CAP_OR,        

        CAP_COND      = Capability::CAP_COND,      
        CAP_UNLESS    = Capability::CAP_UNLESS,    
        CAP_ELSE      = Capability::CAP_ELSE,      

        CAP_WITH      = Capability::CAP_WITH,      
        CAP_WITHOUT   = Capability::CAP_WITHOUT,   

        CAP_NAMESPACE = Capability::CAP_NAMESPACE, 
        CAP_ARCH      = Capability::CAP_ARCH,      
      };

    public:
      CapDetail()
      : _kind( NOCAP ), _lhs( 0 ), _rhs( 0 ), _flag( 0 ), _archIfSimple( 0 )
      {}
      explicit CapDetail( const Capability & cap_r )
      : _kind( NOCAP ), _lhs( cap_r.id() ), _rhs( 0 ), _flag( 0 ), _archIfSimple( 0 )
      { _init(); }
      explicit CapDetail( sat::detail::IdType id_r )
      : _kind( NOCAP ), _lhs( id_r ), _rhs( 0 ), _flag( 0 ), _archIfSimple( 0 )
      { _init(); }

    public:
      Kind kind()         const { return _kind; }
      bool isNull()       const { return _kind == NOCAP; }
      bool isNamed()      const { return _kind == NAMED; }
      bool isVersioned()  const { return _kind == VERSIONED; }
      bool isSimple()     const { return _kind & (NAMED|VERSIONED); }
      bool isExpression() const { return _kind == EXPRESSION; }

      bool     hasArch()  const { return _archIfSimple; }
      IdString arch()     const { return _archIfSimple ? IdString( _archIfSimple ) : IdString(); }
      IdString name()     const { return isSimple()    ? IdString( _lhs ) : IdString(); }
      Rel      op()       const { return isVersioned() ? Rel( _flag )     : isSimple() ? Rel::ANY : Rel::NONE; }
      Edition  ed()       const { return isVersioned() ? Edition( _rhs )  : Edition(); }

      Capability lhs()    const { return isExpression() ? Capability( _lhs ) : Capability::Null; }
      CapRel     capRel() const { return isExpression() ? CapRel(_flag)      : REL_NONE; }
      Capability rhs()    const { return isExpression() ? Capability( _rhs ) : Capability::Null; }

    private:
      void _init();
    private:
      Kind                _kind;
      sat::detail::IdType _lhs;
      sat::detail::IdType _rhs;
      unsigned            _flag;
      sat::detail::IdType _archIfSimple;
  };

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

  std::ostream & operator<<( std::ostream & str, CapDetail::Kind obj ) ZYPP_API;

  std::ostream & operator<<( std::ostream & str, CapDetail::CapRel obj ) ZYPP_API;


  inline CapDetail Capability::detail() const { return CapDetail( _id ); }

} // namespace zypp

ZYPP_DEFINE_ID_HASHABLE( ::zypp::Capability );

#endif // ZYPP_CAPABILITY_H