object_map.cpp

Go to the documentation of this file.

/*
 * object_map.cpp
 *
 * Copyright (C) 2007,2009  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 object map (see vgfx.h)
 */

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

#include <sstream>

#include "common/wave_ex.h"


namespace vgfx {

// destructor implementation
ObjectMap::~ObjectMap(void) throw() { }

// core registration map
typedef std::map<std::string, smart_ptr<Primitive> > primitive_map_t;



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

class MapImpl : public ObjectMap {
public:
        MapImpl(void) throw();
        ~MapImpl(void) throw();

        // public class methods ------------------------------------------------
        void initialize(void);

        // vgfx::ObjectMap class interface methods -----------------------------
        long size(void) const throw();
        void newObjectID(IN const char * prefix,
                                OUT std::string& id);
        void addObject(IN smart_ptr<Primitive>&);
        Primitive * findObject(IN const char * id) const throw();
        smart_ptr<Primitive> removeObject(IN const char * id);

private:
        // private member data -------------------------------------------------
        primitive_map_t         m_map;
        long                    m_counter;
        bool                    m_destroying;
};



MapImpl::MapImpl
(
void
)
throw()
{
        m_destroying = false;
        m_counter = time(NULL) >> 16;
}



MapImpl::~MapImpl
(
void
)
throw()
{
        m_destroying = true;
        m_map.clear();
}



void
MapImpl::initialize
(
void
)
{
        // nothing to do!
}



void
MapImpl::newObjectID
(
IN const char * prefix,
OUT std::string& id
)
{
        if (!prefix) {
                prefix = "obj";
        }

        char buffer[64];
        while (true) {
                sprintf(buffer, "%s%lx", prefix, m_counter);
                if (!objtree::isValidPropertyName(buffer)) {
                        WAVE_EX(wex);
                        wex << "Bad prefix--invalid property name: '" << buffer;
                        wex << "'";
                }
                ++m_counter;

                vgfx::Primitive * p = this->findObject(buffer);
                if (!p) {
                        id = buffer;
                        return;
                }
        }
}



long
MapImpl::size
(
void
)
const throw()
{
        if (m_destroying)
                return 0;
        return m_map.size();
}



void 
MapImpl::addObject
(
IN smart_ptr<Primitive>& p
)
{
        ASSERT(!m_destroying, "destroying ourselves");
        ASSERT(p, "null primitive passed in to addObject()");
        const char * id = p->getID();
        ASSERT(id, "object has a null ID");

        if (!objtree::isValidPropertyName(id)) {
                WAVE_EX(wex);
                wex << "Invalid object id: '" << id << "'.  IDs should contain";
                wex << " lower-case letters and numbers only, and must begin ";
                wex << "with a lower-case letter.";
        }

        if (this->findObject(id)) {
                WAVE_EX(wex);
                wex << "Already have an object with id '" << id << "'";
        }

        m_map[id] = p;
}



Primitive * 
MapImpl::findObject
(
IN const char * id
)
const throw()
{
        ASSERT(id, "null ID passed in to findObject()");
        if (m_destroying)
                return NULL;

        // is this a good ID?
        if (!objtree::isValidPropertyName(id)) {
                WAVE_EX(wex);
                wex << "malformed object id: '" << id << "'";
        }

        primitive_map_t::const_iterator i = m_map.find(id);
        if (m_map.end() == i) {
                // DPRINTF("  not found!");
                return NULL;    // not found
        }

        // found it!
        // TODO: why do I have to do this nasty cast?  Necessary?
        //   I want to let people do lookups of objects in the registry.
        //   The lookup should be const on the registry, even though
        //      clients get a non-const object pointer back.
        const Primitive * p = i->second;
        return (Primitive *) p;
}



smart_ptr<Primitive> 
MapImpl::removeObject
(
IN const char * id
)
{
        // actually, there are valid use cases where objects want to
        // be removed as the map is destructing.
        //ASSERT(!m_destroying, "destroying ourselves");
        if (m_destroying) {
                return NULL;    // no-op...
        }

        // look up the object
        ASSERT(id, "NULL id passed in to removeObject()");
        primitive_map_t::iterator i = m_map.find(id);
        if (m_map.end() == i) {
                WAVE_EX(wex);
                wex << "Cannot remove object from map: id '" << id;
                wex << "' not found.";
        }
        smart_ptr<Primitive> p = i->second;
        ASSERT(p.get_ref_count() > 1, "Bad ref count?");

        // only allowed to remove if ref count is zero!
        long refs = p->getRefCount();
        if (refs > 0) {
                WAVE_EX(wex);
                wex << "Cannot remove object '" << id << "' from map: ";
                wex << refs << " object(s) are still using it!";
        }

        // save a copy of the primitive before nuking it from map
        m_map.erase(i);
//      ASSERT(m_map.end() == m_map.find(id),
//          "Just removed an object, but I can still find it???");

        return p;
}



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

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

        local->initialize();

        return local;
}


};      // vgfx namespace