Make WvStreams compile with gcc 4.4.

[wvstreams.git] / uniconf / unitransactiongen.cc

#include "unitransactiongen.h"
#include "uniconftree.h"
#include "unilistiter.h"
#include "wvmoniker.h"

static IUniConfGen *creator(WvStringParm s, IObject *_obj)
{
    IUniConfGen *base = wvcreate<IUniConfGen>(s, _obj);
    if (base)
        return new UniTransactionGen(base);
    else
        return NULL;
}

static WvMoniker<IUniConfGen> moniker("transaction", creator);

/* This enum is a field of UniConfChangeTree. It indicates the type of
   change represented by a node in a UniConfChangeTree. */
enum changeMode
{
    /* This indicates that "newvalue" is valid and that
       its value should be written to the underlying generator at commit
       time. This tree *might* have children, which must be applied.
       "newvalue" will be a non-null pointer to a non-null WvString. */
    NEWVALUE,
    /* This indicates that "newtree" is valid (but possibly NULL) and that
       the underlying generator's corresponding subtree should be made
       identical at commit time. This tree will *not* have children (though
       newtree might). */
    NEWTREE,
    /* This indicates that "was_null_or_empty" is valid and that the key
       in the underlying generator should be created at commit time if it
       does not already exist at commit time. This tree *will* have
       children, which must be applied, and at least one of which will
       be non-BLANK. "was_null_or_empty" will be the return value of the
       WvString negation operation on the last known value of the
       corresponding key in the underlying generator; it is necessary
       in order to filter callbacks in certain cases. */
    NEWNODE,
    /* This indicates that none of the fields are valid and that
       nothing should be done for this tree. This tree *will* have children,
       which must be applied, but they will all have mode of NEWTREE with
       newtree == NULL. */
    BLANK
};

class UniConfChangeTree : public UniConfTree<UniConfChangeTree>
{
public:
    changeMode mode;

    // This used to be a union, but it was causing memory errors that were 
    // extremely difficult to track down.  Some of this code might serve no
    // purpose without this being a union, but I'd rather have it still work
    // and not leak than break it. -- mrwise
    WvString newvalue;
    UniConfValueTree *newtree;
    bool was_null_or_empty;

    // Constructs a tree and links it to a parent.
    UniConfChangeTree(UniConfChangeTree *parent, const UniConfKey &key)
        : UniConfTree<UniConfChangeTree>(parent, key), newtree(0) {}

    // Destroys a tree and everything it owns.
    ~UniConfChangeTree()
    {
        if (newtree)
            delete newtree;
    }
};

// Constructed by UniTransactionGen::iterator() to iterate over a section that
// is to be completely replaced by a particular UniConfValueTree.
class GenStyleValueTreeIter : public UniConfGen::Iter
{
public:
    GenStyleValueTreeIter(UniConfValueTree *node)
        : i(*node)
    {
        // printf("GenStyleValueTreeIter\n");
    }
    
    ~GenStyleValueTreeIter()
    {
        // printf("~GenStyleValueTreeIter\n");
    }

    void rewind() { i.rewind(); }
    bool next() { return i.next(); }
    UniConfKey key() const { return i->key(); }
    WvString value() const { return i->value(); }

private:
    UniConfValueTree::Iter i;
};

// Constructed by UniTransactionGen::iterator() to iterate over a section that
// is being modified but not replaced. We iterate first over all of the values
// that we're changing, except those we're deleting, and second over all
// existing values not iterated over in the first stage, except those we're
// deleting.
class GenStyleChangeTreeIter : public UniConfGen::Iter
{
public:
    GenStyleChangeTreeIter(UniConfChangeTree *_root,
                           const UniConfKey &_section,
                           IUniConfGen *_base)
        : root(_root), section(_section), base(_base),
          doing_i1(true), i1(*root), i2(base->iterator(section))
    {
        // printf("GenStyleChangeTreeIter(%s)\n", WvString(section).cstr());
    }

