libzypp  11.13.5
IdStringType.h
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 #ifndef ZYPP_IDSTRINGTYPE_H
13 #define ZYPP_IDSTRINGTYPE_H
14 
15 #include "zypp/IdString.h"
16 
18 namespace zypp
19 {
20 
22  //
23  // CLASS NAME : IdStringType<Derived>
24  //
85  template <class Derived>
86  class IdStringType : protected sat::detail::PoolMember,
87  private base::SafeBool<Derived>
88  {
89  typedef typename base::SafeBool<Derived>::bool_type bool_type;
90  public:
91  typedef IdString::IdType IdType;
92 
93  protected:
94  IdStringType() {}
95  IdStringType(const IdStringType &) {}
96  void operator=(const IdStringType &) {}
97  ~IdStringType() {}
98 
99  private:
100  const Derived & self() const { return *static_cast<const Derived*>( this ); }
101 
102  public:
103  const IdString & idStr() const { return self()._str; }
104 
105  bool empty() const { return idStr().empty(); }
106  unsigned size() const { return idStr().size(); }
107  const char * c_str() const { return idStr().c_str(); }
108  std::string asString() const { return idStr().asString(); }
109 
110  IdType id() const { return idStr().id(); }
111 
112  public:
113 #ifndef SWIG // Swig treats it as syntax error
114 
115  using base::SafeBool<Derived>::operator bool_type;
116 #endif
117  public:
118  // - break it down to idString/const char* <=> idString/cont char*
119  // - handle idString(0)/NULL being the least value
120  // - everything else goes to _doCompare (no NULL)
121  static int compare( const Derived & lhs, const Derived & rhs ) { return compare( lhs.idStr(), rhs.idStr() ); }
122  static int compare( const Derived & lhs, const IdString & rhs ) { return compare( lhs.idStr(), rhs ); }
123  static int compare( const Derived & lhs, const std::string & rhs ) { return compare( lhs.idStr(), rhs.c_str() ); }
124  static int compare( const Derived & lhs, const char * rhs ) { return compare( lhs.idStr(), rhs );}
125 
126  static int compare( const IdString & lhs, const Derived & rhs ) { return compare( lhs, rhs.idStr() ); }
127  static int compare( const IdString & lhs, const IdString & rhs ) { return lhs == rhs ? 0 : Derived::_doCompare( (lhs ? lhs.c_str() : (const char *)0 ),
128  (rhs ? rhs.c_str() : (const char *)0 ) ); }
129  static int compare( const IdString & lhs, const std::string & rhs ) { return compare( lhs, rhs.c_str() ); }
130  static int compare( const IdString & lhs, const char * rhs ) { return Derived::_doCompare( (lhs ? lhs.c_str() : (const char *)0 ), rhs ); }
131 
132  static int compare( const std::string & lhs, const Derived & rhs ) { return compare( lhs.c_str(), rhs.idStr() ); }
133  static int compare( const std::string & lhs, const IdString & rhs ) { return compare( lhs.c_str(), rhs ); }
134  static int compare( const std::string & lhs, const std::string & rhs ) { return compare( lhs.c_str(), rhs.c_str() ); }
135  static int compare( const std::string & lhs, const char * rhs ) { return compare( lhs.c_str(), rhs ); }
136 
137  static int compare( const char * lhs, const Derived & rhs ) { return compare( lhs, rhs.idStr() ); }
138  static int compare( const char * lhs, const IdString & rhs ) { return Derived::_doCompare( lhs, (rhs ? rhs.c_str() : (const char *)0 ) ); }
139  static int compare( const char * lhs, const std::string & rhs ) { return compare( lhs, rhs.c_str() ); }
140  static int compare( const char * lhs, const char * rhs ) { return Derived::_doCompare( lhs, rhs ); }
141 
142  public:
143  int compare( const Derived & rhs ) const { return compare( idStr(), rhs.idStr() ); }
144  int compare( const IdStringType & rhs ) const { return compare( idStr(), rhs.idStr() ); }
145  int compare( const IdString & rhs ) const { return compare( idStr(), rhs ); }
146  int compare( const std::string & rhs ) const { return compare( idStr(), rhs.c_str() ); }
147  int compare( const char * rhs ) const { return compare( idStr(), rhs ); }
148 
149  private:
150  static int _doCompare( const char * lhs, const char * rhs )
151  {
152  if ( ! lhs ) return rhs ? -1 : 0;
153  return rhs ? ::strcmp( lhs, rhs ) : 1;
154  }
155 
156  private:
157 #ifndef SWIG // Swig treats it as syntax error
158  friend base::SafeBool<Derived>::operator bool_type() const;
159 #endif
160  bool boolTest() const { return ! empty(); }
161  };
163 
165  template <class Derived>
166  inline std::ostream & operator<<( std::ostream & str, const IdStringType<Derived> & obj )
167  { return str << obj.c_str(); }
168 
170  template <class Derived>
171  inline bool operator==( const IdStringType<Derived> & lhs, const IdStringType<Derived> & rhs )
172  { return lhs.compare( rhs ) == 0; }
174  template <class Derived>
175  inline bool operator==( const IdStringType<Derived> & lhs, const IdString & rhs )
176  { return lhs.compare( rhs ) == 0; }
178  template <class Derived>
179  inline bool operator==( const IdStringType<Derived> & lhs, const char * rhs )
180  { return lhs.compare( rhs ) == 0; }
182  template <class Derived>
183  inline bool operator==( const IdStringType<Derived> & lhs, const std::string & rhs )
184  { return lhs.compare( rhs ) == 0; }
186  template <class Derived>
187  inline bool operator==( const IdString & lhs, const IdStringType<Derived> & rhs )
188  { return rhs.compare( lhs ) == 0; }
190  template <class Derived>
191  inline bool operator==( const char * lhs, const IdStringType<Derived> & rhs )
192  { return rhs.compare( lhs ) == 0; }
194  template <class Derived>
195  inline bool operator==( const std::string & lhs, const IdStringType<Derived> & rhs )
196  { return rhs.compare( lhs ) == 0; }
197 
199  template <class Derived>
200  inline bool operator!=( const IdStringType<Derived> & lhs, const IdStringType<Derived> & rhs )
201  { return lhs.compare( rhs ) != 0; }
203  template <class Derived>
204  inline bool operator!=( const IdStringType<Derived> & lhs, const IdString & rhs )
205  { return lhs.compare( rhs ) != 0; }
207  template <class Derived>
208  inline bool operator!=( const IdStringType<Derived> & lhs, const char * rhs )
209  { return lhs.compare( rhs ) != 0; }
211  template <class Derived>
212  inline bool operator!=( const IdStringType<Derived> & lhs, const std::string & rhs )
213  { return lhs.compare( rhs ) != 0; }
215  template <class Derived>
216  inline bool operator!=( const IdString & lhs, const IdStringType<Derived> & rhs )
217  { return rhs.compare( lhs ) != 0; }
219  template <class Derived>
220  inline bool operator!=( const char * lhs, const IdStringType<Derived> & rhs )
221  { return rhs.compare( lhs ) != 0; }
223  template <class Derived>
224  inline bool operator!=( const std::string & lhs, const IdStringType<Derived> & rhs )
225  { return rhs.compare( lhs ) != 0; }
226 
228  template <class Derived>
229  inline bool operator<( const IdStringType<Derived> & lhs, const IdStringType<Derived> & rhs )
230  { return lhs.compare( rhs ) < 0; }
232  template <class Derived>
233  inline bool operator<( const IdStringType<Derived> & lhs, const IdString & rhs )
234  { return lhs.compare( rhs ) < 0; }
236  template <class Derived>
237  inline bool operator<( const IdStringType<Derived> & lhs, const char * rhs )
238  { return lhs.compare( rhs ) < 0; }
240  template <class Derived>
241  inline bool operator<( const IdStringType<Derived> & lhs, const std::string & rhs )
242  { return lhs.compare( rhs ) < 0; }
244  template <class Derived>
245  inline bool operator<( const IdString & lhs, const IdStringType<Derived> & rhs )
246  { return rhs.compare( lhs ) >= 0; }
248  template <class Derived>
249  inline bool operator<( const char * lhs, const IdStringType<Derived> & rhs )
250  { return rhs.compare( lhs ) >= 0; }
252  template <class Derived>
253  inline bool operator<( const std::string & lhs, const IdStringType<Derived> & rhs )
254  { return rhs.compare( lhs ) >= 0; }
255 
257  template <class Derived>
258  inline bool operator<=( const IdStringType<Derived> & lhs, const IdStringType<Derived> & rhs )
259  { return lhs.compare( rhs ) <= 0; }
261  template <class Derived>
262  inline bool operator<=( const IdStringType<Derived> & lhs, const IdString & rhs )
263  { return lhs.compare( rhs ) <= 0; }
265  template <class Derived>
266  inline bool operator<=( const IdStringType<Derived> & lhs, const char * rhs )
267  { return lhs.compare( rhs ) <= 0; }
269  template <class Derived>
270  inline bool operator<=( const IdStringType<Derived> & lhs, const std::string & rhs )
271  { return lhs.compare( rhs ) <= 0; }
273  template <class Derived>
274  inline bool operator<=( const IdString & lhs, const IdStringType<Derived> & rhs )
275  { return rhs.compare( lhs ) > 0; }
277  template <class Derived>
278  inline bool operator<=( const char * lhs, const IdStringType<Derived> & rhs )
279  { return rhs.compare( lhs ) > 0; }
281  template <class Derived>
282  inline bool operator<=( const std::string & lhs, const IdStringType<Derived> & rhs )
283  { return rhs.compare( lhs ) > 0; }
284 
286  template <class Derived>
287  inline bool operator>( const IdStringType<Derived> & lhs, const IdStringType<Derived> & rhs )
288  { return lhs.compare( rhs ) > 0; }
290  template <class Derived>
291  inline bool operator>( const IdStringType<Derived> & lhs, const IdString & rhs )
292  { return lhs.compare( rhs ) > 0; }
294  template <class Derived>
295  inline bool operator>( const IdStringType<Derived> & lhs, const char * rhs )
296  { return lhs.compare( rhs ) > 0; }
298  template <class Derived>
299  inline bool operator>( const IdStringType<Derived> & lhs, const std::string & rhs )
300  { return lhs.compare( rhs ) > 0; }
302  template <class Derived>
303  inline bool operator>( const IdString & lhs, const IdStringType<Derived> & rhs )
304  { return rhs.compare( lhs ) <= 0; }
306  template <class Derived>
307  inline bool operator>( const char * lhs, const IdStringType<Derived> & rhs )
308  { return rhs.compare( lhs ) <= 0; }
310  template <class Derived>
311  inline bool operator>( const std::string & lhs, const IdStringType<Derived> & rhs )
312  { return rhs.compare( lhs ) <= 0; }
313 
315  template <class Derived>
316  inline bool operator>=( const IdStringType<Derived> & lhs, const IdStringType<Derived> & rhs )
317  { return lhs.compare( rhs ) >= 0; }
319  template <class Derived>
320  inline bool operator>=( const IdStringType<Derived> & lhs, const IdString & rhs )
321  { return lhs.compare( rhs ) >= 0; }
323  template <class Derived>
324  inline bool operator>=( const IdStringType<Derived> & lhs, const char * rhs )
325  { return lhs.compare( rhs ) >= 0; }
327  template <class Derived>
328  inline bool operator>=( const IdStringType<Derived> & lhs, const std::string & rhs )
329  { return lhs.compare( rhs ) >= 0; }
331  template <class Derived>
332  inline bool operator>=( const IdString & lhs, const IdStringType<Derived> & rhs )
333  { return rhs.compare( lhs ) < 0; }
335  template <class Derived>
336  inline bool operator>=( const char * lhs, const IdStringType<Derived> & rhs )
337  { return rhs.compare( lhs ) < 0; }
339  template <class Derived>
340  inline bool operator>=( const std::string & lhs, const IdStringType<Derived> & rhs )
341  { return rhs.compare( lhs ) < 0; }
342 
344 } // namespace zypp
346 #endif // ZYPP_IDSTRINGTYPE_H