core/DataStack.cpp

Go to the documentation of this file.

// /////////////////////////////////////////////////////////////////////////////
//
// Name:            DataStack.cpp
// Author:          Michael Bartsch (ZCCdark203)
//
// Desc :           DataStacks provide an interface for storing (and removing)
//                  variables that can be accessed from anywhere within the
//                  framework. Furthermore it's also possible to save these
//                  variables into files.
//
// 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 "DataStack.h"
#include "GameManager.h"


// DataStack class
// Static variables.
u32 DataStack::mIDCount = 0;

// DataStack constructor.
DataStack::DataStack(const std::string &name)
: mRefCount(1), mName(name)
{
    mID = mIDCount++;
}

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

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

// Clears the DataStack.
void DataStack::clear()
{
    removeAll();
}

// AngelScript: Will be used to instanciate objects of this class.
DataStack* DataStack::refFactory(const std::string &name)
{
    return new DataStack(name);
}

// Angelscript: Increases the reference counter.
void DataStack::refAdd()
{
    mRefCount++;
}

// Angelscript: Decreases the reference counter.
void DataStack::refRelease()
{
    if(--mRefCount == 0)
    {
       if(!GameManager::Instance()->getDataStore()->removeDataStack(this))
         delete this;
    }
}

// Gets the ID of the DataStack.
u32 DataStack::getID() const
{
    return mID;
}

// Gets the name of the DataStack.
const std::string& DataStack::getName() const
{
    return mName;
}

// Gets the number of variables on the DataStack.
u32 DataStack::getSize() const
{
    return mVars.size();
}

// Try to find the given variable.
std::string DataStack::getVar(const std::string &name)
{
    // Try to find the given variable.
    std::map<std::string, std::string>::iterator it;
    it = mVars.find(name);

    // Did we find the variable?
    if(it != mVars.end())
      return it->second;

    // We didn't find the variable.
    else return NULL;
}

// Removes all variables from this DataStack.
void DataStack::removeAll()
{
    mVars.clear();
}

// Removes the variable with the given name.
bool DataStack::removeVar(const std::string &name)
{
    std::map<std::string, std::string>::iterator it;
    it = mVars.find(name);

    if(it != mVars.end())
    {
       mVars.erase(it);
       return true;
    }

    else return false;
}

// Saves the Data Stack as a bencoded file.
bool DataStack::saveBencode(const std::string &fileName)
{
    // Get pointer to the File System of Irrlicht.
    IFileSystem *fileSystem = GameManager::Instance()->getDevice()->getFileSystem();

    // Open the file.
    IWriteFile *file = fileSystem->createAndWriteFile(fileName.c_str());

    // Create a buffer.
    std::stringstream fBuffer;

    // Write the header to the buffer.
    fBuffer << "d3:fidi2419e5:ftype3:bdse";

    // Write the contents of the data stack to the buffer.
    fBuffer << "d";

    std::map<std::string, std::string>::iterator it;
    for(it = mVars.begin(); it != mVars.end(); it++)
    {
        fBuffer << it->first.size() << ":" << it->first;
        fBuffer << it->second.size() << ":" << it->second;
    }

    fBuffer << "e";

    // Write to the file.
    file->write(fBuffer.str().c_str(), fBuffer.str().size());

    // Close the file.
    file->drop();

    return true;
}

// Loads the Data Stack from a bencoded file.
bool DataStack::loadBencode(const std::string &fileName)
{
    // Get pointer to the File System of Irrlicht.
    IFileSystem *fileSystem = GameManager::Instance()->getDevice()->getFileSystem();

    // Does the file exist?
    if(!fileSystem->existFile(fileName.c_str()))
      return false;

    // Open the given file and load the contents to the buffer.
    IReadFile *file = fileSystem->createAndOpenFile(fileName.c_str());

    long fSize = file->getSize();
    c8 *fBuffer = new c8[fSize+1];
    file->read(fBuffer, fSize);
    file->drop();

    // Indentify the file as Bencoded Data Stack.
    std::string fHeader = std::string(fBuffer).substr(0, 25);

    if(fHeader != "d3:fidi2419e5:ftype3:bdse")
      return false;

    // Delete any previous data.
    removeAll();

    // Get remaining data from the file.
    std::stringstream bCountStream;
    unsigned long bCount = 0;

    int state = 0;
    std::string key;
    std::string value;

    for(unsigned int i = 25; i < fSize; i++)
    {
        if(bCount != 0)
        {
           if(state == 0)
             key += fBuffer[i];

           else if(state == 1)
             value += fBuffer[i];

           bCount--;
        }

        else
        {
           if(!key.empty())
             state = 1;

           if(!value.empty())
           {
              mVars[key] = value;
              key.clear();
              value.clear();
              state = 0;
           }

           if(fBuffer[i] >= '0' && fBuffer[i] <= '9')
             bCountStream << fBuffer[i];
        }

        if(fBuffer[i] == ':')
        {
            bCountStream >> bCount;
            bCountStream.clear();
        }
    }

    // Remove the buffer.
    delete[] fBuffer;

    // We're done.
    return true;
}

