ContentType.h

Go to the documentation of this file.

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

#include <iosfwd>
#include <string>

namespace zypp
{
  class ContentType
  {
  public:
    ContentType()
    {}

    explicit ContentType( const std::string & type_r )
    {
      std::string::size_type pos = type_r.find( "/" );
      if ( pos == std::string::npos )
      {
        testAndSet( _type, type_r );
      }
      else
      {
        testAndSet( _type,    type_r.substr( 0, pos ) );
        testAndSet( _subtype, type_r.substr( pos+1 ) );
      }
    }

    ContentType( const std::string & type_r, const std::string & subtype_r )
    {
      testAndSet( _type,    type_r );
      testAndSet( _subtype, subtype_r );
    }

  public:
    const std::string & type() const
    { return _type; }

    void type( const std::string & type_r )
    { _type = type_r; }

    const std::string & subtype() const
    { return _subtype; }

    void subtype( const std::string & subtype_r )
    { _subtype = 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, const 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 = 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