    ~GenStyleChangeTreeIter()
    {
        // printf("~GenStyleChangeTreeIter(%s)\n", WvString(section).cstr());
        if (i2) delete i2;
    }

    void rewind()
    {
        i1.rewind();
        doing_i1 = true;
    }

    bool next()
    {
        if (doing_i1)
        {
            for (;;)
            {
                if (i1.next())
                {
                    if (i1->mode == NEWVALUE ||
                        i1->mode == NEWNODE ||
                        (i1->mode == NEWTREE && i1->newtree))
                        return true;
                }
                else
                    break;
            }
            doing_i1 = false;
            if (i2) i2->rewind();
        }
        if (i2)
        {
            for (;;)
            {
                if (i2->next())
                {
                    UniConfChangeTree *node = root->findchild(i2->key());
                    if (!node || node->mode == BLANK)
                        return true;
                }
                else
                    break;
            }
        }
        return false;
    }

    UniConfKey key() const
    {
        if (doing_i1)
            return i1->key();
        else if (i2)
            return i2->key();
        else
            return UniConfKey();
    }

    WvString value() const
    {
        if (doing_i1)
        {
            if (i1->mode == NEWVALUE)
                return i1->newvalue;
            else if (i1->mode == NEWTREE)
                return i1->newtree->value();
            else // i.e. i1->mode == NEWNODE
            {
                WvString value(base->get(UniConfKey(section, i1->key())));
                return !value ? WvString::empty : value;
            }
        }
        else
        {
            return i2->value();
        }
    }

private:
    UniConfChangeTree *root;
    UniConfKey section;
    IUniConfGen *base;

    bool doing_i1;
    UniConfChangeTree::Iter i1;
    UniConfGen::Iter *i2;
};

UniTransactionGen::UniTransactionGen(IUniConfGen *_base)
    : root(NULL), base(_base)
{
    base->add_callback(this, wv::bind(&UniTransactionGen::gencallback, this,
                                      _1, _2));
}

UniTransactionGen::~UniTransactionGen()
{
    base->del_callback(this);
    WVRELEASE(base);
    WVDELETE(root);
}

WvString UniTransactionGen::get(const UniConfKey &key)
{
    UniConfChangeTree *node = root;
    for (int seg = 0;; node = node->findchild(key.segment(seg++)))
    {
        if (!node)
            // If we couldn't find the next node, then we aren't
            // changing the requested key, and so the value is whatever
            // it currently is.
            return base->get(key);
        else if (node->mode == NEWTREE)
        {
            // Else if the next node has mode of NEWTREE, then we're changing
            // the requested key to whatever its value is in the stored
            // tree.
            if (node->newtree)
            {
                UniConfValueTree *subnode = node->newtree->find(
                    key.last(key.numsegments() - seg));
                if (subnode)
                    return subnode->value();
            }
            return WvString::null;
        }
        else if (seg == key.numsegments())
        {
            // Else if this is the last node, then figure out what the node
            // would do and return the appropriate value. (The node's mode
            // will be either NEWVALUE, NEWNODE, or BLANK.)
            if (node->mode == NEWVALUE)
                return node->newvalue;
            WvString value(base->get(key.first(seg)));
            return (node->mode == NEWNODE && !value) ? WvString::empty : value;
        }
    }
}

void UniTransactionGen::set(const UniConfKey &key, WvStringParm value)
{
    hold_delta();
    root = set_change(root, key, 0, value);
    unhold_delta();
}

void UniTransactionGen::setv(const UniConfPairList &pairs)
{
    hold_delta();
    UniConfPairList::Iter i(pairs);
    for (i.rewind(); i.next(); )
        root = set_change(root, i->key(), 0, i->value());
    unhold_delta();
}