// Saves the Data Stack as a XML file.
bool DataStack::saveXML(const std::string &fileName)
{
    // Get pointer to the File System of Irrlicht.
    IFileSystem *fileSystem = GameManager::Instance()->getDevice()->getFileSystem();

    // Open the file.
    IWriteFile *file = fileSystem->createAndWriteFile(fileName.c_str());

    // Create a buffer.
    std::stringstream fBuffer;

    // Write the header to the buffer.
    fBuffer << "<?xml version=\"1.0\"?>\n";

    // Write the contents of the data stack to the buffer.
    fBuffer << "<datastack>\n";

    std::map<std::string, std::string>::iterator it;
    for(it = mVars.begin(); it != mVars.end(); it++)
      fBuffer << "   <var name=\"" << it->first << "\" value=\"" << it->second << "\" />\n";

    fBuffer << "</datastack>";

    // Write to the file.
    file->write(fBuffer.str().c_str(), fBuffer.str().size());

    // Close the file.
    file->drop();

    return true;
}

// Loads the Data Stack from a XML file.
bool DataStack::loadXML(const std::string &fileName)
{
    // Get pointer to the File System of Irrlicht.
    IFileSystem *fileSystem = GameManager::Instance()->getDevice()->getFileSystem();

    // Does the file exist?
    if(!fileSystem->existFile(fileName.c_str()))
      return false;

    // Open the file.
    IXMLReader *file = fileSystem->createXMLReader(fileName.c_str());

    if(!file)
      return false;

    // Read from the file.
    bool isDataStack = false;

    while(file && file->read())
    {
       switch(file->getNodeType())
       {
          case io::EXN_ELEMENT:

             // Did we find a <datastack>?
             if(core::stringw("datastack") == file->getNodeName())
               isDataStack = true;

             // Did we find a <var>?
             if(isDataStack)
             {
                if(core::stringw("var") == file->getNodeName())
                {
                   core::stringc name = file->getAttributeValue(L"name");
                   core::stringc value = file->getAttributeValue(L"value");
                   mVars[name.c_str()] = value.c_str();
                }
             }

             break;

         default:
            break;
        }
    }

    if(!isDataStack)
      return false;

    // Close the file.
    file->drop();

    return true;
}


// DataStack Angelscript binding.
template<typename T>
void bindSetGetVar(asIScriptEngine *engine, const std::string &asType)
{
    // Forward declarations.
    int r;
    std::stringstream ss;

    // Binds DataStack::setVar<T>
    ss.str("");
    ss << "bool set_" << asType << "(const string&, const " << asType << ")";
    r = engine->RegisterObjectMethod("DataStack", ss.str().c_str(),
                                     asMETHODPR(DataStack, setVar<T>, (const std::string&, const T&), bool),
                                     asCALL_THISCALL); assert(r >= 0);

    // Binds DataStack::getVar<T>
    ss.str("");
    ss << asType << " get_" << asType << "(const string&)";
    r = engine->RegisterObjectMethod("DataStack", ss.str().c_str(),
                                     asMETHODPR(DataStack, getVar<T>, (const std::string&), T),
                                     asCALL_THISCALL); assert(r >= 0);
}

void bindDataStack(asIScriptEngine *engine)
{
    // Forward declarations.
    int r;

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

    // Set DataStack behaviour.
    r = engine->RegisterObjectBehaviour("DataStack", asBEHAVE_FACTORY, "DataStack@ f(const string &)",
                                        asFUNCTION(DataStack::refFactory), asCALL_CDECL); assert(r >= 0);
    r = engine->RegisterObjectBehaviour("DataStack", asBEHAVE_ADDREF, "void f()",
                                        asMETHOD(DataStack, refAdd), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectBehaviour("DataStack", asBEHAVE_RELEASE, "void f()",
                                        asMETHOD(DataStack, refRelease), asCALL_THISCALL); assert(r >= 0);

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

    r = engine->RegisterObjectMethod("DataStack", "u32 getID()",
                                     asMETHOD(DataStack, getID), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("DataStack", "const string& getName()",
                                     asMETHOD(DataStack, getName), asCALL_THISCALL); assert(r >= 0);

    // Bind DataStack::setVar<T> and DataStack::getVar<T>
    bindSetGetVar<s32>(engine, "s32");
    bindSetGetVar<c8>(engine, "c8");
    bindSetGetVar<f32>(engine, "f32");
    bindSetGetVar<f64>(engine, "f64");
    bindSetGetVar<s16>(engine, "s16");
    bindSetGetVar<s32>(engine, "s32");
    bindSetGetVar<u16>(engine, "u16");
    bindSetGetVar<u32>(engine, "u32");
    bindSetGetVar<u8>(engine, "u8");
    bindSetGetVar<std::string>(engine, "string");

    r = engine->RegisterObjectMethod("DataStack", "void removeAll()",
                                     asMETHOD(DataStack, removeAll), asCALL_THISCALL); assert(r >= 0);
    r = engine->RegisterObjectMethod("DataStack", "bool removeVar(const string &)",
                                     asMETHOD(DataStack, removeVar), asCALL_THISCALL); assert(r >= 0);

    r = engine->RegisterObjectMethod("DataStack", "bool saveBencode(const string &)",
                                     asMETHOD(DataStack, saveBencode), asCALL_THISCALL);assert(r >= 0);
    r = engine->RegisterObjectMethod("DataStack", "bool loadBencode(const string &)",
                                     asMETHOD(DataStack, loadBencode), asCALL_THISCALL);assert(r >= 0);

    r = engine->RegisterObjectMethod("DataStack", "bool saveXML(const string &)",
                                     asMETHOD(DataStack, saveXML), asCALL_THISCALL);assert(r >= 0);
    r = engine->RegisterObjectMethod("DataStack", "bool loadXML(const string &)",
                                     asMETHOD(DataStack, loadXML), asCALL_THISCALL);assert(r >= 0);
}

// End of File

---