typeinst.cpp

Go to the documentation of this file.

/*
 * typeinst.cpp
 *
 * Copyright (C) 2008,2009,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 basic type/instance routines.
 */

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

#include <fstream>

#include "common/wave_ex.h"
#include "datahash/datahash_text.h"
#include "datahash/datahash_util.h"
#include "geometry/geometry_3d.h"
#include "perf/perf.h"
#include "story/story.h"
#include "threadsafe/threadsafe_map.h"
#include "threadsafe/threadsafe_queue.h"
#include "util/parsing.h"
#include "util/token_stream.h"


namespace aesop {


// interface destructor implementation
ComponentData::~ComponentData(void) throw() { /*DPRINTF("GOING AWAY");*/ }
Instance::~Instance(void) throw() { }
TypeComponentLoader::~TypeComponentLoader(void) throw() { }


typedef threadsafe_queue<smart_ptr<TypeComponentLoader> > vec_loader_t;

typedef threadsafe_map<std::string, smart_ptr<vec_loader_t> > map_loaders_t;


static map_loaders_t s_loaders;


//
//      static helper methods
//

static void
readIdFromStream
(
IO std::istream& stream,
OUT AESOPIdBuffer& buffer,
IO std::string& token
)
{
        if (!stream.good()) {
                WAVE_EX(wex);
                wex << "bad stream while parsing instances?";
        }

        getNextToken(stream, token);
        buffer.set(token.c_str());
        DPRINTF("  read Id: %s", (const char *) buffer);
}



static bool
isReservedComponent
(
IN const char * name
)
{
        ASSERT(name, "null");

        // reserve empty or anything beginning with underscore
        return (!*name || '_' == *name);
}



//
//      ComponentData -- base class default implementations
//

void
ComponentData::dump
(
IN const char * msg
)
const
throw()
{
        // ASSERT(msg) -- can be null!
        if (msg) {
                DPRINTF("%s", msg);
        }
        DPRINTF("    (data dump not overridden from base class)");
}



//
//      Registry -- local object to maintain type loaders
//

class Registry {
public:
        // constructor, destructor ---------------------------------------------
        Registry(void) throw() { }
        ~Registry(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IN smart_ptr<story::Story>& story);
        void loadInstanceComponentData(IN smart_ptr<Instance>& instance);
        const Datahash * getComponentData(IN const char * typeName,
                                        IN const char * componentName);

private:
        // private typedefs ----------------------------------------------------
        typedef std::map<std::string, smart_ptr<TypeComponentLoader> >
            loader_map_t;

        struct type_rec_t {
                smart_ptr<Datahash>             typeData;
                loader_map_t                    loaders;
        };

        typedef threadsafe_map<std::string, smart_ptr<type_rec_t> > type_map_t;

        // private helper methods ----------------------------------------------
        bool isTypeLoaded(IN const char * typeId);
        smart_ptr<type_rec_t> loadType(IN const char * typeId);
        smart_ptr<type_rec_t> getType(IN const char * typeId);