void UniTransactionGen::commit()
{
    if (root)
    {
        // Apply our changes to the inner generator.  We can't optimise
        // away callbacks at this point, because we may get notified of
        // changes caused by our changes.
        hold_delta();
        apply_changes(root, UniConfKey());

        // make sure the inner generator also commits
        base->commit();

        // save deleting the root till now so we can hide any
        // redundant notifications caused by the base->commit()
        delete root;
        root = NULL;
        unhold_delta();
    }
    
    // no need to base->commit() if we know we haven't changed anything!
}

bool UniTransactionGen::refresh()
{
    if (root)
    {
        hold_delta();
        cancel_changes(root, UniConfKey());
        delete root;
        root = NULL;
        unhold_delta();
        
        // no need to base->commit() here, since the inner generator never
        // saw any changes
    }
    
    // must always base->refresh(), even if we didn't change anything
    return base->refresh();
}

UniConfGen::Iter *UniTransactionGen::iterator(const UniConfKey &key)
{
    UniConfChangeTree *node = root;
    for (int seg = 0;; node = node->findchild(key.segment(seg++)))
    {
        if (!node)
            // If we couldn't find the next node, then we aren't changing the
            // children of the requested key, so they're whatever they
            // currently are.
            return base->iterator(key);
        else if (node->mode == NEWTREE)
        {
            // Else if the next node has mode of NEWTREE, then we're changing
            // the children of the requested key to whatever they are in the
            // stored tree.
            if (node->newtree)
            {
                UniConfValueTree *subnode = node->newtree->find(
                    key.last(key.numsegments() - seg));
                if (subnode)
                {
                    UniConfGen::Iter *i = new GenStyleValueTreeIter(subnode);
                    UniListIter *i2 = new UniListIter(this);
                    i2->autofill(i);
                    delete i;
                    return i2;
                }
            }
            return new UniConfGen::NullIter();
        }
        else if (seg == key.numsegments())
        {
            // Else if this is the last node, then iterate over its direct
            // children.
            UniConfGen::Iter *i = new GenStyleChangeTreeIter(node, key, base);
            UniListIter *i2 = new UniListIter(this);
            i2->autofill(i);
            delete i;
            return i2;
        }
    }
}

void UniTransactionGen::apply_values(UniConfValueTree *newcontents,
                                     const UniConfKey &section)
{
    base->set(section, newcontents->value());

    UniConfGen::Iter *j = base->iterator(section);
    if (j)
    {
        for (j->rewind(); j->next();)
        {
            if (newcontents->findchild(j->key()) == NULL)
                // Delete all children of the current value in the
                // underlying generator that do not exist in our
                // replacement tree.
                base->set(UniConfKey(section, j->key()), WvString::null);
        }
        delete j;
    }

    // Repeat for each child in the replacement tree.
    UniConfValueTree::Iter i(*newcontents);
    for (i.rewind(); i.next();)
        apply_values(i.ptr(), UniConfKey(section, i->key()));
}

void UniTransactionGen::apply_changes(UniConfChangeTree *node,
                                      const UniConfKey &section)
{
    if (node->mode == NEWTREE)
    {
        // If the current change is a NEWTREE change, then replace the
        // tree in the underlying generator with the stored one.
        if (node->newtree == NULL)
            base->set(section, WvString::null);
        else
            apply_values(node->newtree, section);
        // Since such changes have no children, return immediately.
        return;
    }
    else if (node->mode == NEWVALUE)
    {
        // Else if the current change is a NEWVALUE change, ...
        base->set(section, node->newvalue);
    }
    else if (node->mode == NEWNODE)
    {
        // Else if the current change is a NEWNODE change, ...
        if (!base->exists(section))
            // ... and the current value in the underlying generator doesn't
            // exist, then create it.
            base->set(section, WvString::empty);
        // Note: This *is* necessary. We can't ignore this change and have
        // the underlying generator handle it, because it's possible that
        // this NEWNODE was the result of a set() which was later deleted.
    }
    
    // Repeat for each child in the change tree.
    UniConfChangeTree::Iter i(*node);
    for (i.rewind(); i.next();)
        apply_changes(i.ptr(), UniConfKey(section, i->key()));
}

