CpeId.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_CPEID_H
#define ZYPP_CPEID_H
 
#include <iosfwd>
#include <string>
 
#include <zypp/base/PtrTypes.h>
#include <zypp/base/Flags.h>
#include <zypp/base/EnumClass.h>
#include <zypp/base/SetRelationMixin.h>
 
namespace zypp
{
  class CpeId : public base::SetRelationMixin<CpeId>
  {
  public:
    class Value;
 
  public:
    struct EAttributeDef {
      enum Enum {
        part,           //< attribute (2.2)
        vendor,         //< attribute (2.2)
        product,        //< attribute (2.2)
        version,        //< attribute (2.2)
        update,         //< attribute (2.2)
        edition,        //< attribute (2.2)
        language,       //< attribute (2.2)
        sw_edition,     //< extended attribute (2.3)
        target_sw,      //< extended attribute (2.3)
        target_hw,      //< extended attribute (2.3)
        other           //< extended attribute (2.3)
      };
      static constexpr unsigned numAttributes = other+1;        
      static const std::string & asString( Enum val_r );        
    };
    typedef base::EnumClass<EAttributeDef> Attribute;   
 
  public:
    struct NoThrowType { static std::string lastMalformed; };
    static constexpr NoThrowType noThrow = NoThrowType();
 
  public:
    CpeId();
 
    explicit CpeId( const std::string & cpe_r );
 
    explicit CpeId( const char * cpe_r )
      : CpeId( std::string( cpe_r ? cpe_r : "" ) )
    {}
 
    CpeId( const std::string & cpe_r, NoThrowType );
 
    ~CpeId();
 
  public:
    explicit operator bool() const;
 
    std::string asString() const
    { return asFs(); }
 
    std::string asFs() const;
 
    std::string asUri() const;
 
    std::string asWfn() const;
 
  private:
    friend SetCompare base::SetRelationMixin<CpeId>::compare( const CpeId & ) const;
    SetCompare setRelationMixinCompare( const CpeId & trg ) const;
 
  public:
    class Impl;                 
  private:
    RWCOW_pointer<Impl> _pimpl; 
  };
 
  SETRELATIONMIXIN_DEFINE_COMPARE_BETWEEN( CpeId, const char * );
  SETRELATIONMIXIN_DEFINE_COMPARE_BETWEEN( CpeId, const std::string & );
 
  inline std::ostream & operator<<( std::ostream & str, const CpeId & obj )
  { return str << obj.asString(); }
 
  inline std::ostream & operator<<( std::ostream & str, const CpeId::Attribute & obj )
  { return str << CpeId::Attribute::asString( obj.asEnum() ); }
 
 
  class CpeId::Value : public base::SetRelationMixin<Value>
  {
  public:
    static const Value ANY;
 
    static const Value NA;
 
  public:
    struct FsFormatType {};
    static constexpr FsFormatType fsFormat = FsFormatType();
 
    struct UriFormatType {};
    static constexpr UriFormatType uriFormat = UriFormatType();
 
  public:
    Value()
    {}
 
    explicit Value( const std::string & value_r );
 
    explicit Value( const char * value_r )
    : Value( std::string( value_r ? value_r : "*" ) )
    {}
 
     Value( const std::string & encoded_r, FsFormatType );
 
     Value( const std::string & encoded_r, UriFormatType );
 
  public:
    struct ETypeDef {
      enum Enum {
        ANY,
        NA,
        wildcardfree,
        wildcarded,
      };
    };
    typedef base::EnumClass<ETypeDef> Type;     
 
    Type type() const
    {
      if ( !_value ) return Type::ANY;
      if ( _value->empty() ) return Type::NA;
      return( isWildcarded() ? Type::wildcarded : Type::wildcardfree );
    }
 
    bool isANY() const
    { return !_value; }
 
    bool isNA() const
    { return _value && _value->empty(); }
 
    bool isLogical() const
    { return !_value || _value->empty(); }
    bool isLogical( Type type_r ) const
    { return( type_r == Type::ANY || type_r == Type::NA ); }
 
    bool isString() const
    { return _value && !_value->empty(); }
    bool isString( Type type_r ) const
    { return( type_r == Type::wildcardfree || type_r == Type::wildcarded ); }
 
    bool isWildcardfree() const
    { return isString() && ! containsWildcard(); }
 
    bool isWildcarded() const
    { return isString() && containsWildcard(); }
 
  public:
    std::string asString() const
    { return asWfn(); }
 
    std::string asWfn() const;
 
    std::string asFs() const;
 
    std::string asUri() const;
 
  private:
    friend SetCompare base::SetRelationMixin<Value>::compare( const Value & ) const;
    SetCompare setRelationMixinCompare( const Value & trg ) const;
 
    bool containsWildcard() const;
 
  private:
    RWCOW_pointer<std::string> _value;
  };
 
  SETRELATIONMIXIN_DEFINE_COMPARE_BETWEEN( CpeId::Value, const char * );
  SETRELATIONMIXIN_DEFINE_COMPARE_BETWEEN( CpeId::Value, const std::string & );
 
  std::ostream & operator<<( std::ostream & str, const CpeId::Value & obj );
 
} // namespace zypp
#endif // ZYPP_CPEID_H