        // private member data -------------------------------------------------
        smart_ptr<story::Story> m_story;
        type_map_t              m_types;
};


static smart_ptr<Registry> s_registry;          // static instance


void
Registry::initialize
(
IN smart_ptr<story::Story>& story
)
{
        ASSERT(story, "null");

        m_story = story;
}



//
//      Registry -- class methods
//
//      NOTE: all methods on this interface MUST be threadsafe!
//

void
Registry::loadInstanceComponentData
(
IN smart_ptr<Instance>& instance
)
{
        ASSERT(instance, "null");

        const char * typeId = instance->getTypeId();
        DPRINTF("Loading instance component data for type %s", typeId);

        smart_ptr<type_rec_t> tr = this->getType(typeId);
        if (!tr) {
                DPRINTF("  No such type?  %s", typeId);
                ASSERT(false, "stop");
                return;
        }
        DPRINTF("Got a type: %s", typeId);

        // loop through all type component loaders and have them load data
        for (loader_map_t::iterator i = tr->loaders.begin();
             i != tr->loaders.end(); ++i) {
                const char * name = i->first.c_str();
                smart_ptr<TypeComponentLoader> tcl = i->second;
                ASSERT(tcl, "null");

                DPRINTF("  Loading '%s' component...", name);

                // get the hash data for this component stored with the type
                smart_ptr<Datahash> hash = getSubhash(tr->typeData, name);
                const char * id = getString(hash, "id");

                // get full path to component file
                std::string full_path = m_story->getObjectPath(name, id);
                DPRINTF("    path: %s", full_path.c_str());

                // invoke component loader
                smart_ptr<ComponentData> cdata =
                    tcl->loadTS(instance, hash, full_path.c_str());

                // update instance
                instance->setComponentData(name, cdata);
        }
}



const Datahash *
Registry::getComponentData
(
IN const char * typeName,
IN const char * componentName
)
{
        ASSERT(typeName, "null");
        ASSERT(componentName, "null");

        smart_ptr<type_rec_t> type = this->getType(typeName);
        if (!type) {
                DPRINTF("No such type: '%s'", typeName);
                return NULL;
        }

        if (!type->typeData) {
                DPRINTF("No type data?  type='%s'", typeName);
                return NULL;
        }

        int nElements = type->typeData->count(componentName);
        if (!nElements) {
                DPRINTF("type '%s' contains no component data: '%s'",
                    typeName, componentName);
                return NULL;
        }
        ASSERT_THROW(1 == nElements, "Type '" << typeName << "' contains "
            "multiple '" << componentName << "' component entries?");

        // type contains a single entry for this component name
        Datahash::iterator_t i;
        type->typeData->getIterator(componentName, i);
        const hash_value_t * hv = type->typeData->getNextElementUnsafe(i);
        ASSERT_THROW(hv, "component disappeared");
        ASSERT_THROW(hv->hash, "component is not a hash");
        return hv->hash;
}



//
//      Registry -- private helper methods
//

smart_ptr<Registry::type_rec_t>
Registry::loadType
(
IN const char * typeId
)
{
        perf::Timer timer("TypeRegistry::loadType");
        ASSERT(typeId, "null");
        ASSERT(m_story, "null");

        // threadsafe!
        // we rely on story and types map being threadsafe
        DPRINTF("Reading type '%s'", typeId);

        // create type record
        smart_ptr<type_rec_t> type_rec = new type_rec_t;
        ASSERT(type_rec, "out of memory");

        // get full path
        std::string path = m_story->getObjectPath("type", typeId);
        path += ".type";        // types are special--get extension always

        // load as datahash
        type_rec->typeData = readHashFromTextFile(path.c_str());
        ASSERT(type_rec->typeData, "null");

        // read keys (components)
        VecString badKeys;
        Datahash * hash = type_rec->typeData;
        Datahash::iterator_t i;
        hash->getIterator(i);
        std::string keystr;
        hash_value_t hv;
        while (hash->getNextElement(i, keystr, hv)) {
                const char * key = keystr.c_str();
                DPRINTF("  key: %s", key);
                smart_ptr<Datahash> data = hv.hash;
                if (!data)
                        continue;       // skip this element

                // get the ID
                const char * id = getString(data, "id");
                DPRINTF("  id: %s", id);

                // what is full path to this object?
                std::string full_path = m_story->getObjectPath(key, id);
                DPRINTF("  path: %s", full_path.c_str());

                // do we have any loaders for this?
                smart_ptr<TypeComponentLoader> tcl;
                smart_ptr<vec_loader_t> pv;
                s_loaders.lookup(key, pv);
                if (pv) {
                        vec_loader_t::iterator_t i;
                        pv->getIterator(i);
                        smart_ptr<TypeComponentLoader> p;
                        while (pv->getNextElement(i, p)) {
                                ASSERT(p, "null loader in queue");
                                DPRINTF("  Checking loader...");
                                if (p->isMyFormat(data, full_path.c_str())) {
                                        tcl = p;
                                        break;
                                }
                        }
                }

                if (!tcl) {
                        // no registered loader for this!  Skip it...
                        DPRINTF("No loader for component %s=%s in type %s (%s)",
                            key, id, typeId, path.c_str());

                        // don't need datahash data either
                        badKeys.push_back(key);
                } else {
                        // have a loader!  Save it for this type
                        DPRINTF("Found a loader for %s=%s in type %s (%s)",
                            key, id, typeId, path.c_str());
                        DPRINTF("  Have %d loaders so far",
                            (int) type_rec->loaders.size());
                        type_rec->loaders[key] = tcl;
                }
        }

        // nuke any bad keys
        for (VecString::const_iterator i = badKeys.begin(); i != badKeys.end();
             ++i) {
                const char * key = i->c_str();
                type_rec->typeData->remove(key);
        }

        // okay, have datahash with all loaded components
        DPRINTF("Have a type, about to insert...");
        m_types.insert(typeId, type_rec);
        DPRINTF("Returning type record now...");
        return type_rec;
}



smart_ptr<Registry::type_rec_t>
Registry::getType
(
IN const char * typeId
)
{
        ASSERT(typeId, "null");

        // threadsafe!  map is threadsafe
        smart_ptr<type_rec_t> result;
        m_types.lookup(typeId, result);

        // if we need to load it, do so now
        return (result) ? result : this->loadType(typeId);
}



//
//      InstImpl -- class that implements the aesop::Instance interface
//

class InstImpl : public Instance {
public:
        // constructor, destructor ---------------------------------------------
        ~InstImpl(void) throw() { }

