resources.cpp

Go to the documentation of this file.

/*
 * resources.cpp
 *
 * Copyright (C) 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.
 *
 *
 * Resource APIs
 */

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

#include "threadsafe/smart_ptr.h"



struct resource_t {
        // constructor, manipulators
        resource_t(void) throw() { this->clear(); }
        void clear(void) throw() {
                        name.clear();
                        value = NULL;
                        bytes = 0;
                }

        // data fields
        std::string             name;   // name of resource
        const byte_t *          value;  // someone else owns data
        int                     bytes;  // size of value array
};


typedef std::map<std::string, resource_t> res_map_t;


struct res_namespace_t {
        // constructor, manipulators
        res_namespace_t(void) throw() { this->clear(); }
        void clear(void) throw() {
                        name.clear();
                        resources.clear();
                }

        // data fields
        std::string             name;   // name of namespace
        res_map_t               resources;// resource map in namespace
};


typedef std::map<std::string, smart_ptr<res_namespace_t> > namespace_map_t;



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

static namespace_map_t *
getNamespaceMap
(
void
)
throw()
{
        // our static (global) map of all resources, keyed by namespace
        static namespace_map_t * s_map = NULL;
        if (!s_map) {
                s_map = new namespace_map_t;
                ASSERT(s_map, "out of memory");
        }
        return s_map;
}



static res_map_t *
getResourceMap
(
IN namespace_map_t * nmap,
IN const char * nameSpace,
IN eCreateFlag createBehavior
)
{
        ASSERT(nmap, "null");
        ASSERT(nameSpace, "null");

        namespace_map_t::iterator i = nmap->find(nameSpace);
        if (nmap->end() != i) {
                // found in map!
                res_namespace_t * rmap = i->second;
                ASSERT(rmap, "null namespace in namespace map");
                return &rmap->resources;
        }

        // not in map
        if (eCreateIfNotExists != createBehavior) {
                // not supposed to create it!
                return NULL;
        }

        // we need to create a new entry
        smart_ptr<res_namespace_t> rmap = new res_namespace_t;
        ASSERT(rmap, "out of memory");
        rmap->name = nameSpace;         // copy namespace name

        // add this new resource map to the global map and return it
        nmap->operator[](nameSpace) = rmap;
        return &rmap->resources;
}



static res_map_t *
getResourceMap
(
IN const char * nameSpace,
IN eCreateFlag createBehavior
)
{
        ASSERT(nameSpace, "null");

        namespace_map_t * nmap = getNamespaceMap();
        ASSERT(nmap, "null");

        return getResourceMap(nmap, nameSpace, createBehavior);
}



////////////////////////////////////////////////////////////////////////////////
//
//      internal-only API (pseudo public)
//
////////////////////////////////////////////////////////////////////////////////



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

int
getResourceNamespaceCount
(
void
)
throw()
{
        namespace_map_t * nmap = getNamespaceMap();
        ASSERT(nmap, "null");

        return nmap->size();
}



const char *
getResourceNamespaceName
(
IN int index
)
throw()
{
        namespace_map_t * nmap = getNamespaceMap();
        ASSERT(nmap, "null");

        for (namespace_map_t::const_iterator i = nmap->begin();
             i != nmap->end(); ++i, --index) {
                if (!index) {
                        const res_namespace_t * rmap = i->second;
                        ASSERT(rmap, "null record in namespace map");
                        return rmap->name.c_str();
                }
        }

        return NULL;
}



int
getResourceCount
(
IN const char * nameSpace
)
throw()
{
        ASSERT(nameSpace, "null");

        res_map_t * rmap = getResourceMap(nameSpace, eNullIfNotExists);
        return (rmap) ? rmap->size() : 0;
}



const char *
getResourceName
(
IN const char * nameSpace,
IN int index
)
throw()
{
        ASSERT(nameSpace, "null");

        res_map_t * rmap = getResourceMap(nameSpace, eNullIfNotExists);
        if (!rmap)
                return false;

        for (res_map_t::const_iterator i = rmap->begin();
             i != rmap->end(); ++i, --index) {
                if (!index) {
                        const resource_t& res = i->second;
                        return res.name.c_str();
                }
        }

        return false;
}



int
getResourceSize
(
IN const char * nameSpace,
IN const char * name
)
throw()
{
        ASSERT(nameSpace, "null");
        ASSERT(name, "null");

        res_map_t * rmap = getResourceMap(nameSpace, eNullIfNotExists);
        if (!rmap)
                return false;

        res_map_t::const_iterator i = rmap->find(name);
        if (rmap->end() == i) {
                // resource not found!
                return 0;
        }

        const resource_t& res = i->second;
        return res.bytes;
}



const byte_t *
getResourceData
(
IN const char * nameSpace,
IN const char * name
)
throw()
{
        ASSERT(nameSpace, "null");
        ASSERT(name, "null");

        res_map_t * rmap = getResourceMap(nameSpace, eNullIfNotExists);
        if (!rmap) {
                return NULL;    // no such namespace
        }

        res_map_t::const_iterator i = rmap->find(name);
        if (rmap->end() == i) {
                return NULL;    // not in map
        }

        return i->second.value;
}



void
registerResource
(
IN const char * nameSpace,
IN const char * name,
IN const byte_t * value,
IN int bytes
)
{
        ASSERT(nameSpace, "null");
        ASSERT(name, "null");
        ASSERT(value, "null");
        ASSERT(bytes > 0, "invalid byte count: %d", bytes);

        res_map_t * rmap = getResourceMap(nameSpace, eCreateIfNotExists);
        ASSERT(rmap, "should always get a map back");

        resource_t res;
        res.name = name;
        res.value = value;
        res.bytes = bytes;

        // we insert (and possibly overwrite!) the new value
        rmap->operator[](name) = res;
}