00001 #ifndef __STRL_HPP__
00002 #define __STRL_HPP__
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031 #include <stdarg.h>
00032
00033 #include "string.hpp"
00034 #include "listt.hpp"
00035
00036
00037
00038 class StrList;
00039 class StrSet;
00040 class KVStrList;
00041
00042
00043
00044 class StrList {
00045 private:
00046 ListT<String> l;
00047
00048 public:
00049 BOOL owns(Lix p) const { return l.owns(p); }
00050 LIINT index (Lix p) const { return l.index(p); }
00051 Lix lix(LIINT i) const { return l.lix(i); }
00052 LIINT length(VOID) const { return l.length(); }
00053 BOOL empty(VOID) const { return l.empty(); }
00054 VOID clear( VOID ) { l.clear(); };
00055 VOID reverse(VOID) { l.reverse(); }
00056
00057 Lix first(VOID) const { return l.first(); }
00058 Lix last(VOID) const { return l.last(); }
00059 Lix next(Lix p) const { return l.next(p); }
00060 Lix prev(Lix p) const { return l.prev(p); }
00061
00062 StrList& operator = (const StrList& a) { l.operator=(a.l); return *this; }
00063
00064 Lix prepend(VOID) { return l.prepend(); }
00065 Lix append(VOID) { return l.append(); }
00066 Lix insbefore(Lix p) { return l.insbefore(p); }
00067 Lix insafter(Lix p) { return l.insafter(p); }
00068 Lix prepend(const String& d) { return l.prepend(d); }
00069 Lix append(const String& d) { return l.append(d); }
00070 Lix insbefore(Lix p, const String& d) { return l.insbefore(p,d); }
00071 Lix insafter(Lix p, const String& d) { return l.insafter(p,d); }
00072 Lix prepend(const StrList& a) { return l.prepend(a.l); }
00073 Lix append(const StrList& a) { return l.append(a.l); }
00074 Lix insbefore(Lix p, const StrList& a) { return l.insbefore(p,a.l); }
00075 Lix insafter(Lix p, const StrList& a) { return l.insafter(p,a.l); }
00076 Lix prepend_mv(StrList& a) { return l.prepend_mv(a.l); }
00077 Lix append_mv(StrList& a) { return l.append_mv(a.l); }
00078 Lix insbefore_mv(Lix p, StrList& a) { return l.insbefore_mv(p,a.l); }
00079 Lix insafter_mv(Lix p, StrList& a) { return l.insafter_mv(p,a.l); }
00080 Lix prepend(const char *d) { return l.prepend(String(d)); }
00081 Lix append(const char *d) { return l.append(String(d)); }
00082 Lix insbefore(Lix p, const char *d) { return l.insbefore(p,String(d)); }
00083 Lix insafter(Lix p, const char *d) { return l.insafter(p,String(d)); }
00084
00085 Lix del(Lix p, INT dir = 1) { return l.del(p,dir); }
00086 VOID delprev(Lix p) { l.delprev(p); }
00087 VOID delnext(Lix p) { l.delnext(p); }
00088 Lix delfirst(VOID) { return l.delfirst(); }
00089 Lix dellast(VOID) { return l.dellast(); }
00090
00091 const String& item(Lix p) const { return l.item(p); }
00092 const String& operator () (Lix p) const { return l.operator()(p); }
00093 const String& item_first(VOID) const { return l.item_first(); }
00094 const String& item_last(VOID) const { return l.item_last(); }
00095 String& item(Lix p) { return l.item(p); }
00096 String& item_first(VOID) { return l.item_first(); }
00097 String& item_last(VOID) { return l.item_last(); }
00098
00099 VOID exchange( Lix p1, Lix p2 ) { l.exchange(p1,p2); }
00100 VOID sortf( INT (*comparefunc) ( const String*item1, const String*item2 ))
00101 { l.sortf(comparefunc); }
00102
00103 Lix insbefore(LIINT i) { return l.insbefore(i); }
00104 Lix insbefore(LIINT i, const String& item) { return l.insbefore(i,item); }
00105 Lix insbefore(LIINT i, const StrList& a) { return l.insbefore(i,a.l); }
00106 Lix insbefore_mv(LIINT i, StrList& a) { return l.insbefore_mv(i,a.l); }
00107 Lix insafter(LIINT i) { return l.insafter(i); }
00108 Lix insafter(LIINT i, const String& item) { return l.insafter(i,item); }
00109 Lix insafter(LIINT i, const StrList& a) { return l.insafter(i,a.l); }
00110 Lix insafter_mv(LIINT i, StrList& a) { return l.insafter_mv(i,a.l); }
00111 VOID del(LIINT i) { l.del(i); }
00112 VOID delprev(LIINT i) { l.delprev(i); }
00113 VOID delnext(LIINT i) { l.delnext(i); }
00114 const String& item(LIINT i) const { return l.item(i); }
00115 const String& operator () (LIINT i) const { return l.operator()(i); }
00116 String& item(LIINT i) { return l.item(i); }
00117 VOID exchange( LIINT i1, LIINT i2 ) { l.exchange(i1,i2); }
00118
00119 #ifdef KK // $$$
00120 inline StrList& operator = (const StrSet& a);
00121 inline Lix prepend(const StrSet& a);
00122 inline Lix append(const StrSet& a);
00123 inline Lix insbefore(Lix p, const StrSet& a);
00124 inline Lix insafter(Lix p, const StrSet& a);
00125 inline Lix prepend_mv(StrSet& a);
00126 inline Lix append_mv(StrSet& a);
00127 inline Lix insbefore_mv(Lix p, StrSet& a);
00128 inline Lix insafter_mv(Lix p, StrSet& a);
00129 inline Lix insbefore(LIINT i, const StrSet& a);
00130 inline Lix insbefore_mv(LIINT i, StrSet& a);
00131 inline Lix insafter(LIINT i, const StrSet& a);
00132 inline Lix insafter_mv(LIINT i, StrSet& a);
00133 #endif
00134
00135 public:
00136 StrList( ) {};
00137 StrList( const StrList &a ) { l=a.l; };
00138 inline StrList( const StrSet &a );
00139 StrList( const char *words ) { append_s(words); }
00140 StrList( int dummy, const char *fwords, ... ) { (void)dummy; va_list v; va_start(v,fwords); append_s(fwords,v); va_end(v); }
00141 StrList( const char *fwords, va_list v ) { append_s(fwords,v); }
00142 StrList( const char *wordarray[] ) { append_s(wordarray); }
00143 StrList( char *wordarray[] ) { append_s(wordarray); }
00144
00145 VOID append_s( const char *words );
00146 VOID append_sf( const char *fwords, ... );
00147 VOID append_s( const char *fwords, va_list v );
00148 VOID append_s( const char *wordarray[] );
00149 VOID append_s( char* wordarray[]) {append_s((const char**)wordarray);}
00150
00151 VOID sort( BOOL reverse=FALSE );
00152 BOOL OK( VOID ) const;
00153
00154 friend class StrSet;
00155 friend class KVStrList;
00156 };
00157
00158 std::ostream& operator << (std::ostream &st, const StrList &l);
00159
00160
00161
00162 class StrSet {
00163 private:
00164 SetListT<String> l;
00165
00166 public:
00167 BOOL owns(Lix p) const { return l.owns(p); }
00168 LIINT index (Lix p) const { return l.index(p); }
00169 Lix lix(LIINT i) const { return l.lix(i); }
00170 LIINT length(VOID) const { return l.length(); }
00171 BOOL empty(VOID) const { return l.empty(); }
00172 VOID clear( VOID ) { l.clear(); };
00173 VOID reverse(VOID) { l.reverse(); }
00174
00175 Lix first(VOID) const { return l.first(); }
00176 Lix last(VOID) const { return l.last(); }
00177 Lix next(Lix p) const { return l.next(p); }
00178 Lix prev(Lix p) const { return l.prev(p); }
00179
00180 StrSet& operator = (const StrSet& a) { l.operator=(a.l); return *this; }
00181
00182 Lix _prepend(VOID) {return l._prepend();}
00183 Lix _append(VOID) {return l._append();}
00184 Lix _insbefore(Lix p) {return l._insbefore(p);}
00185 Lix _insafter(Lix p) {return l._insafter(p);}
00186 Lix _prepend(const String& d) {return l._prepend(d);}
00187 Lix _append(const String& d) {return l._append(d);}
00188 Lix _insbefore(Lix p, const String& d) {return l._insbefore(p,d);}
00189 Lix _insafter(Lix p, const String& d) {return l._insafter(p,d);}
00190 Lix _prepend(const StrSet& a) {return l._prepend(a.l);}
00191 Lix _append(const StrSet& a) {return l._append(a.l);}
00192 Lix _insbefore(Lix p, const StrSet& a) {return l._insbefore(p,a.l);}
00193 Lix _insafter(Lix p, const StrSet& a) {return l._insafter(p,a.l);}
00194 Lix _prepend_mv(StrSet& a) {return l._prepend_mv(a.l);}
00195 Lix _append_mv(StrSet& a) {return l._append_mv(a.l);}
00196 Lix _insbefore_mv(Lix p, StrSet& a) {return l._insbefore_mv(p,a.l);}
00197 Lix _insafter_mv(Lix p, StrSet& a) {return l._insafter_mv(p,a.l);}
00198 Lix _prepend(const char *d) { return l._prepend(String(d)); }
00199 Lix _append(const char *d) { return l._append(String(d)); }
00200 Lix _insbefore(Lix p, const char *d) { return l._insbefore(p,String(d)); }
00201 Lix _insafter(Lix p, const char *d) { return l._insafter(p,String(d)); }
00202
00203 Lix del(Lix p, INT dir = 1) {return l.del(p,dir);}
00204 VOID delprev(Lix p) {l.delprev(p);}
00205 VOID delnext(Lix p) {l.delnext(p);}
00206 Lix delfirst(VOID) {return l.delfirst();}
00207 Lix dellast(VOID) {return l.dellast();}
00208
00209 const String& item(Lix p) const {return l.item(p);}
00210 const String& operator () (Lix p) const {return l.operator()(p);}
00211 const String& item_first(VOID) const {return l.item_first();}
00212 const String& item_last(VOID) const {return l.item_last();}
00213 String& _item(Lix p) {return l._item(p);}
00214 String& _item_first(VOID) {return l._item_first();}
00215 String& _item_last(VOID) {return l._item_last();}
00216
00217 VOID exchange( Lix p1, Lix p2 ) {l.exchange(p1,p2);}
00218 VOID sortf( INT (*comparefunc) ( const String*item1, const String*item2 ))
00219 {l.sortf(comparefunc);}
00220
00221 Lix add(const String& x) {return l.add(x);}
00222 VOID add(const StrSet& a) {l.add(a.l);}
00223 VOID add_mv(StrSet& a, BOOL ovwrt) {l.add_mv(a.l,0,0,ovwrt);}
00224 Lix add(const char * x) {return l.add(String(x));}
00225
00226 Lix seek(const String& x) const {return l.seek(x);}
00227 BOOL contains(const String& x) const {return l.contains(x);}
00228 BOOL contains(const StrSet&a) const {return l.contains(a.l);}
00229 BOOL contains(const char * x) const {return l.contains(String(x));}
00230 BOOL equals(const StrSet&a, BOOL allowrep=TRUE) const {return l.equals(a.l,allowrep);}
00231 BOOL erase(const String & x) {return l.erase(x);}
00232 BOOL erase(const StrSet& a) {return l.erase(a.l);}
00233 BOOL erase(const char * x) {return l.erase(String(x));}
00234 VOID keep(const StrSet& a) {l.keep(a.l);}
00235
00236 Lix _insbefore(LIINT i) {return l._insbefore(i);}
00237 Lix _insbefore(LIINT i, const String& item) {return l._insbefore(i,item);}
00238 Lix _insbefore(LIINT i, const StrSet& a) {return l._insbefore(i,a.l);}
00239 Lix _insbefore_mv(LIINT i, StrSet& a) {return l._insbefore_mv(i,a.l);}
00240 Lix _insbefore(LIINT i, const char * item) {return l._insbefore(i,String(item));}
00241 Lix _insafter(LIINT i) {return l._insafter(i);}
00242 Lix _insafter(LIINT i, const String& item) {return l._insafter(i,item);}
00243 Lix _insafter(LIINT i, const StrSet& a) {return l._insafter(i,a.l);}
00244 Lix _insafter_mv(LIINT i, StrSet& a) {return l._insafter_mv(i,a.l);}
00245 Lix _insafter(LIINT i, const char *item) {return l._insafter(i,String(item));}
00246 VOID del(LIINT i) {l.del(i);}
00247 VOID delprev(LIINT i) {l.delprev(i);}
00248 VOID delnext(LIINT i) {l.delnext(i);}
00249 const String& item(LIINT i) const {return l.item(i);}
00250 const String& operator () (LIINT i) const {return l.operator()(i);}
00251 String& _item(LIINT i) {return l._item(i);}
00252 VOID exchange( LIINT i1, LIINT i2 ) {l.exchange(i1,i2);}
00253
00254 StrSet& operator = (const StrList& a) {l.operator=(a.l); return *this;}
00255 Lix _prepend(const StrList& a) {return l._prepend(a.l);}
00256 Lix _append(const StrList& a) {return l._append(a.l);}
00257 Lix _insbefore(Lix p, const StrList& a) {return l._insbefore(p,a.l);}
00258 Lix _insafter(Lix p, const StrList& a) {return l._insafter(p,a.l);}
00259 Lix _prepend_mv(StrList& a) {return l._prepend_mv(a.l);}
00260 Lix _append_mv(StrList& a) {return l._append_mv(a.l);}
00261 Lix _insbefore_mv(Lix p, StrList& a) {return l._insbefore_mv(p,a.l);}
00262 Lix _insafter_mv(Lix p, StrList& a) {return l._insafter_mv(p,a.l);}
00263 VOID add(const StrList& a) {l.add(a.l);}
00264 VOID add_mv(StrList& a, BOOL ovwrt) {l.add_mv(a.l,0,0,ovwrt);}
00265 BOOL contains(const StrList&a) const {return l.contains(a.l);}
00266 BOOL equals(const StrList&a, BOOL allowrep=TRUE) const {return l.equals(a.l,allowrep);}
00267 BOOL erase(const StrList& a) {return l.erase(a.l);}
00268 VOID keep(const StrList& a) {l.keep(a.l);}
00269 Lix _insbefore(LIINT i, const StrList& a) {return l._insbefore(i,a.l);}
00270 Lix _insbefore_mv(LIINT i, StrList& a) {return l._insbefore_mv(i,a.l);}
00271 Lix _insafter(LIINT i, const StrList& a) {return l._insafter(i,a.l);}
00272 Lix _insafter_mv(LIINT i, StrList& a) {return l._insafter_mv(i,a.l);}
00273
00274 public:
00275 StrSet() {};
00276 StrSet( const StrList &a ) { l=a.l; };
00277 StrSet( const StrSet &a ) { l=a.l; };
00278 StrSet( const char *words ) { add_s(words); }
00279 StrSet( int dummy, const char *fwords, ... ) { (void)dummy; va_list v; va_start(v,fwords); add_s(fwords,v); va_end(v); }
00280 StrSet( const char *fwords, va_list v ) { add_s(fwords,v); }
00281 StrSet( const char *wordarray[] ) { add_s(wordarray); }
00282 StrSet( char *wordarray[] ) { add_s(wordarray); }
00283
00284 VOID add_s( const char *fwords );
00285 VOID add_sf( const char *fwords, ... );
00286 VOID add_s( const char *fwords, va_list v );
00287 VOID add_s( const char *wordarray[] );
00288 VOID add_s( char* wordarray[] ) {add_s((const char**)wordarray);}
00289
00290 VOID sort( BOOL reverse=FALSE );
00291 BOOL OK( VOID ) const;
00292
00293 friend class StrList;
00294 friend class KVStrList;
00295 };
00296
00297 std::ostream& operator << (std::ostream &st, const StrSet &l);
00298
00299
00300
00301 class KVStrList {
00302 private:
00303 KeyValListT<String,String> l;
00304
00305 public:
00306 BOOL owns(Lix p) const { return l.owns(p); }
00307 LIINT index (Lix p) const { return l.index(p); }
00308 Lix lix(LIINT i) const { return l.lix(i); }
00309 LIINT length(VOID) const { return l.length(); }
00310 BOOL empty(VOID) const { return l.empty(); }
00311 VOID clear( VOID ) { l.clear(); };
00312 VOID reverse(VOID) { l.reverse(); }
00313
00314 Lix first(VOID) const { return l.first(); }
00315 Lix last(VOID) const { return l.last(); }
00316 Lix next(Lix p) const { return l.next(p); }
00317 Lix prev(Lix p) const { return l.prev(p); }
00318
00319 KVStrList & operator = (const KVStrList & a) { l.operator=(a.l); return *this; }
00320
00321 Lix _prepend(VOID) {return l._prepend();}
00322 Lix _append(VOID) {return l._append();}
00323 Lix _insbefore(Lix p) {return l._insbefore(p);}
00324 Lix _insafter(Lix p) {return l._insafter(p);}
00325 Lix _prepend(const String& k, const String &v) {return l._prepend(k,v);}
00326 Lix _append(const String& k, const String &v) {return l._append(k,v);}
00327 Lix _insbefore(Lix p, const String& k, const String &v) {return l._insbefore(p,k,v);}
00328 Lix _insafter(Lix p, const String& k, const String &v) {return l._insafter(p,k,v);}
00329 Lix _prepend(const KVStrList & a) {return l._prepend(a.l);}
00330 Lix _append(const KVStrList & a) {return l._append(a.l);}
00331 Lix _insbefore(Lix p, const KVStrList & a) {return l._insbefore(p,a.l);}
00332 Lix _insafter(Lix p, const KVStrList & a) {return l._insafter(p,a.l);}
00333 Lix _prepend_mv(KVStrList & a) {return l._prepend_mv(a.l);}
00334 Lix _append_mv(KVStrList & a) {return l._append_mv(a.l);}
00335 Lix _insbefore_mv(Lix p, KVStrList & a) {return l._insbefore_mv(p,a.l);}
00336 Lix _insafter_mv(Lix p, KVStrList & a) {return l._insafter_mv(p,a.l);}
00337
00338 Lix del(Lix p, INT dir = 1) {return l.del(p,dir);}
00339 VOID delprev(Lix p) {l.delprev(p);}
00340 VOID delnext(Lix p) {l.delnext(p);}
00341 Lix delfirst(VOID) {return l.delfirst();}
00342 Lix dellast(VOID) {return l.dellast();}
00343
00344 const String& itemkey(Lix p) const {return l.itemkey(p);}
00345 const String& itemkey_first(VOID) const {return l.itemkey_first();}
00346 const String& itemkey_last(VOID) const {return l.itemkey_last();}
00347 String& _itemkey(Lix p) {return l._itemkey(p);}
00348 String& _itemkey_first(VOID) {return l._itemkey_first();}
00349 String& _itemkey_last(VOID) {return l._itemkey_last();}
00350
00351 const String& itemval(Lix p) const {return l.itemval(p);}
00352 const String& itemval_first(VOID) const {return l.itemval_first();}
00353 const String& itemval_last(VOID) const {return l.itemval_last();}
00354 String& itemval(Lix p) {return l.itemval(p);}
00355 String& itemval_first(VOID) {return l.itemval_first();}
00356 String& itemval_last(VOID) {return l.itemval_last();}
00357
00358 VOID exchange( Lix p1, Lix p2 ) {l.exchange(p1,p2);}
00359 VOID sortf( INT (*comparefunc) ( const String*item1, const String*item2 ))
00360 {l.sortf(comparefunc);}
00361
00362 Lix add(const String& k, const String &v) {return l.add(k,v);}
00363 VOID add(const KVStrList & a) {l.add(a.l);}
00364 VOID add_mv(KVStrList & a, BOOL ovwrt) {l.add_mv(a.l,0,0,ovwrt);}
00365
00366 Lix seek(const String& k) const {return l.seek(k);}
00367 BOOL contains(const String& k) const {return l.contains(k);}
00368 BOOL contains(const KVStrList &a) const {return l.contains(a.l);}
00369 BOOL contains(const char *k) const {return l.contains(String(k));}
00370 BOOL equals(const KVStrList &a, BOOL allowrep=TRUE) const {return l.equals(a.l,allowrep);}
00371 BOOL erase(const String & k) {return l.erase(k);}
00372 BOOL erase(const KVStrList & a) {return l.erase(a.l);}
00373 BOOL erase(const char * k) {return l.erase(String(k));}
00374 VOID keep(const KVStrList & a) {l.keep(a.l);}
00375
00376 const String& val( const String& key ) const;
00377 const String& val( const String& key, const String& defval ) const { return l.val(key,defval); }
00378
00379 Lix _insbefore(LIINT i) {return l._insbefore(i);}
00380 Lix _insbefore(LIINT i, const String& k, const String& v) {return l._insbefore(i,k,v);}
00381 Lix _insbefore(LIINT i, const KVStrList & a) {return l._insbefore(i,a.l);}
00382 Lix _insbefore_mv(LIINT i, KVStrList & a) {return l._insbefore_mv(i,a.l);}
00383 Lix _insafter(LIINT i) {return l._insafter(i);}
00384 Lix _insafter(LIINT i, const String& k, const String& v) {return l._insafter(i,k,v);}
00385 Lix _insafter(LIINT i, const KVStrList & a) {return l._insafter(i,a.l);}
00386 Lix _insafter_mv(LIINT i, KVStrList & a) {return l._insafter_mv(i,a.l);}
00387 VOID del(LIINT i) {l.del(i);}
00388 VOID delprev(LIINT i) {l.delprev(i);}
00389 VOID delnext(LIINT i) {l.delnext(i);}
00390 const String& itemkey(LIINT i) const {return l.itemkey(i);}
00391 String& _itemkey(LIINT i) {return l._itemkey(i);}
00392 const String& itemval(LIINT i) const {return l.itemval(i);}
00393 String& itemval(LIINT i) {return l.itemval(i);}
00394 VOID exchange( LIINT i1, LIINT i2 ) {l.exchange(i1,i2);}
00395
00396 BOOL contains(const StrList&a) const {return l.contains(a.l);}
00397 BOOL equals(const StrList&a, BOOL allowrep=TRUE) const {return l.equals(a.l,allowrep);}
00398 BOOL erase(const StrList& a) {return l.erase(a.l);}
00399 VOID keep(const StrList& a) {l.keep(a.l);}
00400 BOOL contains(const StrSet&a) const {return l.contains(a.l);}
00401 BOOL equals(const StrSet&a, BOOL allowrep=TRUE) const {return l.equals(a.l,allowrep);}
00402 BOOL erase(const StrSet& a) {return l.erase(a.l);}
00403 VOID keep(const StrSet& a) {l.keep(a.l);}
00404
00405 protected:
00406 static int toi( const String &k, const String &v );
00407 static long tol( const String &k, const String &v );
00408 static float tof( const String &k, const String &v);
00409 static double tod( const String &k, const String &v );
00410 static BOOL tob( const String &k, const String &v );
00411 public:
00412 KVStrList ( ) {};
00413 KVStrList ( const KVStrList &p) { l=p.l; }
00414 KVStrList ( const char *words, const char* sep="=" ) { add_s(words,sep); }
00415 KVStrList ( int dummy, const char *fwords, const char* sep="=", ... ) { (void)dummy; va_list v; va_start(v,sep); add_s(fwords,sep,v); va_end(v); }
00416 KVStrList ( const char *fwords, const char* sep, va_list v ) { add_s(fwords,sep,v); }
00417 KVStrList ( const char *wordarray[], const char*sep=" =\t\n") { add_s(wordarray,sep); }
00418 KVStrList ( char* wordarray[], const char*sep=" =\t\n") { add_s(wordarray,sep); }
00419
00420 const char *cval( const String &k ) const { return val(k); }
00421 int ival( const String &k ) const { return toi(k,val(k)); }
00422 long lval( const String &k ) const { return tol(k,val(k)); }
00423 float fval( const String &k ) const { return tof(k,val(k)); }
00424 double dval( const String &k ) const { return tod(k,val(k)); }
00425 BOOL bval( const String &k ) const { return tob(k,val(k)); }
00426
00427 const char *val( const String &k, const char *vdef ) const;
00428 const char *cval( const String &k, const char *vdef ) const { return val(k,vdef); }
00429 int ival( const String &k, int def ) const;
00430 long lval( const String &k, long def ) const;
00431 float fval( const String &k, float def ) const;
00432 double dval( const String &k, double def ) const;
00433 BOOL bval( const String &k, BOOL def ) const;
00434 BOOL bbval( const String &k ) const { return bval(k,FALSE); }
00435
00436 Lix addc( const String &k, const char* s ) { return add(k,s); }
00437 Lix addi( const String &k, int val );
00438 Lix addui( const String &k, unsigned int val );
00439 Lix addl( const String &k, long val );
00440 Lix addf( const String &k, float val );
00441 Lix addd( const String &k, double val );
00442 Lix addb( const String &k, BOOL val );
00443
00444 Lix add( const String &k, int val ) { return addi(k,val); }
00445 Lix add( const String &k, unsigned int val ) { return addui(k,val); }
00446 Lix add( const String &k, long val ) { return addl(k,val); }
00447 Lix add( const String &k, float val ) { return addf(k,val); }
00448 Lix add( const String &k, double val ) { return addd(k,val); }
00449
00450 VOID add_prefix( const String &prefix );
00451 VOID remove_prefix( const String &prefix );
00452
00453 VOID add_s( const char *words, const char* sep="=" );
00454 VOID add_sf( const char *fwords, const char* sep="=", ... );
00455 VOID add_s( const char *fwords, const char* sep, va_list v );
00456 VOID add_s( const char *wordarray[], const char*sep=" =\t\n");
00457 VOID add_s( char* wordarray[], const char*sep=" =\t\n") {add_s((const char**)wordarray,sep);}
00458
00459 VOID sort( BOOL reverse=FALSE );
00460 BOOL OK( VOID ) const;
00461
00462 friend VOID clargs2props( int argc, char *argv[], KVStrList &props,
00463 StrList &files, const char *format, const char *options,
00464 const char *date );
00465 };
00466
00467 std::ostream& operator << (std::ostream &st, const KVStrList &l);
00468
00469
00470
00471 VOID clargs2props( int argc, char *argv[], KVStrList &props,
00472 StrList &files, const char *format, const char *options="",
00473 const char *date=__DATE__ );
00474
00475
00476
00477 #ifdef KK // $$$
00478 inline StrList::StrList( const StrSet &a ) { l=a.l; };
00479 inline StrList& StrList::operator = (const StrSet& a) { l.operator=(a.l); return *this; }
00480 inline Lix StrList::prepend(const StrSet& a) { return l.prepend(a.l); }
00481 inline Lix StrList::append(const StrSet& a) { return l.append(a.l); }
00482 inline Lix StrList::insbefore(Lix p, const StrSet& a) { return l.insbefore(p,a.l); }
00483 inline Lix StrList::insafter(Lix p, const StrSet& a) { return l.insafter(p,a.l); }
00484 inline Lix StrList::prepend_mv(StrSet& a) { return l.prepend_mv(a.l); }
00485 inline Lix StrList::append_mv(StrSet& a) { return l.append_mv(a.l); }
00486 inline Lix StrList::insbefore_mv(Lix p, StrSet& a) { return l.insbefore_mv(p,a.l); }
00487 inline Lix StrList::insafter_mv(Lix p, StrSet& a) { return l.insafter_mv(p,a.l); }
00488 inline Lix StrList::insbefore(LIINT i, const StrSet& a) { return l.insbefore(i,a.l); }
00489 inline Lix StrList::insbefore_mv(LIINT i, StrSet& a) { return l.insbefore_mv(i,a.l); }
00490 inline Lix StrList::insafter(LIINT i, const StrSet& a) { return l.insafter(i,a.l); }
00491 inline Lix StrList::insafter_mv(LIINT i, StrSet& a) { return l.insafter_mv(i,a.l); }
00492 #endif
00493
00494
00495
00496 #endif
