Question

I’ll begin with a context that will lead to the actual question.

I’m trying to build a class whose every instance will manage how data is tied together into objects.
The class should preferably contain methods:

class DataManager {
  Object CreateObject();
  void DestoryObject();

  template<typename DataType>
  DataType* AddDataToObject(Object o)

  template<typename DataType>
  DataType* GetDataForObject(Object o)

  template<typename DataType>
  void RemoveDataFromObject(Object o)
};

Object in the code above is just some identifier – int at this point and does not contain any data or methods (this should not change). DataType used above can be basically any class, however the general situation is that this is just a struct with no methods. The complete list of things that can be used as DataType is known at compile time but should not be encoded as it changes quite often.

The two goals I try to achieve are:
– Maintainability/Speed – The user should be able to add new DataType structures without modifying this code
– Speed – should be as fast as possible 🙂

Now the best thing idea I had so far is to make a container classes:

class ContainerBase;

template<typename DataType>
class DataTypeContainer : ContainerBase;

The data structure then would be something like:

map< DataTypeType, map< Object, ContainerBase* > >

Sow how can one achieve this?
Would boost::mpl::map help and how?

In essence this should be possible to do since all DataType’s are known at compile time.

Answer 1

class DataManager {
    struct internal_base { virtual ~internal_base() {} };
    template<typename T> struct internal_data : public internal_base {
        T t;
    };
    boost::unordered_map<Object, boost::unordered_map<std::string, boost::unique_ptr<internal_base>>> data;
public:
    Object CreateObject() { return Object(); }
    void DestroyObject(Object o) { data.erase(o); }

    template<typename DataType> DataType* AddDataToObject(Object o, std::string name) {
        internal_data<T>* ptr = new internal_data<T>();
        data[o][name] = ptr;
        return &ptr->t;
    }

    template<typename DataType> DataType* GetDataForObject(Object o, std::string name) {
        internal_base* ptr = data[o][name].get();
        if (internal_data<DataType>* dptr = dynamic_cast<internal_data<DataType>*>(ptr)) {
            return &dptr->t;
        else
            return 0;
    }

    void RemoveDataFromObject(Object o, std::string name) {
        data[o][name] = 0;
    }
};

This code makes some assumptions- like default-construction of Object type, and that it is hashable. But it shouldn’t be too difficult to modify. It would be substantially trickier to get defined behaviour if you want just one data member of each type associated with a specific Object, because you can’t rely on RTTI to return unique names for each possible DataType.