uniconf/uniconf.cc

   1 /*
   2  * Worldvisions Weaver Software:
   3  *   Copyright (C) 1997-2002 Net Integration Technologies, Inc.
   4  *
   5  * Defines a hierarchical registry abstraction.  See uniconf.h.
   6  */
   7 #include "uniconf.h"
   8 #include "uniconfroot.h"
   9 #include "uniconfgen.h"
  10 #include "wvstream.h"
  11 #include <assert.h>
  12
  13
  14 UniConf::UniConf(UniConfRoot *root, const UniConfKey &fullkey)
  15     : xroot(root), xfullkey(fullkey)
  16 {
  17     // nothing special
  18 }
  19
  20
  21 UniConf::UniConf() : xroot(NULL), xfullkey(UniConfKey::EMPTY)
  22 {
  23     // nothing special
  24 }
  25
  26
  27 UniConf::UniConf(const UniConf &other)
  28     : xroot(other.xroot), xfullkey(other.xfullkey)
  29 {
  30     // nothing special
  31 }
  32
  33
  34 UniConf::~UniConf()
  35 {
  36     // nothing special
  37 }
  38
  39
  40
  41
  42 UniConfKey UniConf::fullkey(const UniConfKey &k) const
  43 {
  44     return k.subkey(xfullkey);
  45 }
  46
  47
  48 bool UniConf::exists() const
  49 {
  50     return xroot->mounts.exists(xfullkey);
  51 }
  52
  53
  54 bool UniConf::haschildren() const
  55 {
  56     return xroot->mounts.haschildren(xfullkey);
  57 }
  58
  59
  60 void UniConf::prefetch(bool recursive) const
  61 {
  62     xroot->mounts.prefetch(xfullkey, recursive);
  63 }
  64
  65
  66 WvString UniConf::getme(WvStringParm defvalue) const
  67 {
  68     WvString value = xroot->mounts.get(xfullkey);
  69     if (value.isnull())
  70         return defvalue;
  71     return value;
  72 }
  73
  74
  75 int UniConf::getmeint(int defvalue) const
  76 {
  77     return xroot->mounts.str2int(getme(), defvalue);
  78 }
  79
  80
  81 void UniConf::setme(WvStringParm value) const
  82 {
  83     xroot->mounts.set(xfullkey, value);
  84 }
  85
  86
  87 void UniConf::setmeint(int value) const
  88 {
  89     setme(WvString(value));
  90 }
  91
  92
  93 void UniConf::move(const UniConf &dst) const
  94 {
  95     dst.remove();
  96     copy(dst, true);
  97     remove();
  98 }
  99
 100
 101 void UniConf::copy(const UniConf &dst, bool force) const
 102 {
 103     // do the main key first
 104     dst.setme(getme());
 105
 106     // now all the children
 107     RecursiveIter i(*this);
 108     for (i.rewind(); i.next(); )
 109     {
 110         UniConf dst2 = dst[i->fullkey(*this)];
 111         if (force || dst2.getme().isnull())
 112             dst2.setme(i->getme());
 113     }
 114 }
 115
 116
 117 bool UniConf::refresh() const
 118 {
 119     return xroot->mounts.refresh();
 120 }
 121
 122
 123 void UniConf::commit() const
 124 {
 125     xroot->mounts.commit();
 126 }
 127
 128
 129 IUniConfGen *UniConf::mount(WvStringParm moniker, bool refresh) const
 130 {
 131     return xroot->mounts.mount(xfullkey, moniker, refresh);
 132 }
 133
 134
 135 IUniConfGen *UniConf::mountgen(IUniConfGen *gen, bool refresh) const
 136 {
 137     return xroot->mounts.mountgen(xfullkey, gen, refresh);
 138 }
 139
 140
 141 void UniConf::unmount(IUniConfGen *gen, bool commit) const
 142 {
 143     return xroot->mounts.unmount(gen, commit);
 144 }
 145
 146
 147 bool UniConf::ismountpoint() const
 148 {
 149     return xroot->mounts.ismountpoint(xfullkey);
 150 }
 151
 152
 153 IUniConfGen *UniConf::whichmount(UniConfKey *mountpoint) const
 154 {
 155     return xroot->mounts.whichmount(xfullkey, mountpoint);
 156 }
 157
 158
 159 bool UniConf::isok() const
 160 {
 161     IUniConfGen *gen = whichmount();
 162     return gen && gen->isok();
 163 }
 164
 165
 166 void UniConf::add_callback(void *cookie, const UniConfCallback &callback,
 167                            bool recurse) const
 168 {
 169     xroot->add_callback(cookie, xfullkey, callback, recurse);
 170 }
 171
 172
 173 void UniConf::del_callback(void *cookie, bool recurse) const
 174 {
 175     xroot->del_callback(cookie, xfullkey, recurse);
 176 }
 177
 178
 179 void UniConf::add_setbool(bool *flag, bool recurse) const
 180 {
 181     xroot->add_setbool(xfullkey, flag, recurse);
 182 }
 183
 184
 185 void UniConf::del_setbool(bool *flag, bool recurse) const
 186 {
 187     xroot->del_setbool(xfullkey, flag, recurse);
 188 }
 189
 190
 191 void UniConf::hold_delta()
 192 {
 193     xroot->mounts.hold_delta();
 194 }
 195
 196
 197 void UniConf::unhold_delta()
 198 {
 199     xroot->mounts.unhold_delta();
 200 }
 201
 202
 203 void UniConf::clear_delta()
 204 {
 205     xroot->mounts.clear_delta();
 206 }
 207
 208
 209 void UniConf::flush_delta()
 210 {
 211     xroot->mounts.flush_delta();
 212 }
 213
 214
 215 void UniConf::dump(WvStream &stream, bool everything) const
 216 {
 217     UniConf::RecursiveIter it(*this);
 218     for (it.rewind(); it.next(); )
 219     {
 220         WvString value(it->getme());
 221         if (everything || !!value)
 222             stream.print("%s = %s\n", it->fullkey(), value);
 223     }
 224 }
 225
 226
 227
 228 /***** UniConf::Iter *****/
 229
 230 UniConf::Iter::Iter(const UniConf &_top)
 231     : IterBase(_top)
 232 {
 233     it = _top.rootobj()->mounts.iterator(top.fullkey());
 234     if (!it) it = new UniConfGen::NullIter;
 235 }
 236
 237
 238
 239 /***** UniConf::RecursiveIter *****/
 240
 241 UniConf::RecursiveIter::RecursiveIter(const UniConf &_top)
 242     : IterBase(_top)
 243 {
 244     it = _top.rootobj()->mounts.recursiveiterator(top.fullkey());
 245     if (!it) it = new UniConfGen::NullIter;
 246 }
 247
 248
 249 /***** UniConf::XIter *****/
 250
 251 UniConf::XIter::XIter(const UniConf &_top, const UniConfKey &pattern)
 252     : IterBase(_top), pathead(pattern.first()),
 253     pattail(pattern.removefirst()), subit(NULL), it(NULL), recit(NULL)
 254 {
 255     if (! pathead.iswild())
 256     {
 257         // optimization to collect as many consecutive non-wildcard
 258         // segments as possible in one go
 259         while (! pattail.isempty())
 260         {
 261             UniConfKey patnext(pattail.first());
 262             if (patnext.iswild())
 263                 break;
 264             pathead.append(patnext);
 265             pattail = pattail.removefirst();
 266         }
 267     }
 268 }
 269
 270
 271 UniConf::XIter::~XIter()
 272 {
 273     cleanup();
 274 }
 275
 276
 277 void UniConf::XIter::cleanup()
 278 {
 279     if (subit)
 280     {
 281         delete subit;
 282         subit = NULL;
 283     }
 284     if (it)
 285     {
 286         delete it;
 287         it = NULL;
 288     }
 289     if (recit)
 290     {
 291         delete recit;
 292         recit = NULL;
 293     }
 294 }
 295
 296
 297 void UniConf::XIter::rewind()
 298 {
 299     cleanup();
 300     ready = false;
 301
 302     if (pathead.isempty())
 303     {
 304         current = top;
 305         ready = current.exists();
 306     }
 307     else if (pathead == UniConfKey::RECURSIVE_ANY)
 308     {
 309         recit = new UniConf::RecursiveIter(top);
 310         recit->rewind();
 311         if (UniConfKey::EMPTY.matches(pattail))
 312         {
 313             // pattern includes self
 314             current = top;
 315             ready = current.exists();
 316         }
 317     }
 318     else if (pathead == UniConfKey::ANY)
 319     {
 320         it = new UniConf::Iter(top);
 321         it->rewind();
 322     }
 323     else
 324     {
 325         // non-wildcard segment
 326         current = top[pathead];
 327         if (pattail.isempty())
 328         {
 329             // don't bother recursing if there are no deeper wildcard
 330             // elements (works together with optimization in constructor)
 331             ready = current.exists();
 332         }
 333         else
 334         {
 335             // more wildcards, setup recursion
 336             enter(current);
 337         }
 338     }
 339 }
 340
 341
 342 inline bool UniConf::XIter::qnext()
 343 {
 344     if (subit) // currently in a sub-iterator
 345     {
 346         bool found = subit->next();
 347         if (found)
 348         {
 349             current = **subit;
 350             return true;
 351         }
 352         else
 353         {
 354             // end of this sub-iterator
 355             delete subit;
 356             subit = NULL;
 357             return false;
 358         }
 359     }
 360     else // no sub-iterator at all
 361         return false;
 362 }
 363
 364
 365 void UniConf::XIter::enter(const UniConf &child)
 366 {
 367     subit = new UniConf::XIter(child, pattail);
 368     subit->rewind();
 369 }
 370
 371
 372 bool UniConf::XIter::next()
 373 {
 374     if (ready)
 375     {
 376         ready = false;
 377         return true;
 378     }
 379     while (!qnext())
 380     {
 381         // UniConfKey::ANY
 382         if (it && it->next())
 383         {
 384             /* Not needed for now since we don't match partial keys
 385             if (! pathead.matches(it->key()))
 386                 break;
 387             */
 388             enter(**it);
 389             continue;
 390         }
 391         // UniConfKey::RECURSIVE_ANY
 392         if (recit && recit->next())
 393         {
 394             enter(**recit);
 395             continue;
 396         }
 397         // anything else or finished
 398         return false;
 399     }
 400
 401     // if we get here, qnext() returned true
 402     return true;
 403 }
 404
 405
 406
 407 /***** UniConf::SortedIterBase *****/
 408
 409 UniConf::SortedIterBase::SortedIterBase(const UniConf &root,
 410     UniConf::SortedIterBase::Comparator comparator)
 411     : IterBase(root), xcomparator(comparator), xkeys()
 412 {
 413 }
 414
 415
 416 UniConf::SortedIterBase::~SortedIterBase()
 417 {
 418     _purge();
 419 }
 420
 421
 422 int UniConf::SortedIterBase::defcomparator(const UniConf &a,
 423     const UniConf &b)
 424 {
 425     return a.fullkey().compareto(b.fullkey());
 426 }
 427
 428
 429 static UniConf::SortedIterBase::Comparator innercomparator = NULL;
 430
 431 static bool wrapcomparator(const UniConf &a, const UniConf &b)
 432 {
 433     return innercomparator(a, b) < 0;
 434 }
 435
 436
 437 void UniConf::SortedIterBase::_purge()
 438 {
 439     count = xkeys.size();
 440     xkeys.clear();
 441 }
 442
 443
 444 void UniConf::SortedIterBase::_rewind()
 445 {
 446     index = 0;
 447     count = xkeys.size();
 448
 449     // This code is NOT reentrant because qsort makes it too hard
 450     innercomparator = xcomparator;
 451     std::sort(xkeys.begin(), xkeys.end(), wrapcomparator);
 452 }
 453
 454
 455 bool UniConf::SortedIterBase::next()
 456 {
 457     if (index >= count)
 458         return false;
 459     current = xkeys[index];
 460     index += 1;
 461     return true;
 462 }