/usr/include/x86_64-linux-gnu/zypp/Edition.h is in libzypp-dev 15.3.0-1build1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 | /*---------------------------------------------------------------------\
| ____ _ __ __ ___ |
| |__ / \ / / . \ . \ |
| / / \ V /| _/ _/ |
| / /__ | | | | | | |
| /_____||_| |_| |_| |
| |
\---------------------------------------------------------------------*/
/** \file zypp/Edition.h
*
*/
#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
//
/** Edition represents <code>[epoch:]version[-release]</code>
*
* \li \c epoch (optional) number, Edition::noepoch if not supplied
* \li \c version (required) string, may not contain '-'
* \li \c release (optional) string, may not contain '-'
*
* Comparison is actually \reg g_BackendSpecific.
*
* \li \b RPM: Edition are ordered according to \c epoch, then \c version,
* then \c release. Version and release strings are compared by splitting
* them into segments of alpha or digit sequences. Segments are compared
* according to their type. On mixed types a string compares less than a
* number.
* \code
* compare( 1.a, 1.0 ) == -1 (<)
* compare( 1.0, 1.a ) == 1 (>)
* compare( 1.0, 1_0 ) == 0 (==)
* \endcode
*
* \attention operator< defines equivalence classes of version strings, as non
* alphanumeric chars are ignored. That' why \c 1.0 and \c 1_0 compare equal
* in the example.<BR>
*
* \attention Edition::match compares two editions, treating empty
* version or release strings as wildcard. Thus match is not transitive,
* and you don't want to use it to order keys in a a std::container.
*
* \ingroup g_BackendSpecific
*/
class Edition : public IdStringType<Edition>
{
public:
/** Type of an epoch. */
typedef unsigned epoch_t;
/** Value representing \c noepoch. */
static const epoch_t noepoch = 0;
/** Value representing \c noedition (<tt>""</tt>)
* This is in fact a valid Edition. It's what the default ctor
* creates or will be parsed from an empty string.
*/
static const Edition noedition;
public:
/** Default ctor: \ref noedition. */
Edition() {}
/** Ctor taking edition as string. */
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 ) {}
/** Ctor taking \a version_r, \a release_r and optional \a epoch_r */
Edition( const std::string & version_r,
const std::string & release_r,
epoch_t epoch_r = noepoch );
/** \overload */
Edition( const char * version_r,
const char * release_r,
epoch_t epoch_r = noepoch );
/** Ctor taking \a version_r, \a release_r and optional \a epoch_r as string. */
Edition( const std::string & version_r,
const std::string & release_r,
const std::string & epoch_r );
/** \overload */
Edition( const char * version_r,
const char * release_r,
const char * epoch_r );
public:
/** Epoch */
epoch_t epoch() const;
/** Version */
std::string version() const;
/** Release */
std::string release() const;
public:
/** \ref compare functor.
* \see \ref RelCompare.
*/
typedef zypp::Compare<Edition> Compare;
/** \ref Edition \ref Range based on \ref Compare.
* \see \ref RelCompare.
*/
typedef Range<Edition> CompareRange;
public:
/** \name Match two Editions
* Match two Editions returning <tt>-1,0,1</tt>, treating empty
* version/release strings as \c ANY.
*/
//@{
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 ); }
//@}
/** \ref match functor.
* \see \ref RelCompare.
*/
struct Match: public std::binary_function<Edition,Edition,int>
{
int operator()( const Edition & lhs, const Edition & rhs ) const
{ return Edition::match( lhs, rhs ); }
};
/** \ref Edition \ref Range based on \ref Match.
* \see \ref RelCompare.
*/
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;
};
///////////////////////////////////////////////////////////////////
/** \relates Edition XML output. */
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
|