ContentType.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_CONTENTTYPE_H
#define ZYPP_CONTENTTYPE_H
 
#include <iosfwd>
#include <string>
#include <stdexcept>
 
namespace zypp
{
  class ContentType
  {
  public:
    ContentType()
    {}
 
    explicit ContentType( std::string type_r )
    {
      std::string::size_type pos = type_r.find( "/" );
      if ( pos != std::string::npos )
      {
        testAndSet( _subtype, type_r.substr( pos+1 ) );
        type_r.erase( pos );
      }
      testAndSet( _type, std::move(type_r) );
    }
 
    ContentType( std::string type_r, std::string subtype_r )
    {
      testAndSet( _type,    std::move(type_r) );
      testAndSet( _subtype, std::move(subtype_r) );
    }
 
  public:
    const std::string & type() const
    { return _type; }
 
    void type( std::string type_r )
    { _type = std::move(type_r); }
 
    const std::string & subtype() const
    { return _subtype; }
 
    void subtype( std::string subtype_r )
    { _subtype = std::move(subtype_r); }
 
  public:
    bool empty() const
    { return emptyType() && emptySubtype(); }
    bool emptyType() const
    { return _type.empty(); }
    bool emptySubtype() const
    { return _subtype.empty(); }
 
    explicit operator bool () const
    { return !empty(); }
 
    std::string asString() const
    { std::string ret( type() ); if ( ! emptySubtype() ) { ret += "/"; ret += subtype(); } return ret; }
 
  private:
    void testAndSet( std::string & var_r, std::string val_r )
    {
      if ( val_r.find_first_of( "/ \t\r\n" ) != std::string::npos )
        throw std::invalid_argument( "ContentType: illegal char in '" + val_r + "'" );
      var_r = std::move(val_r);
    }
  private:
    std::string _type;
    std::string _subtype;
  };
 
  inline std::ostream & operator<<( std::ostream & str, const ContentType & obj )
  { return str << obj.asString(); }
 
  inline bool operator==( const ContentType & lhs, const ContentType & rhs )
  { return lhs.type() == rhs.type() && lhs.subtype() == rhs.subtype(); }
 
  inline bool operator!=( const ContentType & lhs, const ContentType & rhs )
  { return !( lhs == rhs ); }
 
  inline bool operator<( const ContentType & lhs, const ContentType & rhs )
  { int cmp = lhs.type().compare( rhs.type() ); return cmp < 0 || ( cmp == 0 && lhs.subtype() < rhs.subtype() ); }
 
  inline bool operator<=( const ContentType & lhs, const ContentType & rhs )
  { return lhs < rhs || lhs == rhs; }
 
  inline bool operator>( const ContentType & lhs, const ContentType & rhs )
  { return !( lhs <= rhs ); }
 
  inline bool operator>=( const ContentType & lhs, const ContentType & rhs )
  { return !( lhs < rhs ); }
 
 
} // namespace zypp
#endif // ZYPP_CONTENTTYPE_H