struct my_userdata
{
    UniConfValueTree *node;
    const UniConfKey &key;
};

void UniTransactionGen::deletion_visitor(const UniConfValueTree *node,
                                         void *userdata)
{
    my_userdata *data = (my_userdata *)userdata;
    delta(UniConfKey(data->key, node->fullkey(data->node)), WvString::null);
}

// Mirror image of apply_values() that issues all of the callbacks associated
// with discarding a replacement value tree.
void UniTransactionGen::cancel_values(UniConfValueTree *newcontents,
                                      const UniConfKey &section)
{
    WvString value(base->get(section));
    if (!newcontents || newcontents->value() != value)
        delta(section, value);
    
    if (newcontents)
    {
        UniConfValueTree::Iter i(*newcontents);
        for (i.rewind(); i.next();)
        {
            UniConfKey subkey(section, i->key());
            if (!base->exists(subkey))
            {
                my_userdata data = { i.ptr(), subkey };
                i->visit(wv::bind(&UniTransactionGen::deletion_visitor, this,
                                  _1, _2),
                         (void*)&data, false, true);
            }
        }
    }

    UniConfGen::Iter *i = base->iterator(section);
    if (i)
    {
        for (i->rewind(); i->next();)
            cancel_values(newcontents ?
                          newcontents->findchild(i->key()) : NULL,
                          UniConfKey(section, i->key()));
        delete i;
    }
}

// Mirror image of apply_changes() that issues all of the callbacks associated
// with discarding a change tree.
void UniTransactionGen::cancel_changes(UniConfChangeTree *node,
                                       const UniConfKey &section)
{
    if (node->mode == NEWTREE)
    {
        if (!base->exists(section))
        {
            if (node->newtree != NULL)
            {
                my_userdata data = { node->newtree, section };
                node->newtree->visit(
                    wv::bind(&UniTransactionGen::deletion_visitor, this,
                             _1, _2),
                    (void *)&data, false, true);
            }
        }
        else
            cancel_values(node->newtree, section);
        return;
    }

    WvString value;
    if (node->mode != BLANK)
        value = base->get(section);

    if (node->mode == NEWVALUE &&
        !value.isnull() &&
        value != node->newvalue)
        delta(section, value);

    UniConfChangeTree::Iter i(*node);
    for (i.rewind(); i.next();)
        cancel_changes(i.ptr(), UniConfKey(section, i->key()));

    if (node->mode != BLANK && value.isnull())
        delta(section, WvString::null);
}

void UniTransactionGen::gencallback(const UniConfKey &key,
                                    WvStringParm value)
{
    UniConfChangeTree *node = root;
    for (int seg = 0;; node = node->findchild(key.segment(seg++)))
    {
        if (!node)
            // If we couldn't find the next node, then we aren't changing
            // the changed key or any of its children, and so a callback
            // should be made.
            break;
        else if (node->mode == NEWTREE)
            // Else if the next node has mode of NEWTREE, then we're changing
            // the changed key and all of its children to whatever their
            // values are in the stored tree, and so the callback should be
            // ignored.
            return;
        else if (seg == key.numsegments())
        {
            // Else if this is the last node, then figure out what we 
            // should do.
            if (node->mode == NEWVALUE)
                // If we're replacing this key's value, then we should
                // ignore the callback.
                return;
            else if (node->mode == NEWNODE)
            {
                // Else if we want to create this key, then use its
                // was_null_or_empty flag to figure out if we need
                // to issue a callback, and update it if necessary.
                if (node->was_null_or_empty && !value)
                    return;
                node->was_null_or_empty = !value;
                if (value.isnull())
                {
                    delta(key, WvString::empty);
                    return;
                }
                break;
            }
            else // i.e. node->mode == BLANK
                // Else if we're doing nothing to this key, then a
                // callback should be made.
                break;
        }
    }
    
    // Make a normal callback.
    delta(key, value);
}

