include/uniconftree.h

   1 /* -*- Mode: C++ -*-
   2  * Worldvisions Weaver Software:
   3  *   Copyright (C) 1997-2002 Net Integration Technologies, Inc.
   4  *
   5  * UniConf low-level tree storage abstraction.
   6  */
   7 #ifndef __UNICONFTREE_H
   8 #define __UNICONFTREE_H
   9
  10 #include "uniconfkey.h"
  11 #include "unihashtree.h"
  12 #include "wvtr1.h"
  13
  14 /**
  15  * A recursively composed dictionary for tree-structured
  16  * data indexed by UniConfKey.
  17  *
  18  * Someday this could be further abstracted into a generic WvTreeDict.
  19  *
  20  * "Sub" is the name of the concrete subclass of UniConfTree.
  21  */
  22 template<class Sub>
  23 class UniConfTree : public UniHashTreeBase
  24 {
  25
  26 public:
  27     typedef wv::function<void(const Sub*, void*)> Visitor;
  28     typedef wv::function<bool(const Sub*, const Sub*)> Comparator;
  29
  30     /** Creates a node and links it to a subtree, if parent is non-NULL */
  31     UniConfTree(Sub *parent, const UniConfKey &key) :
  32         UniHashTreeBase(parent, key)
  33         { }
  34
  35     /** Destroy this node's contents and children. */
  36     ~UniConfTree()
  37         { zap(); }
  38
  39     /** Returns a pointer to the parent node, or NULL if there is none. */
  40     Sub *parent() const
  41         { return static_cast<Sub*>(this->xparent); }
  42
  43     /** Reparents this node. */
  44     void setparent(Sub *parent)
  45         { UniHashTreeBase::_setparent(parent); }
  46
  47     /** Returns a pointer to the root node of the tree. */
  48     Sub *root() const
  49         { return static_cast<Sub*>(UniHashTreeBase::_root()); }
  50
  51     /**
  52      * Returns full path of this node relative to an ancestor.
  53      * If ancestor is NULL, returns the root.
  54      */
  55     UniConfKey fullkey(const Sub *ancestor = NULL) const
  56         { return UniHashTreeBase::_fullkey(ancestor); }
  57
  58     /**
  59      * Finds the sub-node with the specified key.
  60      * If key.isempty(), returns this node.
  61      */
  62     Sub *find(const UniConfKey &key) const
  63         { return static_cast<Sub*>(UniHashTreeBase::_find(key)); }
  64
  65     /**
  66      * Finds the direct child node with the specified key.
  67      *
  68      * If key.numsegments() == 1, then performs the same task
  69      * as find(key), but a little faster.  Otherwise returns NULL.
  70      */
  71     Sub *findchild(const UniConfKey &key) const
  72         { return static_cast<Sub*>(UniHashTreeBase::_findchild(key)); }
  73
  74     /**
  75      * Removes the node for the specified key from the tree
  76      * and deletes it along with any of its children.
  77      *
  78      * If the key is UniConfKey::EMPTY, deletes this object.
  79      */
  80     void remove(const UniConfKey &key)
  81         { delete find(key); }
  82
  83     /** Removes and deletes all children of this node. */
  84     void zap()
  85     {
  86         if (!(this->xchildren))
  87             return;
  88         // set xchildren to NULL first so that the zap() will happen faster
  89         // otherwise, each child will attempt to unlink itself uselessly
  90
  91         typename UniHashTreeBase::Container *oldchildren = this->xchildren;
  92         this->xchildren = NULL;
  93
  94         // delete all children
  95         typename UniHashTreeBase::Container::Iter i(*oldchildren);
  96         for (i.rewind(); i.next();)
  97             delete static_cast<Sub*>(i.ptr());
  98
  99         delete oldchildren;
 100     }
 101
 102     /**
 103      * Performs a traversal on this tree using the specified
 104      * visitor function and traversal type(s).
 105      * "visitor" is the tree visitor function
 106      * "userdata" is userdata for the tree visitor function
 107      */
 108     void visit(const Visitor &visitor, void *userdata,
 109         bool preorder = true, bool postorder = false) const
 110     {
 111         _recursive_unsorted_visit(this, reinterpret_cast<
 112             const typename UniHashTreeBase::BaseVisitor&>(visitor), userdata,
 113             preorder, postorder);
 114     }
 115
 116     /**
 117      * Compares this tree with another using the specified comparator
 118      * function.
 119      * Comparison of a subtree ends when the comparator returns false.
 120      * "comparator" is the value compare function
 121      * "userdata" is userdata for the compare function
 122      * Returns: true if the comparison function returned true each time
 123      */
 124     bool compare(const Sub *other, const Comparator &comparator)
 125     {
 126         return _recursivecompare(this, other, reinterpret_cast<
 127             const typename UniHashTreeBase::BaseComparator&>(comparator));
 128     }
 129
 130     /**
 131      * An iterator that walks over all elements on one level of a
 132      * UniConfTree.
 133      */
 134     class Iter : public UniHashTreeBase::Iter
 135     {
 136     public:
 137         typedef typename UniHashTreeBase::Iter MyBase;
 138
 139         /** Creates an iterator over the specified tree. */
 140         Iter(Sub &tree) : UniHashTreeBase::Iter(tree)
 141             { }
 142
 143         /** Returns a pointer to the current node. */
 144         Sub *ptr() const
 145             { return static_cast<Sub*>(MyBase::ptr()); }
 146         WvIterStuff(Sub);
 147     };
 148 };
 149
 150
 151 /** A plain UniConfTree that holds keys and values. */
 152 class UniConfValueTree : public UniConfTree<UniConfValueTree>
 153 {
 154     WvString xvalue;  /*!< the value of this entry */
 155
 156 public:
 157     UniConfValueTree(UniConfValueTree *parent,
 158                      const UniConfKey &key, WvStringParm value)
 159         : UniConfTree<UniConfValueTree>(parent, key), xvalue(value)
 160         { }
 161
 162     /** Returns the value field. */
 163     const WvString &value() const
 164         { return xvalue; }
 165
 166     /** Sets the value field. */
 167     void setvalue(WvStringParm value)
 168         { xvalue = value; }
 169 };
 170
 171
 172 #endif // __UNICONFTREE_H