1 /*---------------------------------------------------------------------\
3 | |__ / \ / / . \ . \ |
8 \---------------------------------------------------------------------*/
9 /** \file zypp/IdStringType.h
12 #ifndef ZYPP_IDSTRINGTYPE_H
13 #define ZYPP_IDSTRINGTYPE_H
15 #include "zypp/IdString.h"
17 ///////////////////////////////////////////////////////////////////
19 { /////////////////////////////////////////////////////////////////
21 ///////////////////////////////////////////////////////////////////
23 // CLASS NAME : IdStringType<Derived>
25 /** Base class for creating \ref IdString based types.
27 * Just by deriving from \ref IdStringType a class provides all
28 * the operations an \ref IdString does. (incl. conversion to string types,
29 * comparison of string types and stream output).
31 * To disable any comparison, declare (but do not define) \ref _doCompare
34 * class NoCompare : public IdStringType<NoCompare>
37 * static int _doCompare( const char * lhs, const char * rhs );
42 * If you need a different than the default lexicographical
43 * order, write your own \ref _doCompare.
46 * // uses default lexicographical order
47 * class CaseCmp : public IdStringType<CaseCmp>
51 * explicit CaseCmp( const char * cstr_r ) : _str( cstr_r ) {}
53 * friend class IdStringType<CaseCmp>;
57 * // uses case insensitive comparison order
58 * class NoCaseCmp : public IdStringType<NoCaseCmp>
62 * explicit NoCaseCmp( const char * cstr_r ) : _str( cstr_r ) {}
64 * static int _doCompare( const char * lhs, const char * rhs )
66 * if ( lhs == rhs ) return 0;
67 * if ( lhs && rhs ) return ::strcasecmp( lhs, rhs );
68 * return( lhs ? 1 : -1 );
71 * friend class IdStringType<NoCaseCmp>;
76 * NoCaseCmp na( "a" );
77 * DBG << "ca == a ? " << (ca == "a") << endl; // ca == a ? 1
78 * DBG << "ca == A ? " << (ca == "A") << endl; // ca == A ? 0
79 * DBG << "na == a ? " << (na == "a") << endl; // na == a ? 1
80 * DBG << "na == A ? " << (na == "A") << endl; // na == A ? 1
82 * \todo allow redefinition of order vis _doCompare not only for char* but on any level
85 template <class Derived>
86 class IdStringType : protected sat::detail::PoolMember
89 typedef IdString::IdType IdType;
93 IdStringType(const IdStringType &) {}
94 void operator=(const IdStringType &) {}
98 const Derived & self() const { return *static_cast<const Derived*>( this ); }
101 const IdString & idStr() const { return self()._str; }
103 bool empty() const { return idStr().empty(); }
104 unsigned size() const { return idStr().size(); }
105 const char * c_str() const { return idStr().c_str(); }
106 std::string asString() const { return idStr().asString(); }
108 IdType id() const { return idStr().id(); }
111 /** Evaluate in a boolean context <tt>( ! empty() )</tt>. */
112 explicit operator bool() const
113 { return ! empty(); }
116 // - break it down to idString/const char* <=> idString/cont char*
117 // - handle idString(0)/NULL being the least value
118 // - everything else goes to _doCompare (no NULL)
119 static int compare( const Derived & lhs, const Derived & rhs ) { return compare( lhs.idStr(), rhs.idStr() ); }
120 static int compare( const Derived & lhs, const IdString & rhs ) { return compare( lhs.idStr(), rhs ); }
121 static int compare( const Derived & lhs, const std::string & rhs ) { return compare( lhs.idStr(), rhs.c_str() ); }
122 static int compare( const Derived & lhs, const char * rhs ) { return compare( lhs.idStr(), rhs );}
124 static int compare( const IdString & lhs, const Derived & rhs ) { return compare( lhs, rhs.idStr() ); }
125 static int compare( const IdString & lhs, const IdString & rhs ) { return lhs == rhs ? 0 : Derived::_doCompare( (lhs ? lhs.c_str() : (const char *)0 ),
126 (rhs ? rhs.c_str() : (const char *)0 ) ); }
127 static int compare( const IdString & lhs, const std::string & rhs ) { return compare( lhs, rhs.c_str() ); }
128 static int compare( const IdString & lhs, const char * rhs ) { return Derived::_doCompare( (lhs ? lhs.c_str() : (const char *)0 ), rhs ); }
130 static int compare( const std::string & lhs, const Derived & rhs ) { return compare( lhs.c_str(), rhs.idStr() ); }
131 static int compare( const std::string & lhs, const IdString & rhs ) { return compare( lhs.c_str(), rhs ); }
132 static int compare( const std::string & lhs, const std::string & rhs ) { return compare( lhs.c_str(), rhs.c_str() ); }
133 static int compare( const std::string & lhs, const char * rhs ) { return compare( lhs.c_str(), rhs ); }
135 static int compare( const char * lhs, const Derived & rhs ) { return compare( lhs, rhs.idStr() ); }
136 static int compare( const char * lhs, const IdString & rhs ) { return Derived::_doCompare( lhs, (rhs ? rhs.c_str() : (const char *)0 ) ); }
137 static int compare( const char * lhs, const std::string & rhs ) { return compare( lhs, rhs.c_str() ); }
138 static int compare( const char * lhs, const char * rhs ) { return Derived::_doCompare( lhs, rhs ); }
141 int compare( const Derived & rhs ) const { return compare( idStr(), rhs.idStr() ); }
142 int compare( const IdStringType & rhs ) const { return compare( idStr(), rhs.idStr() ); }
143 int compare( const IdString & rhs ) const { return compare( idStr(), rhs ); }
144 int compare( const std::string & rhs ) const { return compare( idStr(), rhs.c_str() ); }
145 int compare( const char * rhs ) const { return compare( idStr(), rhs ); }
148 static int _doCompare( const char * lhs, const char * rhs )
150 if ( ! lhs ) return rhs ? -1 : 0;
151 return rhs ? ::strcmp( lhs, rhs ) : 1;
154 ///////////////////////////////////////////////////////////////////
156 /** \relates IdStringType Stream output */
157 template <class Derived>
158 inline std::ostream & operator<<( std::ostream & str, const IdStringType<Derived> & obj )
159 { return str << obj.c_str(); }
161 /** \relates IdStringType Equal */
162 template <class Derived>
163 inline bool operator==( const IdStringType<Derived> & lhs, const IdStringType<Derived> & rhs )
164 { return lhs.compare( rhs ) == 0; }
166 template <class Derived>
167 inline bool operator==( const IdStringType<Derived> & lhs, const IdString & rhs )
168 { return lhs.compare( rhs ) == 0; }
170 template <class Derived>
171 inline bool operator==( const IdStringType<Derived> & lhs, const char * rhs )
172 { return lhs.compare( rhs ) == 0; }
174 template <class Derived>
175 inline bool operator==( const IdStringType<Derived> & lhs, const std::string & rhs )
176 { return lhs.compare( rhs ) == 0; }
178 template <class Derived>
179 inline bool operator==( const IdString & lhs, const IdStringType<Derived> & rhs )
180 { return rhs.compare( lhs ) == 0; }
182 template <class Derived>
183 inline bool operator==( const char * lhs, const IdStringType<Derived> & rhs )
184 { return rhs.compare( lhs ) == 0; }
186 template <class Derived>
187 inline bool operator==( const std::string & lhs, const IdStringType<Derived> & rhs )
188 { return rhs.compare( lhs ) == 0; }
190 /** \relates IdStringType NotEqual */
191 template <class Derived>
192 inline bool operator!=( const IdStringType<Derived> & lhs, const IdStringType<Derived> & rhs )
193 { return lhs.compare( rhs ) != 0; }
195 template <class Derived>
196 inline bool operator!=( const IdStringType<Derived> & lhs, const IdString & rhs )
197 { return lhs.compare( rhs ) != 0; }
199 template <class Derived>
200 inline bool operator!=( const IdStringType<Derived> & lhs, const char * rhs )
201 { return lhs.compare( rhs ) != 0; }
203 template <class Derived>
204 inline bool operator!=( const IdStringType<Derived> & lhs, const std::string & rhs )
205 { return lhs.compare( rhs ) != 0; }
207 template <class Derived>
208 inline bool operator!=( const IdString & lhs, const IdStringType<Derived> & rhs )
209 { return rhs.compare( lhs ) != 0; }
211 template <class Derived>
212 inline bool operator!=( const char * lhs, const IdStringType<Derived> & rhs )
213 { return rhs.compare( lhs ) != 0; }
215 template <class Derived>
216 inline bool operator!=( const std::string & lhs, const IdStringType<Derived> & rhs )
217 { return rhs.compare( lhs ) != 0; }
219 /** \relates IdStringType Less */
220 template <class Derived>
221 inline bool operator<( const IdStringType<Derived> & lhs, const IdStringType<Derived> & rhs )
222 { return lhs.compare( rhs ) < 0; }
224 template <class Derived>
225 inline bool operator<( const IdStringType<Derived> & lhs, const IdString & rhs )
226 { return lhs.compare( rhs ) < 0; }
228 template <class Derived>
229 inline bool operator<( const IdStringType<Derived> & lhs, const char * rhs )
230 { return lhs.compare( rhs ) < 0; }
232 template <class Derived>
233 inline bool operator<( const IdStringType<Derived> & lhs, const std::string & rhs )
234 { return lhs.compare( rhs ) < 0; }
236 template <class Derived>
237 inline bool operator<( const IdString & lhs, const IdStringType<Derived> & rhs )
238 { return rhs.compare( lhs ) >= 0; }
240 template <class Derived>
241 inline bool operator<( const char * lhs, const IdStringType<Derived> & rhs )
242 { return rhs.compare( lhs ) >= 0; }
244 template <class Derived>
245 inline bool operator<( const std::string & lhs, const IdStringType<Derived> & rhs )
246 { return rhs.compare( lhs ) >= 0; }
248 /** \relates IdStringType LessEqual */
249 template <class Derived>
250 inline bool operator<=( const IdStringType<Derived> & lhs, const IdStringType<Derived> & rhs )
251 { return lhs.compare( rhs ) <= 0; }
253 template <class Derived>
254 inline bool operator<=( const IdStringType<Derived> & lhs, const IdString & rhs )
255 { return lhs.compare( rhs ) <= 0; }
257 template <class Derived>
258 inline bool operator<=( const IdStringType<Derived> & lhs, const char * rhs )
259 { return lhs.compare( rhs ) <= 0; }
261 template <class Derived>
262 inline bool operator<=( const IdStringType<Derived> & lhs, const std::string & rhs )
263 { return lhs.compare( rhs ) <= 0; }
265 template <class Derived>
266 inline bool operator<=( const IdString & lhs, const IdStringType<Derived> & rhs )
267 { return rhs.compare( lhs ) > 0; }
269 template <class Derived>
270 inline bool operator<=( const char * lhs, const IdStringType<Derived> & rhs )
271 { return rhs.compare( lhs ) > 0; }
273 template <class Derived>
274 inline bool operator<=( const std::string & lhs, const IdStringType<Derived> & rhs )
275 { return rhs.compare( lhs ) > 0; }
277 /** \relates IdStringType Greater */
278 template <class Derived>
279 inline bool operator>( const IdStringType<Derived> & lhs, const IdStringType<Derived> & rhs )
280 { return lhs.compare( rhs ) > 0; }
282 template <class Derived>
283 inline bool operator>( const IdStringType<Derived> & lhs, const IdString & rhs )
284 { return lhs.compare( rhs ) > 0; }
286 template <class Derived>
287 inline bool operator>( const IdStringType<Derived> & lhs, const char * rhs )
288 { return lhs.compare( rhs ) > 0; }
290 template <class Derived>
291 inline bool operator>( const IdStringType<Derived> & lhs, const std::string & rhs )
292 { return lhs.compare( rhs ) > 0; }
294 template <class Derived>
295 inline bool operator>( const IdString & lhs, const IdStringType<Derived> & rhs )
296 { return rhs.compare( lhs ) <= 0; }
298 template <class Derived>
299 inline bool operator>( const char * lhs, const IdStringType<Derived> & rhs )
300 { return rhs.compare( lhs ) <= 0; }
302 template <class Derived>
303 inline bool operator>( const std::string & lhs, const IdStringType<Derived> & rhs )
304 { return rhs.compare( lhs ) <= 0; }
306 /** \relates IdStringType GreaterEqual */
307 template <class Derived>
308 inline bool operator>=( const IdStringType<Derived> & lhs, const IdStringType<Derived> & rhs )
309 { return lhs.compare( rhs ) >= 0; }
311 template <class Derived>
312 inline bool operator>=( const IdStringType<Derived> & lhs, const IdString & rhs )
313 { return lhs.compare( rhs ) >= 0; }
315 template <class Derived>
316 inline bool operator>=( const IdStringType<Derived> & lhs, const char * rhs )
317 { return lhs.compare( rhs ) >= 0; }
319 template <class Derived>
320 inline bool operator>=( const IdStringType<Derived> & lhs, const std::string & rhs )
321 { return lhs.compare( rhs ) >= 0; }
323 template <class Derived>
324 inline bool operator>=( const IdString & lhs, const IdStringType<Derived> & rhs )
325 { return rhs.compare( lhs ) < 0; }
327 template <class Derived>
328 inline bool operator>=( const char * lhs, const IdStringType<Derived> & rhs )
329 { return rhs.compare( lhs ) < 0; }
331 template <class Derived>
332 inline bool operator>=( const std::string & lhs, const IdStringType<Derived> & rhs )
333 { return rhs.compare( lhs ) < 0; }
335 /////////////////////////////////////////////////////////////////
337 ///////////////////////////////////////////////////////////////////
338 #endif // ZYPP_IDSTRINGTYPE_H