// Create and return a UniConfValueTree containing the value 'value' for
// the key given by the segments of 'key' at and after position 'seg', with
// parent 'parent' and key given by the segment of 'key' at position seg-1
// (which is the "root" key if seg == 0). Issue callbacks as necessary using
// all the segments of 'key'.
UniConfValueTree *UniTransactionGen::create_value(UniConfValueTree *parent,
                                                  const UniConfKey &key,
                                                  int seg,
                                                  WvStringParm value)
{
    UniConfValueTree *tree = 0;
    for (; seg != key.numsegments();)
    {
        // Create any needed intermediate nodes, each with value equal to
        // the empty string.
        parent = new UniConfValueTree(parent,
                                      key.segment(seg-1),
                                      WvString::empty);
        delta(key.first(seg++), WvString::empty);
        if (!tree)
            tree = parent;
    }
    // Create the last node with the specified value.
    parent = new UniConfValueTree(parent,
                                  key.segment(seg-1),
                                  value);
    delta(key, value);
    if (!tree)
        tree = parent;
    return tree;
}

void UniTransactionGen::deletion_simulator(const UniConfKey &key)
{
    UniConfGen::Iter *i = base->iterator(key);
    if (i)
    {
        for (i->rewind(); i->next();)
            deletion_simulator(UniConfKey(key, i->key()));
        delete i;
    }
    delta(key, WvString::null);
}

// Like create_value(), but make a UniConfChangeTree containing a *change*
// to value 'value'.
UniConfChangeTree *UniTransactionGen::create_change(UniConfChangeTree *parent,
                                                    const UniConfKey &key,
                                                    int seg,
                                                    WvStringParm value)
{
    // if the key has a trailing slash, this should be a no-op: we don't
    // want this to have any effect
    if ((key.hastrailingslash()) && !value.isnull())
        return parent;

    UniConfChangeTree *tree = 0;
    for (; seg != key.numsegments(); seg++)
    {
        parent = new UniConfChangeTree(parent, key.segment(seg-1));
        if (value.isnull())
            // We don't do anything for intermediate nodes when deleting, ...
            parent->mode = BLANK;
        else
        {
            // ... but when set()'ing a non-null value, we want them to exist.
            parent->mode = NEWNODE;
            UniConfKey nodekey(key.first(seg));
            WvString curr = base->get(nodekey);
            parent->was_null_or_empty = !curr;
            if (curr.isnull())
                delta(nodekey, WvString::empty);
        }
        if (!tree)
            tree = parent;
    }
    parent = new UniConfChangeTree(parent, key.segment(seg-1));
    // Create the last node with the specified change.
    if (value.isnull())
    {
        parent->mode = NEWTREE;
        parent->newtree = 0;
        if (base->exists(key))
            deletion_simulator(key);
    }
    else
    {
        parent->mode = NEWVALUE;
        parent->newvalue = WvString(value);
        if (base->get(key) != value)
            delta(key, value);
    }
    if (!tree)
        tree = parent;
    return tree;
}

// Modify an existing UniConfValueTree to incorporate the set() of a
// particular value for a particular key. Return a possibly altered
// pointer to the root of the tree. 'seg' and 'key' are used like they
// are in create_value(), and callbacks are made similarly.
UniConfValueTree *UniTransactionGen::set_value(UniConfValueTree *node,
                                               const UniConfKey &key,
                                               int seg,
                                               WvStringParm value)
{
    // printf("set_value('%s', %d)\n", WvString(key).cstr(), value.isnull());
    if (value.isnull())
    {
        // Delete the key if it exists.
        if (node)
        {
            UniConfValueTree *subnode = node->find(
                key.last(key.numsegments() - seg));
            if (subnode)
            {
                hold_delta();
                my_userdata data = { subnode, key };
                subnode->visit(wv::bind(&UniTransactionGen::deletion_visitor,
                                        this, _1, _2),
                               (void *)&data, false, true);
                // printf("DELETE SUBNODE!\n");
                delete subnode;
                unhold_delta();
                return subnode == node ? NULL : node;
            }
            else
                return node;
        }
        else
            return NULL;
    }
    else
    {
        // Switch to create_value() if we ever can't find the next node.
        if (!node)
            return create_value(NULL, key, seg, value);
        
        UniConfValueTree *subnode = node;
        for (; seg != key.numsegments();)
        {
            UniConfKey segment(key.segment(seg++));
            UniConfValueTree *child = subnode->findchild(segment);
            // Switch to create_value() if we ever can't find the next node.
            if (!child)
            {
                create_value(subnode, key, seg, value);
                return node;
            }
            else
                subnode = child;
        }
        // The node already existed and we've found it; set it.
        if (value != subnode->value())
        {
            subnode->setvalue(value);
            delta(key, value);
        }
        return node;
    }
}

