uniconfgen.cc

/*
 * Worldvisions Weaver Software:
 *   Copyright (C) 2002 Net Integration Technologies, Inc.
 * 
 * An abstract data container that backs a UniConf tree.
 */
#include "uniconfgen.h"
#include "strutils.h"
 
// FIXME: interfaces (IUniConfGen) shouldn't have implementations!
IUniConfGen::~IUniConfGen()
{
}
 
UUID_MAP_BEGIN(UniConfGen)
  UUID_MAP_ENTRY(IObject)
  UUID_MAP_ENTRY(IUniConfGen)
  UUID_MAP_END
 
UniConfGen::UniConfGen()
{
    hold_nesting = 0;
}
 
 
UniConfGen::~UniConfGen()
{
    assert(cblist.isempty());
}
 
 
void UniConfGen::hold_delta()
{
    hold_nesting++;
}
 
 
void UniConfGen::unhold_delta()
{
    assert(hold_nesting > 0);
    if (hold_nesting == 1)
        flush_delta();
    hold_nesting--;
}
 
 
void UniConfGen::clear_delta()
{
    deltas.zap();
}
 
 
void UniConfGen::flush_delta()
{
    UniConfPairList::Iter it(deltas);
    for (;;)
    {
        it.rewind();
        if (! it.next())
            break;
 
        UniConfKey key((*it).key());
        WvString value((*it).value());
 
        it.xunlink();
        dispatch_delta(key, value);
    }
}
 
 
void UniConfGen::dispatch_delta(const UniConfKey &key, WvStringParm value)
{
    cblist(key, value);
}
 
 
void UniConfGen::delta(const UniConfKey &key, WvStringParm value)
{
    if (hold_nesting == 0)
    {
        // not nested, dispatch immediately
        dispatch_delta(key, value);
    }
    else
    {
        hold_delta();
        deltas.add(new UniConfPair(key, value), true);
        unhold_delta();
    }
}
 
 
void UniConfGen::setv_naive(const UniConfPairList &pairs)
{
    UniConfPairList::Iter pair(pairs);
    for (pair.rewind(); pair.next(); )
        set(pair->key(), pair->value());
}
 
 
bool UniConfGen::haschildren(const UniConfKey &key)
{
    bool children = false;
    
    hold_delta();
    
    Iter *it = iterator(key);
    if (it)
    {
        it->rewind();
        if (it->next()) children = true;
        delete it;
    }
    
    unhold_delta();
    return children;
}
 
 
bool UniConfGen::exists(const UniConfKey &key)
{
    return !get(key).isnull();
}
 
 
int UniConfGen::str2int(WvStringParm value, int defvalue) const
{
    // also recognize bool strings as integers
    const char *strs[] = {
        "true", "yes", "on", "enabled",
        "false", "no", "off", "disabled"
    };
    const size_t numtruestrs = 4;
 
    if (!value.isnull())
    {
        // try to recognize an integer
        char *end;
        int num = strtol(value.cstr(), &end, 0);
        if (end != value.cstr())
            return num; // was a valid integer
        
        // try to recognize a special string
        for (size_t i = 0; i < sizeof(strs) / sizeof(const char*); ++i)
            if (strcasecmp(value, strs[i]) == 0)
                return i < numtruestrs;
    }
    return defvalue;
}
 
 
bool UniConfGen::isok()
{
    return true;
}
 
 
void UniConfGen::add_callback(void *cookie,
                              const UniConfGenCallback &callback)
{
    cblist.add(callback, cookie);
}
 
 
void UniConfGen::del_callback(void *cookie)
{
    cblist.del(cookie);
}
 
 
 
class _UniConfGenRecursiveIter : public IUniConfGen::Iter
{
    WvList<IUniConfGen::Iter> itlist;
    IUniConfGen *gen;
    UniConfKey top, current;
    bool sub_next;
    
public:
    _UniConfGenRecursiveIter(IUniConfGen *_gen, const UniConfKey &_top)
        : top(_top)
    {
        gen = _gen;
        sub_next = false;
    }
    
    virtual ~_UniConfGenRecursiveIter() { }
 
    virtual void rewind()
    {
        current = "";
        sub_next = false;
        itlist.zap();
        
        Iter *subi = gen->iterator(top);
        if (subi)
        {
            subi->rewind();
            itlist.prepend(subi, true);
        }
    }
 
    virtual bool next()
    {
        //assert(!itlist.isempty()); // trying to seek past the end is illegal!
        
        if (sub_next)
        {
            sub_next = false;
            
            UniConfKey subkey(itlist.first()->key());
            UniConfKey newkey(current, subkey);
            //fprintf(stderr, "subiter: '%s'\n", newkey.cstr());
            Iter *newsub = gen->iterator(UniConfKey(top, newkey));
            if (newsub)
            {
                current.append(subkey);
                //fprintf(stderr, "current is now: '%s'\n", current.cstr());
                newsub->rewind();
                itlist.prepend(newsub, true);
            }
        }
        
        WvList<IUniConfGen::Iter>::Iter i(itlist);
        for (i.rewind(); i.next(); )
        {
            if (i->next()) // NOTE: not the same as i.next()
            {
                // set up so next time, we go into its subtree
                sub_next = true;
                return true;
            }
            
            // otherwise, this iterator is empty; move up the tree
            current = current.removelast();
            //fprintf(stderr, "current is now: '%s'\n", current.cstr());
            i.xunlink();
        }
        
        // all done!
        return false;
    }
 
    virtual UniConfKey key() const
    {
        //fprintf(stderr, "current is now: '%s'\n", current.cstr());
        if (!itlist.isempty())
            return UniConfKey(current, itlist.first()->key());
        else
            return current;
    }
    
    virtual WvString value() const
    {
        return gen->get(UniConfKey(top, key()));
    }
};
 
 
UniConfGen::Iter *UniConfGen::recursiveiterator(const UniConfKey &key)
{
    return new _UniConfGenRecursiveIter(this, key);
}