Edition.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_EDITION_H
#define ZYPP_EDITION_H
 
#include <iosfwd>
#include <string>
#include <functional>
 
#include <zypp/IdStringType.h>
#include <zypp/RelCompare.h>
#include <zypp/Range.h>
 
namespace zypp
{ 
 
  //
  //    CLASS NAME : Edition
  //
  class Edition : public IdStringType<Edition>
  {
    public:
      typedef unsigned epoch_t;
 
      static const epoch_t noepoch = 0;
 
      static const Edition noedition;
 
    public:
      Edition() {}
 
      explicit Edition( IdString::IdType id_r )     : _str( id_r ) {}
      explicit Edition( const IdString & idstr_r )  : _str( idstr_r ) {}
      explicit Edition( const std::string & str_r ) : _str( str_r ) {}
      explicit Edition( const char * cstr_r )       : _str( cstr_r ) {}
 
      Edition( const std::string & version_r,
               const std::string & release_r,
               epoch_t epoch_r = noepoch );
      Edition( const char * version_r,
               const char * release_r,
               epoch_t epoch_r = noepoch );
 
      Edition( const std::string & version_r,
               const std::string & release_r,
               const std::string & epoch_r );
      Edition( const char * version_r,
               const char * release_r,
               const char * epoch_r );
 
    public:
      epoch_t epoch() const;
 
      std::string version() const;
 
      std::string release() const;
 
    public:
      typedef zypp::Compare<Edition> Compare;
 
      typedef Range<Edition> CompareRange;
 
    public:
      static int match( const Edition & lhs,     const Edition & rhs )     { return match( lhs.idStr(), rhs.idStr() ); }
      static int match( const Edition & lhs,     const IdString & rhs )    { return match( lhs.idStr(), rhs ); }
      static int match( const Edition & lhs,     const std::string & rhs ) { return _doMatch( lhs.c_str(), rhs.c_str() ); }
      static int match( const Edition & lhs,     const char * rhs )        { return _doMatch( lhs.c_str(), rhs );}
 
      static int match( const IdString & lhs,    const Edition & rhs )     { return match( lhs, rhs.idStr() ); }
      static int match( const IdString & lhs,    const IdString & rhs )    { return lhs.compareEQ( rhs ) ? 0 :
                                                                                    _doMatch( lhs.c_str(), rhs.c_str() ); }
      static int match( const IdString & lhs,    const std::string & rhs ) { return _doMatch( lhs.c_str(), rhs.c_str() ); }
      static int match( const IdString & lhs,    const char * rhs )        { return _doMatch( lhs.c_str(), rhs ); }
 
      static int match( const std::string & lhs, const Edition & rhs )     { return _doMatch( lhs.c_str(), rhs.c_str() );}
      static int match( const std::string & lhs, const IdString & rhs )    { return _doMatch( lhs.c_str(), rhs.c_str() ); }
      static int match( const std::string & lhs, const std::string & rhs ) { return _doMatch( lhs.c_str(), rhs.c_str() ); }
      static int match( const std::string & lhs, const char * rhs )        { return _doMatch( lhs.c_str(), rhs ); }
 
      static int match( const char * lhs,        const Edition & rhs )     { return _doMatch( lhs, rhs.c_str() );}
      static int match( const char * lhs,        const IdString & rhs )    { return _doMatch( lhs, rhs.c_str() ); }
      static int match( const char * lhs,        const std::string & rhs ) { return _doMatch( lhs, rhs.c_str() ); }
      static int match( const char * lhs,        const char * rhs )        { return _doMatch( lhs, rhs ); }
 
      int match( const Edition & rhs )     const { return match( idStr(), rhs.idStr() ); }
      int match( const IdString & rhs )    const { return match( idStr(), rhs ); }
      int match( const std::string & rhs ) const { return _doMatch( c_str(), rhs.c_str() ); }
      int match( const char * rhs )        const { return _doMatch( c_str(), rhs ); }
 
      struct Match
      {
        int operator()( const Edition & lhs, const Edition & rhs ) const
        { return Edition::match( lhs, rhs ); }
      };
 
      typedef Range<Edition, Match> MatchRange;
 
    private:
      static int _doCompare( const char * lhs,  const char * rhs );
      static int _doMatch( const char * lhs,  const char * rhs );
 
    private:
      friend class IdStringType<Edition>;
      IdString _str;
  };
 
  inline std::ostream & dumpAsXmlOn( std::ostream & str, const Edition & obj )
  { return str << "<edition"
               << " epoch=\"" << obj.epoch() << "\""
               << " version=\"" << obj.version() << "\""
               << " release=\"" << obj.release() << "\""
               << "/>";
  }
 
} // namespace zypp
#endif // ZYPP_EDITION_H