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 _AttributeDef {
      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<_AttributeDef> 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 _TypeDef {
      enum Enum {
        ANY,
        NA,
        wildcardfree,
        wildcarded,
      };
    };
    typedef base::EnumClass<_TypeDef> 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