core/DataStore.cpp

Go to the documentation of this file.

// /////////////////////////////////////////////////////////////////////////////
//
// Name:            DataStore.cpp
// Author:          Michael Bartsch (ZCCdark203)
//
// Desc :           The DataStore class manages the DataStacks that are being
//                  used by the framework.
//
// License:         Copyright (C) 2009 Michael Bartsch and Contributors
//
//                  This program is free software: you can redistribute it
//                  and/or modify it under the terms of the zlib/libpng License.
//                  See main.cpp for conditions of distribution and use.
//
// /////////////////////////////////////////////////////////////////////////////

// Include files
#include "DataStore.h"


// DataStore class
// DataStore constructor.
DataStore::DataStore()
{
    init();
}

// DataStore deconstructor.
DataStore::~DataStore()
{
    clear();
}

// Initialises the DataStore.
void DataStore::init()
{
}

// Clears the DataStore.
void DataStore::clear()
{
    removeAllDataStacks();
}

// Angelscript: Increases the reference counter.
void DataStore::refAdd()
{
    // Dummy function.
}

// Angelscript: Decreases the reference counter.
void DataStore::refRelease()
{
    // Dummy function.
}

// Adds the given DataStack to the DataStore.
bool DataStore::addDataStack(DataStack *stack)
{
    // Did we get a valid pointer?
    if(stack == NULL)
      return false;

    // Does a DataStack with the same name exist?
    if(getDataStack(stack->getName()))
      return false;

    // Add the DataStack to the vector.
    mStacks.push_back(stack);

    return true;
}

// Creates (and adds) a DataStack with the given name.
DataStack* DataStore::createDataStack(const std::string &name)
{
    // Does a Data Stack with the same name exist?
    if(getDataStack(name))
      return NULL;

    // Create the DataStack and add it to the vector.
    DataStack *stack = new DataStack(name);
    stack->refAdd();
    mStacks.push_back(stack);

    return stack;
}

// Gets the DataStack with the given ID.
DataStack* DataStore::getDataStack(const u32 id)
{
    for(u32 i = 0; i < mStacks.size(); i++)
    {
       if(mStacks[i]->getID() == id)
         return mStacks[i];
    }

    return NULL;
}

// Gets the DataStack with the given name.
DataStack* DataStore::getDataStack(const std::string &name)
{
    for(u32 i = 0; i < mStacks.size(); i++)
    {
       if(mStacks[i]->getName() == name)
         return mStacks[i];
    }

    return NULL;
}

// Removes all DataStacks from this DataStore.
void DataStore::removeAllDataStacks()
{
    // Clear the DataStacks.
    for(u32 i = 0; i < mStacks.size(); i++)
      delete mStacks[i];

    mStacks.clear();
}

// Removes the given DataStack.
bool DataStore::removeDataStack(DataStack *stack)
{
    // Did we get a valid pointer?
    if(stack == NULL)
      return false;

    // Try to remove the DataStack.
    vector<DataStack*>::iterator it;

    for(it = mStacks.begin(); it < mStacks.end(); it++)
    {
        DataStack *dstack = *it;

        if(dstack == stack)
        {
           delete dstack;
           mStacks.erase(it);
           return true;
        }
    }

    // We couldn't find the DataStack and thus couldn't remove it.
    return false;
}

// Removes the given DataStack with the given ID.
bool DataStore::removeDataStack(const u32 id)
{
    // Try to remove the DataStack.
    vector<DataStack*>::iterator it;

    for(it = mStacks.begin(); it < mStacks.end(); it++)
    {
        DataStack *dstack = *it;

        if(dstack->getID() == id)
        {
           delete dstack;
           mStacks.erase(it);
           return true;
        }
    }

    // We couldn't find the DataStack and thus couldn't remove it.
    return false;
}

// Removes the given DataStack with the given name.
bool DataStore::removeDataStack(const std::string &name)
{
    // Try to remove the DataStack.
    vector<DataStack*>::iterator it;

    for(it = mStacks.begin(); it < mStacks.end(); it++)
    {
        DataStack *dstack = *it;

        if(dstack->getName() == name)
        {
           delete dstack;
           mStacks.erase(it);
           return true;
        }
    }

    // We couldn't find the DataStack and thus couldn't remove it.
    return false;
}


// DataStore Angelscript binding.
void bindDataStore(asIScriptEngine *engine)
{
    // Forward declarations.
    int r;

    // Bind DataStore class.
    r = engine->RegisterObjectType("DataStore", sizeof(DataStore), asOBJ_REF); assert(r >= 0);

    // Set DataStore behaviour.
    r = engine->RegisterObjectBehaviour("DataStore", asBEHAVE_ADDREF, "void f()",
                                        asMETHOD(DataStore, refAdd), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectBehaviour("DataStore", asBEHAVE_RELEASE, "void f()",
                                        asMETHOD(DataStore, refRelease), asCALL_THISCALL); assert(r >= 0);

    // Bind DataStore class functions.
    r = engine->RegisterObjectMethod("DataStore", "void init()",
                                     asMETHOD(DataStore, init), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("DataStore", "void clear()",
                                     asMETHOD(DataStore, clear), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("DataStore", "bool addDataStack(DataStack @)",
                                     asMETHOD(DataStore, addDataStack), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("DataStore", "DataStack@ createDataStack(const string &)",
                                     asMETHOD(DataStore, createDataStack), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("DataStore", "DataStack@ getDataStack(const u32)",
                                     asMETHODPR(DataStore, getDataStack, (const u32), DataStack*),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("DataStore", "DataStack@ getDataStack(const string &)",
                                     asMETHODPR(DataStore, getDataStack, (const std::string &), DataStack*),
                                     asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("DataStore", "void removeAllDataStacks()",
                                     asMETHOD(DataStore, removeAllDataStacks), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("DataStore", "bool removeDataStack(DataStack @)",
                                     asMETHODPR(DataStore, removeDataStack, (DataStack*), bool),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("DataStore", "bool removeDataStack(const u32)",
                                     asMETHODPR(DataStore, removeDataStack, (const u32), bool),
                                     asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("DataStore", "bool removeDataStack(const string &)",
                                     asMETHODPR(DataStore, removeDataStack, (const std::string &), bool),
                                     asCALL_THISCALL); assert(r >= 0);
}

// End of File

---