        // public class methods ------------------------------------------------
        void initialize(IO std::istream& stream);
        void initialize(IN const char * instanceId,
                                IN const char * typeId)
                {
                        if (instanceId) {
                                m_instanceId.set(instanceId);
                        }
                        m_typeId.set(typeId);
                }

        // aesop::Instance class interface methods -----------------------------

        // REMEMBER: must be threadsafe!
        const char * getInstanceId(void) const throw() { return m_instanceId; }
        const char * getTypeId(void) const throw() { return m_typeId; }
        placement_t& getPlacement(void) throw() { return m_placement; }
        void setComponentData(IN const char * name,
                                IN smart_ptr<ComponentData>& data);
        smart_ptr<ComponentData> getComponentData(IN const char * name);
        const Datahash * getTypeComponentData(IN const char * name);
        void dump(IN const char * title) throw();
        void setInstanceData(IN const char * name,
                                IN smart_ptr<Datahash>& data);
        smart_ptr<Datahash> getInstanceData(IN const char * name);

private:
        // private typedefs ----------------------------------------------------
        typedef threadsafe_map<std::string, smart_ptr<ComponentData> >
            data_map_t;

        typedef threadsafe_map<std::string, smart_ptr<Datahash> >
            instData_map_t;

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

        // private member data -------------------------------------------------
        AESOPIdBuffer           m_instanceId;   // ID of this instance
        AESOPIdBuffer           m_typeId;       // ID of the type
        placement_t             m_placement;
        data_map_t              m_data;         // map of component data objects
        instData_map_t          m_instData;     // per-component raw inst data
};



//
//      InstImpl -- public class methods (only accessible in this file)
//

void
InstImpl::initialize
(
IN std::istream& stream
)
{
        ASSERT(stream.good(), "bad?");

        // require these
        bool readTypeId = false;
        bool readPlacement = false;

        // switch based on key
        std::string token;
        for (;;) {
                getNextToken(stream, token);
                if ("}" == token)
                        break;          // all done parsing instance

                // is this a keyword we understand?
                if ("typeId" == token) {
                        readIdFromStream(stream, m_typeId, token);
                        readTypeId = true;
                } else if ("placement" == token) {
                        expectToken(stream, "{");
                        m_placement = parsePlacement(stream);
                        readPlacement = true;
                } else if ("instanceId" == token) {
                        readIdFromStream(stream, m_instanceId, token);
                } else if ("instanceData" == token) {
                        expectToken(stream, "{");
                        smart_ptr<Datahash> hash =
                            readHashFromStream("instanceData", stream);

                        // add subhashes as per-component instance data
                        Datahash::iterator_t i;
                        hash->getIterator(i);
                        std::string keystr;
                        hash_value_t hv;
                        while (hash->getNextElement(i, keystr, hv)) {
                                if (!hv.hash)
                                        continue;       // skip this
                                const char * name = keystr.c_str();
                                DPRINTF("  Setting instance data: %s", name);
                                this->setInstanceData(name, hv.hash);
                        }
                } else {
                        WAVE_EX(wex);
                        wex << "Unexpected keyword while parsing instance: ";
                        wex << token;
                }
        }

        // get all the data we needed?
        if (!readTypeId || !readPlacement) {
                WAVE_EX(wex);
                wex << "Instance is missing type and/or placement.";
        }
}



//
//      InstImpl -- aesop::Instance class interface methods
//

void
InstImpl::setComponentData
(
IN const char * name,
IN smart_ptr<ComponentData>& data
)
{
        ASSERT(name, "null");
        // ASSERT(data) -- can be null

        // threadsafe!  We use a threadsafe collection
        if (data) {
                // caller has provided component data.  update our map
                m_data.insert(name, data);
                return;
        }

        // caller has requested that we clear this component data
        m_data.remove(name);
}



smart_ptr<ComponentData>
InstImpl::getComponentData
(
IN const char * name
)
{
        ASSERT(name, "null");

        smart_ptr<ComponentData> cdata;
        m_data.lookup(name, cdata);
        return cdata;           // will be null if not found
}



const Datahash *
InstImpl::getTypeComponentData
(
IN const char * name
)
{
        ASSERT(name, "null");
        ASSERT(s_registry, "null");

        return s_registry->getComponentData(m_typeId, name);
}



void
InstImpl::dump
(
IN const char * title
)
throw()
{
        DPRINTF("Instance (%s)", title);
        DPRINTF("  instanceId=%s", this->getInstanceId());
        DPRINTF("  typeId=%s", this->getTypeId());
        m_placement.dump("instance");

        // iterate over all components in map
        data_map_t::iterator_t i;
        m_data.getIterator(i);
        std::string name;
        smart_ptr<ComponentData> data;
        while (m_data.getNextElement(i, name, data)) {
                ASSERT(data, "null");

                DPRINTF("  Contains component data: %s", name.c_str());
                std::string msg = "    '";
                msg += name;
                msg += "' component data";
                data->dump(msg.c_str());
        }
}



void
InstImpl::setInstanceData
(
IN const char * name,
IN smart_ptr<Datahash>& data
)
{
        ASSERT(name, "null");
        // ASSERT(data) -- can be null!

        if (data) {
                m_instData.insert(name, data);
        } else {
                m_instData.remove(name);
        }
}



smart_ptr<Datahash>
InstImpl::getInstanceData
(
IN const char * name
)
{
        smart_ptr<Datahash> data;
        m_instData.lookup(name, data);
        return data;            // will be null if not found
}



//
//      Instance -- static factory methods
//

smart_ptr<Instance>
Instance::parse
(
IO std::istream& stream
)
{
        perf::Timer timer("parseInstance");
        ASSERT(stream.good(), "bad?");
        ASSERT(s_registry, "need to call initializeTypeInstanceLibrary()");

        DPRINTF("Parsing instance...");
        smart_ptr<InstImpl> local = new InstImpl;
        ASSERT(local, "out of memory");

        local->initialize(stream);

        smart_ptr<Instance> i = local;
        s_registry->loadInstanceComponentData(i);

        i->dump("Just parsed");

        // all done!
        return i;
}



smart_ptr<Instance>
Instance::create
(
IN const char * instanceId,
IN const char * typeId
)
{
        // ASSERT(instanceId) -- can be null!
        ASSERT(typeId, "null");
        ASSERT(s_registry, "need to call initializeTypeInstanceLibrary()");

        smart_ptr<InstImpl> local = new InstImpl;
        ASSERT(local, "out of memory");

        local->initialize(instanceId, typeId);

        smart_ptr<Instance> i = local;
        s_registry->loadInstanceComponentData(i);

        i->dump("Just created");

        return i;
}



//
//      public API
//

void
registerTypeComponentLoader
(
IN smart_ptr<TypeComponentLoader>& tcl
)
{
        ASSERT(tcl, "null");

        // what type of component does this loader load?
        const char * cName = tcl->getComponentName();
        DPRINTF("Registering component loader: '%s'", cName);
        ASSERT(cName, "null");

        // verify this isn't a reserved keyword
        ASSERT_THROW(!isReservedComponent(cName),
            "Cannot register a type component loader for this type: '" <<
            cName << "'.  That is a reserved type component name.");

        // find vector of loaders for this type
        smart_ptr<vec_loader_t> pv;
        s_loaders.lookup(cName, pv);
        if (!pv) {
                // need to create new map entry!
                smart_ptr<vec_loader_t> pv1 = new vec_loader_t;
                ASSERT(pv1, "out of memory");
                s_loaders.insert(cName, pv1);
                pv = pv1;
        }

        // append to vector
        ASSERT(pv, "should have a vector of component loaders now");
        pv->push_back(tcl);
}



void
initializeTypeInstanceLibrary
(
IN smart_ptr<story::Story>& story
)
{
        ASSERT(story, "null");

        // already have instance?
        if (s_registry) {
                DPRINTF("already created registry!");
                DPRINTF("ignoring redundant initializeTypeInstanceLibrary() call");
                return;
        }

        smart_ptr<Registry> local = new Registry;
        ASSERT(local, "out of memory");
        local->initialize(story);

        // successfully initialized!
        s_registry = local;
}



void
loadInstances
(
IO std::istream& stream,
OUT vec_instance_t& instances
)
{
        perf::Timer timer("loadInstances");
        ASSERT(stream.good(), "bad?");
        instances.clear();

        // keep parsing until end of stream or closing bracket
        std::string token;
        while (true) {
                bool eof = false;
                getNextToken(stream, token, true, &eof);
                if (eof || "}" == token) {
                        break;          // end of list!
                }

                if ("instance" != token) {
                        WAVE_EX(wex);
                        wex << "Invalid token!  Expected 'instance' in ";
                        wex << "instance list, read '" << token << "' instead.";
                }

                // open instance bracket
                expectToken(stream, "{");

                // parse instance
                instances.push_back(Instance::parse(stream));
        }

        // all done!
        DPRINTF("Read %d instances from stream", (int) instances.size());
}



const char *
getKeyWithOverrides
(
IN const char * keyName,
IN const Datahash * instanceData,
IN const Datahash * typeData,
IN const Datahash * modelData,
IN eDatahash_Flag flag
)
{
        ASSERT(keyName, "null");
        // ASSERT(instanceData) -- can be null
        // ASSERT(typeData) -- can be null
        // ASSERT(modelData) -- also can be null!

        const char * val = NULL;        // the value to return

        // check instance data first--it overrides everything else
        if (instanceData) {
                val = getString(instanceData, keyName, eDatahash_Optional);
        }
        if (val) {
                DPRINTF("    Getting value from instance: %s = %s", keyName,
                    val);
                return val;
        }

        // check type data next--it overrides the model data
        if (typeData) {
                val = getString(typeData, keyName, eDatahash_Optional);
        }
        if (val) {
                DPRINTF("    Getting value from type: %s = %s", keyName, val);
                return val;
        }

        // not overridden at all--use base value in model
        if (modelData) {
                val = getString(modelData, keyName, flag);
        }
        if (val) {
                DPRINTF("    Getting value from model: %s = %s", keyName, val);
        }
        return val;
}



};      // aesop namespace