void UniTransactionGen::deletion_simulator2(const UniConfKey &key)
{
    UniConfGen::Iter *i = this->iterator(key);
    if (i)
    {
        for (i->rewind(); i->next();)
            deletion_simulator2(UniConfKey(key, i->key()));
        delete i;
    }
    delta(key, WvString::null);
}

// Like set_value(), but, again, for UniConfChangeTrees instead.
UniConfChangeTree *UniTransactionGen::set_change(UniConfChangeTree *node,
                                                 const UniConfKey &key,
                                                 int seg,
                                                 WvStringParm value)
{
    // printf("set_change(key=%s,mode=%d) = '%s'\n",
    //        WvString(key).cstr(), node ? node->mode : 999, value.cstr());
    
    // Switch to create_change() if we ever can't find the next node,
    // and switch to set_value() if we ever find a NEWTREE.
    if (!node)
        return create_change(NULL, key, seg, value);
    else if (node->mode == NEWTREE)
    {
        node->newtree = set_value(node->newtree, key, seg, value);
        return node;
    }
    
    UniConfChangeTree *subnode = node;
    for (; seg != key.numsegments();)
    {
        if (subnode->mode == BLANK && !value.isnull())
        {
            // If we're setting a non-null value and we weren't previously
            // doing anything to this node, then now we want to create it.
            subnode->mode = NEWNODE;
            UniConfKey nodekey(key.first(seg));
            WvString curr = base->get(nodekey);
            subnode->was_null_or_empty = !curr;
            if (curr.isnull())
                delta(nodekey, WvString::empty);
        }
        
        UniConfKey segment(key.segment(seg++));
        UniConfChangeTree *next = subnode->findchild(segment);
        // Switch to create_change() if we ever can't find the next node,
        // and switch to set_value() if we ever find a NEWTREE.
        if (!next)
        {
            create_change(subnode, key, seg, value);
            return node;
        }
        else if (next->mode == NEWTREE)
        {
            next->newtree = set_value(next->newtree,
                                      key, seg, value);
            return node;
        }
        else
            subnode = next;
    }
    // The node already existed, didn't have mode of NEWTREE, and we've
    // found it; change it.
    if (value.isnull())
    {
        if (subnode->mode != BLANK || base->exists(key))
            deletion_simulator2(key);
        subnode->zap();
        subnode->mode = NEWTREE;
        subnode->newtree = 0;
    }
    else if (subnode->mode == NEWVALUE)
    {
        if (subnode->newvalue != value)
        {
            subnode->newvalue = value;
            delta(key, value);
        }
    }
    else if (subnode->mode == BLANK)
    {
        if (base->get(key) != value)
            delta(key, value);      
        subnode->mode = NEWVALUE;
        subnode->newvalue = WvString(value);
    }
    else // i.e. subnode->mode == NEWNODE
    {
        WvString currval(base->get(key));
        if ((!currval != !value) && (currval != value))
            delta(key, value);
        subnode->mode = NEWVALUE;
        subnode->newvalue = WvString(value);
    }
    return node;
}

// We'll say we're okay whenever the underlying generator is.
bool UniTransactionGen::isok()
{
    return base->isok();
}

void UniTransactionGen::flush_buffers()
{
}