CpeId.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_CPEID_H
#define ZYPP_CPEID_H
 
#include <iosfwd>
#include <string>
 
#include <zypp/Globals.h>
#include <zypp/base/PtrTypes.h>
#include <zypp/base/Flags.h>
#include <zypp/base/EnumClass.h>
#include <zypp/base/SetRelationMixin.h>

namespace zypp
{
  class ZYPP_API 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 );    
    };
    using Attribute = base::EnumClass<EAttributeDef>;  
 
  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,
      };
    };
    using Type = base::EnumClass<ETypeDef>; 

    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