Also, a sneak peek on what I’m currently working on.

DataStore.h

#ifndef __DATASTORE_H__
#define __DATASTORE_H__

// Include files
#include "../dependencies.h"
#include "DataStack.h"

// Forward declarations
class DataStack;

// DataStore class.
class DataStore
{
public:

    // Initialisation and deinitialisation
    DataStore();
    ~DataStore();

    void init();
    void clear();

    // Methods
    bool addDataStack(DataStack *stack);
    DataStack* createDataStack(const std::string &name);

    DataStack* getDataStack(const unsigned int id);
    DataStack* getDataStack(const std::string &name);

    void removeAll();
    bool removeDataStack(DataStack *stack);
    bool removeDataStack(const unsigned int);
    bool removeDataStack(const std::string &name);

private:

    // Normal members
    std::vector<DataStack*> mStacks;

};

#endif

DataStore.cpp

// Include files
#include "DataStore.h"

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

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

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

// Clears the Data Store.
void DataStore::clear()
{
    removeAll();
}

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

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

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

    return true;
}

// Creates a Data Stack 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 Data Stack and add it to the vector.
    DataStack *stack = new DataStack(name);
    mStacks.push_back(stack);

    return stack;
}

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

    return NULL;
}

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

    return NULL;
}

// Removes all Data Stacks from this Data Store.
void DataStore::removeAll()
{
    // Clear the Data Stacks.
    for(unsigned int i = 0; i < mStacks.size(); i++)
      delete mStacks[i];

    mStacks.clear();
}

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

    // Try to remove the Data Stack.
    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 Data Stack and thus couldn't remove it.
    return false;

}

// Removes the given Data Stack with the given id.
bool DataStore::removeDataStack(const unsigned int id)
{
    // Try to remove the Data Stack.
    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 Data Stack and thus couldn't remove it.
    return false;
}

// Removes the given Data Stack with the given name.
bool DataStore::removeDataStack(const std::string &name)
{
    // Try to remove the Data Stack.
    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 Data Stack and thus couldn't remove it.
    return false;
}

// End of File

DataStack.h

#ifndef __DATASTACK_H__
#define __DATASTACK_H__

// Include files
#include "../dependencies.h"
#include "DataStore.h"

// Forward declarations.
class DataStore;

// DataStack class.
class DataStack
{

    friend class DataStore;

public:

    // Initialisation and deinitialisation
    DataStack(const std::string &name);
    ~DataStack();

    void init();
    void clear();

    // Methods
    unsigned int getID() const;
    const std::string& getName() const;

    unsigned int getSize() const;

    // Sets the variable with the given name.
    template<typename T>
    bool setVar(const std::string &name, const T &value)
    {
        std::stringstream ss;
        ss << value;

        if(ss.good())
        {
           mVars[name] = ss.str();
           return true;
        }

        else return false;
    };

    // Gets the variable with the given name.
    template<typename T>
    T getVar(const std::string &name)
    {
        std::map<std::string, std::string>::iterator it;
        it = mVars.find(name);

        if(it != mVars.end())
        {
           std::stringstream ss(it->second);

           T t;
           ss >> t;
           return t;
        }

        else return NULL;
    };

    void removeAll();
    bool removeVar(const std::string &name);

    //bool save(const std::string &filename); TODO
    //bool load(const std::string &filename); TODO

private:

    // Static members
    static unsigned int mIDCount;

    // Normal members
    unsigned int mID;
    std::string mName;

    std::map<std::string, std::string> mVars;
};

#endif

DataStack.cpp

// Include files.
#include "DataStack.h"

// DataStack class
// Static variables.
unsigned int DataStack::mIDCount = 0;

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

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

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

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

// Gets the ID of the Data Stack.
unsigned int DataStack::getID() const
{
    return mID;
}

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

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

// Removes all variables from this Data Stack.
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;
}

// End of File

Remember that all of the above code has been placed in the public domain and that I’ll take no responsibility or liability of any kind for any use that you may make of this code.