Is it appropriate to emulate templated data members? - c++

Question

I'm trying to implement a variation of the Observer pattern that buffers different event types and came to an impasse.
This is what I'm trying to go for:
class Foo
{
/* ..... */
std::vector<Base*> buf;
template<typename T>
void newEvent(T ev)
{
/* I give the list of observers to each event.
* There are billions of events coming in for
* each run of the application
*/
buf.push_back(new Event<T>(ev, &observers<T>));
}
/* Illegal, templated data members */
template<typename T>
std::vector<Observer<T>*> observers;
template<typename T>
void attach(Observer<T> obs)
{
/* Each type has its own list of observers */
observers<T>.push_back(obs);
}
/* ..... */
};
Later on when the buffer is flushed...
void Foo::flush()
{
for (Base* ev : buf)
{
ev->notifyAll();
delete ev;
}
}
template <typename T>
class Event : public Base
{
/* ..... */
Event(T t, const std::vector<Observer*>& o):observers(o),payload(t){}
void notifyAll()
{
for (Observer* obs : observers)
obs->onNotify(this->payload);
}
};
The type from the template is just a POD coming in from the outside. When it gets packaged up, I give it the list of observers. Now I could just manually define each type of observer vector in Foo, but I want to be able to support an undefined number of 'Event' types.
I know templated data members of a class are illegal, even in c++14 where there is some more support templated variables.
Does it make sense to keep going down this path? Originally I had the "observers" part statically in each 'Event' type, but I'm trying to get rid of as much global state as I can, for testability.
I'm trying to just move things into a class template, instead, but then I'm having trouble there, too.
template <typename T>
class EventHandler //can't think of a good name for this demon baby
{
public Base* create(T t); //when I create a new event, I need the observer list
public void attach(Observer<T>);
private std::vector<Observer<T>*> observers;
};
class Buffer
{
/* ..... */
EventHandler<EventType1> thing1;
EventHandler<EventType2> thing2;
EventHandler<EventType3> thing3;
template<typename T>
public newEvent(T ev) //I could just explicitly say the type here
{
buf.push_back(thing?.create(ev)); //how to know which one to use?
}
};
I run into the same problem from the other angle :/. I also thought about just switching on the type id but thought it was messy.

Answer 1

One way would be using std::type_index:
class event_handler_base{
public:
virtual ~event_handler_base(){}
};
template<typename T>
class event_handler: public event_handler_base{
public:
void handle(T ev){ /* handle event */ }
};
class my_special_class{
public:
~my_special_class(){
for(auto &&p : handlers)
delete p.second;
}
template<typename T>
void new_event(T ev){
get_handler<T>().handle(ev);
}
template<typename T>
event_handler<T> &get_handler(){
static std::type_index ti(typeid(T));
auto it = handlers.find(ti);
if(it == handlers.end())
it = handlers.emplace(ti, new event_handler<T>()).first;
return dynamic_cast<event_handler<T>&>(*it->second);
}
std::unordered_map<std::type_index, event_handler_base*> handlers;
};
I wouldn't prefer this method if you can figure out a compile-time answer, but it is still interesting. Always prefer compile time cost over run time cost.