objtree.cpp

Go to the documentation of this file.

/*
 * objtree.cpp
 *
 * Copyright (C) 2006,2010  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Implementation of the objtree API.  See objtree.h
 */

// includes --------------------------------------------------------------------
#include "objtree.h"            // always include our own header first!

#include <sstream>
#include <stdexcept>

#include "datahash/datahash_util.h"
#include "util/token_stream.h"


namespace objtree {

// List interface destructor implementation
List::~List(void) throw() { }

Tree::~Tree(void) throw() { }


////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

static void
verifyLowerCase
(
IN const char * p
)
{
        // actually, this isn't interesting...  should just be valid...
        if ('*' == *p)
                return;
        ASSERT(isValidPropertyName(p), "Invalid id/query: '%s'", p);
}



static bool
idMatchesQuery
(
IN const char * id,
IN const char * query
)
{
        ASSERT(id, "null id");
        ASSERT(query, "null query");

        // basic matching: completely matches, or is wildcard
        if (!strcmp("*", query))
                return true;    // wildcard query
        if (!strcmp(id, query))
                return true;    // query + id exactly match
        return false;
}



////////////////////////////////////////////////////////////////////////////////
//
//      property_t
//
////////////////////////////////////////////////////////////////////////////////

void
property_t::dump
(
IN const char * title
)
const
throw()
{
        ASSERT(title, "null title for property_t dump");

        DPRINTF("  %s", title);
        for (Dictionary::const_iterator i = this->begin(); i != this->end();
             ++i) {
                const char * field = i->first.c_str();
                const char * value = i->second.c_str();

                DPRINTF("    field '%s' --> value '%s'", field, value);
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      property_set_t
//
////////////////////////////////////////////////////////////////////////////////

void
property_set_t::dump
(
IN const char * title
)
const
throw()
{
        DPRINTF("property_set_t %s:", title);
        for (property_set_t::const_iterator i = this->begin(); i != this->end();
             ++i) {
                const char * name = i->first.c_str();
                const property_t& prop = i->second;
                prop.dump(name);
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      ListImpl - implementation of the objtree::List API
//
////////////////////////////////////////////////////////////////////////////////

class ListImpl : public List {
public:
        ~ListImpl(void) throw() { }

        void initialize(void) throw() { }

        // objtree::List class interface methods -------------------------------
        virtual bool addObject(IN const char * id);
        virtual bool removeObject(IN const char * id);
        virtual void getObjects(IN const char * id_query,
                                OUT VecString& ids);
        virtual void getProperties(IN const char * id_query,
                                OUT property_set_t& pset);
        virtual void addProperties(IN const char * id_query,
                                IN const property_set_t& pset);
        virtual void setProperties(IN const char * id_query,
                                IN const property_set_t& pset);

private:
        // private typedefs ----------------------------------------------------
        typedef std::map<std::string, smart_ptr<property_set_t> > obj_map_t;

        // private helper methods ----------------------------------------------
        void getPaths(IN const char * query, OUT VecString& ids);

        // private member data -------------------------------------------------
        obj_map_t               m_objects;
};


////////////////////////////////////////////////////////////////////////////////
//
//      ListImpl -- objtree::List class interface methods
//
////////////////////////////////////////////////////////////////////////////////

bool
ListImpl::addObject
(
IN const char * id
)
{
        ASSERT(id, "null");
        verifyLowerCase(id);

        obj_map_t::iterator i = m_objects.find(id);
        if (m_objects.end() != i)
                return false;   // can't add, already have an object here

        smart_ptr<property_set_t> props = new property_set_t;
        m_objects[id] = props;

        return true;
}



bool
ListImpl::removeObject
(
IN const char * id
)
{
        ASSERT(id, "null");
        verifyLowerCase(id);

        obj_map_t::iterator i = m_objects.find(id);
        if (m_objects.end() == i) {
                DPRINTF("Can't remove object, not in tree: '%s'", id);
                return false;
        }
        m_objects.erase(i);

        return true;
}



void
ListImpl::getObjects
(
IN const char * id_query,
OUT VecString& ids
)
{
        verifyLowerCase(id_query);

        this->getPaths(id_query, ids);
}



void
ListImpl::getProperties
(
IN const char * id_query,
OUT property_set_t& pset
)
{
        verifyLowerCase(id_query);

        VecString ids;
        this->getPaths(id_query, ids);

        // accumulate common properties
        SetString invalid;
        pset.clear();

        // loop through all objects found for this id query
        for (VecString::iterator i = ids.begin(); i != ids.end(); ++i) {

                // retrieve object (object == property set)
                const property_set_t * ps = m_objects[*i];
                ASSERT(ps, "null property set");

                // loop through all properties for this object
                for (property_set_t::const_iterator k = ps->begin();
                     k != ps->end(); ++k) {
                        const char * name = k->first.c_str();

                        const property_t * p = &k->second;
                        ASSERT(p, "null property");

                        // is this property already in the output set?
                        property_t * q = pset.getProperty(name);
                        if (!q) {
                                // haven't seen this property before--add it
                                pset[name] = *p;
                        } else {
                                // already in output set--does value match?
                                if (!strcmp(q->getValue(), p->getValue()))
                                        q->setValue(NULL);      // mismatch, so clear
                        }
                }
        }
}


void
ListImpl::addProperties
(
IN const char * id_query,
IN const property_set_t& pset
)
{
        verifyLowerCase(id_query);

        // get all objects that match query
        VecString ids;
        this->getPaths(id_query, ids);

        // loop through all objects
        for (VecString::iterator i = ids.begin(); i != ids.end(); ++i) {

                obj_map_t::iterator j = m_objects.find(*i);
                ASSERT(m_objects.end() != j, "object not in map?");
                property_set_t& ps = *j->second;

                // loop through input properties, set on this object
                for (property_set_t::const_iterator k = pset.begin();
                     k != pset.end(); ++k) {
                        const char * name = k->first.c_str();
                        const property_t * p = &k->second;

                        // set property on object
                        ps[name] = *p;
                }
        }
}



void
ListImpl::setProperties
(
IN const char * id_query,
IN const property_set_t& pset
)
{
        verifyLowerCase(id_query);

        // get all objects that match query
        VecString ids;
        this->getPaths(id_query, ids);

        // loop through all objects, set properties
        for (VecString::iterator i = ids.begin(); i != ids.end(); ++i) {

                obj_map_t::iterator k = m_objects.find(*i);
                ASSERT(m_objects.end() != k, "Object not in map?");
                property_set_t * ps = k->second;
                ASSERT(ps, "null");

                // loop through all input properties, set
                for (property_set_t::const_iterator j = pset.begin();
                     j != pset.end(); ++j) {

                        const char * name = j->first.c_str();
                        const property_t * p = &j->second;

                        // see if we have a property of this name, type
                        property_t * q = ps->getProperty(name);
                        if (!q)
                                break;  // no match for name

                        // names match--copy value!
                        q->setValue(p->getValue());
                }
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      ListImpl -- private helper methods
//
////////////////////////////////////////////////////////////////////////////////

void
ListImpl::getPaths
(
IN const char * query,
OUT VecString& ids
)
{
        ASSERT(query, "null");
        verifyLowerCase(query);

        ids.clear();

        for (obj_map_t::iterator i = m_objects.begin(); i != m_objects.end();
             ++i) {
                if (idMatchesQuery(i->first.c_str(), query)) {
                        ids.push_back(i->first);
                }
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      TreeImpl - class that implements the Tree interface
//
////////////////////////////////////////////////////////////////////////////////

class TreeImpl : public Tree {
public:
        ~TreeImpl(void) throw() { }

        void initialize(void) throw() { }

        // objtree::Tree class interface methods -------------------------------
        List * getList(IN const char * name);
        void getListNames(OUT VecString& names);

private:
        // private typedefs ----------------------------------------------------
        typedef std::map<std::string, smart_ptr<List> > map_list_t;

        // private member data -------------------------------------------------
        map_list_t              m_lists;
};



List *
TreeImpl::getList
(
IN const char * name
)
{
        ASSERT(name, "null list name");

        map_list_t::iterator i = m_lists.find(name);
        if (m_lists.end() == i) {
                // DPRINTF("Creating list '%s' on demand", name);
                // create new list
                smart_ptr<List> list = List::create();
                ASSERT(list, "failed to create new list for '%s'", name);
                m_lists[name] = list;
                return list;
        }

        return i->second;
}



void
TreeImpl::getListNames
(
OUT VecString& names
)
{
        names.clear();

        for (map_list_t::iterator i = m_lists.begin(); i != m_lists.end(); ++i)
        {
                names.push_back(i->first);
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      helper methods
//
////////////////////////////////////////////////////////////////////////////////

bool
isValidPropertyName
(
IN const char * name
)
throw()
{
        // we have the same requirements as a datahash (see Datahash)
        return isValidHashKeyName(name);
}



bool
isTrue
(
IN const char * text
)
throw()
{
        ASSERT(text, "null");

        // case-insensitive
        char buffer[6];
        for (int i = 0; i < 5; ++i) {
                buffer[i] = tolower(text[i]);
        }
        buffer[5] = 0;

        // true unless we recognize the text as false
        if (!strcmp("0", buffer))
                return false;
        if (!strcmp("f", buffer))
                return false;
        if (!strcmp("false", buffer))
                return false;

        return true;
}



void
persist
(
IN const property_t& p,
OUT std::string& val
)
{
        ASSERT(false, "Who is calling persist()?");
//      std::ostringstream out;

//      out << p.type << ":" << p.value;

//      val = out.str();
}



void
depersist
(
IN const char * text,
OUT property_t& prop
)
{
        ASSERT(text, "null");
        ASSERT(false, "Who is calling depersist()?");

/*
        const char * p = text;
        while (*p && *p != ':') { ++p; }

        if (!*p || p == text) {
                std::ostringstream out;
                out << "Bad property value: " << text;
                throw std::runtime_error(out.str().c_str());
        }
        ++p;

        prop.type = text;
        prop.value = p;
*/
}



void
save
(
IN std::ostream& stream,
IN const property_set_t& pset
)
{
        stream << "{\n";

        for (property_set_t::const_iterator i = pset.begin(); i != pset.end();
             ++i) {
                std::string val;
                ASSERT(isValidPropertyName(i->first.c_str()),
                    "Persisting invalid property name! '%s'", i->first.c_str());
                persist(i->second, val);
                stream << "\t" << i->first << "\t\"" << val << "\"\n";
        }

        stream << "}\n";
}



void
load
(
IN std::istream& stream,
OUT property_set_t& pset
)
{
        pset.clear();

        std::string token;
        expectToken(stream, "{");
        while (true) {
                getNextToken(stream, token);
                if ("}" == token)
                        break;  // end of properties

                std::string name = token;
                if (!isValidPropertyName(name.c_str())) {
                        std::ostringstream out;
                        out << "Invalid property name: " << name;
                        throw std::runtime_error(out.str().c_str());
                }

                property_t p;
                getNextToken(stream, token);
                depersist(token.c_str(), p);

                pset[name] = p;
        }
}



smart_ptr<Datahash>
getDatahash
(
IN const property_set_t& pset
)
{
        smart_ptr<Datahash> hash = Datahash::create();
        ASSERT(hash, "failed to create datahash");

        for (property_set_t::const_iterator i = pset.begin(); i != pset.end();
             ++i) {
                const char * name = i->first.c_str();
                const property_t& p = i->second;

                smart_ptr<Datahash> sub = Datahash::create();
                ASSERT(sub, "failed to create subhash");

                // add name and all sub-fields
                sub->insert("name", name);
                for (Dictionary::const_iterator j = p.begin();
                     j != p.end(); ++j) {
                        const char * field = j->first.c_str();
                        const char * value = j->second.c_str();
                        sub->insert(field, value);
                }
                hash->insert("property", sub);
        }

        return hash;
}



void
getPropertySet
(
IN const Datahash * hash,
OUT property_set_t& pset
)
{
        ASSERT(hash, "null");
        pset.clear();

        Datahash::iterator_t i;
        hash->getIterator("property", i);
        while (const hash_value_t * phv = hash->getNextElementUnsafe(i)) {
                if (eHashDataType_Hash != phv->type)
                        continue;               // skip non-subhash values
                const Datahash * sub = phv->hash;               // subhash

                property_t prop;
                Datahash::iterator_t j;
                sub->getIterator(j);    // all elements
                std::string key;
                while (const hash_value_t * phv = sub->getNextElementUnsafe(i, key)) {
                        const char * field = key.c_str();
                        if (!strcmp(field, "name"))
                                continue;       // skip the name field
                        prop.setFieldValue(field, phv->text.c_str());
                }
                pset[getString(sub, "name")] = prop;
        }
}



////////////////////////////////////////////////////////////////////////////////
//
//      factories
//
////////////////////////////////////////////////////////////////////////////////

smart_ptr<List>
List::create
(
void
)
{
        smart_ptr<ListImpl> local = new ListImpl;
        ASSERT(local, "out of memory");

        local->initialize();

        return local;
}



smart_ptr<Tree>
Tree::create
(
void
)
{
        smart_ptr<TreeImpl> local = new TreeImpl;
        ASSERT(local, "out of memory");

        local->initialize();

        return local;
}



};      // objtree namespace