zypp/IdString.h

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/sat/IdString.h
  10  *
  11 */
  12 #ifndef ZYPP_SAT_IDSTR_H
  13 #define ZYPP_SAT_IDSTR_H
  14
  15 #include <iosfwd>
  16 #include <string>
  17
  18 #include "zypp/base/SafeBool.h"
  19
  20 #include "zypp/sat/detail/PoolMember.h"
  21
  22 ///////////////////////////////////////////////////////////////////
  23 namespace zypp
  24 { /////////////////////////////////////////////////////////////////
  25
  26   ///////////////////////////////////////////////////////////////////
  27   //
  28   //    CLASS NAME : IdString
  29   //
  30   /** Access to the sat-pools string space.
  31    *
  32    * Construction from string will place a copy of the string in the
  33    * string space, if it is not already present.
  34    *
  35    * While comparison differs between \ref IdString::Null and \ref IdString::Empty
  36    * ( \c NULL and \c "" ), both are represented by an empty string \c "".
  37    */
  38   class IdString : protected sat::detail::PoolMember,
  39                    private base::SafeBool<IdString>
  40   {
  41     public:
  42       typedef sat::detail::IdType IdType;
  43
  44     public:
  45       /** Default ctor, empty string. */
  46       IdString() : _id( sat::detail::emptyId ) {}
  47
  48       /** Ctor from id. */
  49       explicit IdString( IdType id_r ) : _id( id_r ) {}
  50
  51       /** Ctor from string. */
  52       explicit IdString( const char * str_r );
  53
  54       /** Ctor from string. */
  55       explicit IdString( const std::string & str_r );
  56
  57     public:
  58       /** No or Null string ( Id \c 0 ). */
  59       static const IdString Null;
  60
  61       /** Empty string. */
  62       static const IdString Empty;
  63
  64     public:
  65       /** Evaluate in a boolean context <tt>( != \c Null )</tt>. */
  66       using base::SafeBool<IdString>::operator bool_type;
  67
  68       /** Whether the string is empty.
  69        * This is true for \ref Null and \ref Empty.
  70        */
  71       bool empty() const
  72       { return( _id == sat::detail::emptyId || _id == sat::detail::noId ); }
  73
  74       /** The strings size. */
  75       unsigned size() const;
  76
  77     public:
  78       /** Conversion to <tt>const char *</tt> */
  79       const char * c_str() const;
  80
  81       /** Conversion to <tt>std::string</tt> */
  82       std::string asString() const
  83       { return c_str(); }
  84
  85     public:
  86       /** Fast compare equal. */
  87       bool compareEQ( const IdString & rhs ) const
  88       { return( _id == rhs.id() ); }
  89
  90       /** Compare IdString returning <tt>-1,0,1</tt>. */
  91       int compare( const IdString & rhs ) const;
  92
  93       /** \overload */
  94       int compare( const char * rhs ) const;
  95
  96       /** \overload */
  97       int compare( const std::string & rhs ) const
  98       { return compare( rhs.c_str() ); }
  99
 100     public:
 101       /** Expert backdoor. */
 102       IdType id() const
 103       { return _id; }
 104     private:
 105       friend base::SafeBool<IdString>::operator bool_type() const;
 106       bool boolTest() const { return _id; }
 107     private:
 108       IdType _id;
 109   };
 110   ///////////////////////////////////////////////////////////////////
 111
 112   /** \relates IdString Stream output */
 113   std::ostream & operator<<( std::ostream & str, const IdString & obj );
 114
 115   /** \relates IdString Stream output */
 116   std::ostream & dumpOn( std::ostream & str, const IdString & obj );
 117
 118   /** \relates IdString Equal */
 119   inline bool operator==( const IdString & lhs, const IdString & rhs )
 120   { return lhs.compareEQ( rhs ); }
 121   /** \overload */
 122   inline bool operator==( const IdString & lhs, const char * rhs )
 123   { return lhs.compare( rhs ) == 0; }
 124   /** \overload */
 125   inline bool operator==( const IdString & lhs, const std::string & rhs )
 126   { return lhs.compare( rhs ) == 0; }
 127   /** \overload */
 128   inline bool operator==( const char * lhs, const IdString & rhs )
 129   { return rhs.compare( lhs ) == 0; }
 130   /** \overload */
 131   inline bool operator==( const std::string & lhs, const IdString & rhs )
 132   { return rhs.compare( lhs ) == 0; }
 133
 134   /** \relates IdString NotEqual */
 135   inline bool operator!=( const IdString & lhs, const IdString & rhs )
 136   { return ! lhs.compareEQ( rhs ); }
 137   /** \overload */
 138   inline bool operator!=( const IdString & lhs, const char * rhs )
 139   { return lhs.compare( rhs ) != 0; }
 140   /** \overload */
 141   inline bool operator!=( const IdString & lhs, const std::string & rhs )
 142   { return lhs.compare( rhs ) != 0; }
 143   /** \overload */
 144   inline bool operator!=( const char * lhs, const IdString & rhs )
 145   { return rhs.compare( lhs ) != 0; }
 146   /** \overload */
 147   inline bool operator!=( const std::string & lhs, const IdString & rhs )
 148   { return rhs.compare( lhs ) != 0; }
 149
 150   /** \relates IdString Less */
 151   inline bool operator<( const IdString & lhs, const IdString & rhs )
 152   { return lhs.compare( rhs ) < 0; }
 153   /** \overload */
 154   inline bool operator<( const IdString & lhs, const char * rhs )
 155   { return lhs.compare( rhs ) < 0; }
 156   /** \overload */
 157   inline bool operator<( const IdString & lhs, const std::string & rhs )
 158   { return lhs.compare( rhs ) < 0; }
 159   /** \overload */
 160   inline bool operator<( const char * lhs, const IdString & rhs )
 161   { return rhs.compare( lhs ) >= 0; }
 162   /** \overload */
 163   inline bool operator<( const std::string & lhs, const IdString & rhs )
 164   { return rhs.compare( lhs ) >= 0; }
 165
 166   /** \relates IdString LessEqual*/
 167   inline bool operator<=( const IdString & lhs, const IdString & rhs )
 168   { return lhs.compare( rhs ) <= 0; }
 169   /** \overload */
 170   inline bool operator<=( const IdString & lhs, const char * rhs )
 171   { return lhs.compare( rhs ) <= 0; }
 172   /** \overload */
 173   inline bool operator<=( const IdString & lhs, const std::string & rhs )
 174   { return lhs.compare( rhs ) <= 0; }
 175   /** \overload */
 176   inline bool operator<=( const char * lhs, const IdString & rhs )
 177   { return rhs.compare( lhs ) > 0; }
 178   /** \overload */
 179   inline bool operator<=( const std::string & lhs, const IdString & rhs )
 180   { return rhs.compare( lhs ) > 0; }
 181
 182   /** \relates IdString Greater */
 183   inline bool operator>( const IdString & lhs, const IdString & rhs )
 184   { return lhs.compare( rhs ) > 0; }
 185   /** \overload */
 186   inline bool operator>( const IdString & lhs, const char * rhs )
 187   { return lhs.compare( rhs ) > 0; }
 188   /** \overload */
 189   inline bool operator>( const IdString & lhs, const std::string & rhs )
 190   { return lhs.compare( rhs ) > 0; }
 191   /** \overload */
 192   inline bool operator>( const char * lhs, const IdString & rhs )
 193   { return rhs.compare( lhs ) <= 0; }
 194   /** \overload */
 195   inline bool operator>( const std::string & lhs, const IdString & rhs )
 196   { return rhs.compare( lhs ) <= 0; }
 197
 198   /** \relates IdString GreaterEqual */
 199   inline bool operator>=( const IdString & lhs, const IdString & rhs )
 200   { return lhs.compare( rhs ) >= 0; }
 201   /** \overload */
 202   inline bool operator>=( const IdString & lhs, const char * rhs )
 203   { return lhs.compare( rhs ) >= 0; }
 204   /** \overload */
 205   inline bool operator>=( const IdString & lhs, const std::string & rhs )
 206   { return lhs.compare( rhs ) >= 0; }
 207   /** \overload */
 208   inline bool operator>=( const char * lhs, const IdString & rhs )
 209   { return rhs.compare( lhs ) < 0; }
 210   /** \overload */
 211   inline bool operator>=( const std::string & lhs, const IdString & rhs )
 212   { return rhs.compare( lhs ) < 0; }
 213
 214   /////////////////////////////////////////////////////////////////
 215 } // namespace zypp
 216 ///////////////////////////////////////////////////////////////////
 217
 218 ZYPP_DEFINE_ID_HASHABLE( ::zypp::IdString );
 219
 220 #endif // ZYPP_SAT_IDSTR_H