DataLayer

//DataLayer.h
#pragma once
#include<boost\any.hpp>
#include<unordered_map>
#include<typeindex>
#include<iostream>

#include "Handle.h"

class DataLayer
{
public:
    DataLayer();
    ~DataLayer();
    template<class T>
    T* create(std::string str);
    template<class T>
    T* getData(std::string);
    template<class T>
    void setData(std::string, T&);
private:
    std::unordered_map<std::string, Handle> data;
};

template<class T>
T* DataLayer::create(std::string str){
    if (data[str].ptr != NULL){
        Deleter_base* deleter = static_cast<Deleter_base*>(data[str].deleter);
        deleter->_delete(data[str]);
        delete deleter;
        std::cout << "Deleting old data at " << str.c_str() << "\n";
    }
    std::cout << "Creating new " << typeid(T).name() << " at " << str.c_str() << "\n";
    data[str].ptr = new T;
    data[str].deleter = new Deleter<T>;
    return static_cast<T*>(data[str].ptr);
}

template<class T>
T* DataLayer::getData(std::string str){
    T* castData = static_cast<T*>(data[str].ptr);
    if (castData == NULL)
        std::cout << "WARNING: Cast from void* to " << typeid(castData).name() << " failed in getData\n";
    return castData;
}

template<class T>
void DataLayer::setData(std::string str, T& toSet){
    if (data[str].ptr == NULL)
        create<T>(str);
    T* ptrToData = static_cast<T*>(data[str].ptr);
    if (ptrToData == NULL){
        std::cout << "WARNING: Cast from void* to " << typeid(ptrToData).name() << " failed in setData\n";
        return;
    }
    else{
        *ptrToData = toSet;
    }
}

//DataLayer.cpp
#include "DataLayer.h"


DataLayer::DataLayer()
{
}


DataLayer::~DataLayer()
{
    for (auto it = data.begin(); it != data.end(); it++){
        std::cout << "~DATALAYER: Deleting " << typeid(it->second).name() << " at " << it->first.c_str() << "\n";
        Deleter_base* deleter = static_cast<Deleter_base*>(it->second.deleter);
        deleter->_delete(it->second);
        delete deleter;
    }
}