#include <assert.h>
#include <iostream>
#include <queue>
#include <string>


class HolderBase
{
  public:
    template <class Fn>
    void Dispatch(Fn f)
    {
      // it should call Holder<T>::Dispatch(f);
    }
};


template <class T>
class Holder : public HolderBase
{
  public:
    Holder(const T& t)
      : m_t(t)
    {
    }

    template <class Fn>
    void Dispatch(Fn f)
    {
      f(t);
    }
  private:
    T m_t;
};


class Queue
{
  public:
    template <class T>
    void push(T t)
    {
        m_queue.push(new Holder<T>(t));// TODO smart ptr?
    };

    template <class TDispatcher>
    void pop(TDispatcher oDispatcher)
    {
        assert(!m_queue.empty());

        HolderBase* p = m_queue.front(); // TODO RAII
        m_queue.pop();
        p->Dispatch(oDispatcher);
        delete p;
    };

    bool empty() const
    {
        return m_queue.empty();
    }
  private:
    std::queue<HolderBase*> m_queue;
};


//-------------------------------------------------------------------------------------------DispatcherSet

template<class ...TDispatchers> 
class DispatcherSet;

template<class TDispatcher, class ...TDispatchers> 
class DispatcherSet<TDispatcher, TDispatchers...> : public TDispatcher, public DispatcherSet<TDispatchers...>
{
  public:
    DispatcherSet(TDispatcher oDispatcher, TDispatchers... oDispatchers)
      : TDispatcher                   (oDispatcher),
        DispatcherSet<TDispatchers...>(oDispatchers...)
    {
    }

    using TDispatcher::operator();
    using DispatcherSet<TDispatchers...>::operator();
};


template<class TDispatcher>
class DispatcherSet<TDispatcher> : public TDispatcher
{
  public:
    DispatcherSet(TDispatcher oDispatcher)
      : TDispatcher(oDispatcher)
    {
    }

    using TDispatcher::operator();
};


template<class ...TDispatchers> 
DispatcherSet<TDispatchers...> CreateDispatchers(TDispatchers... oDispatchers)
{
  return DispatcherSet<TDispatchers...>(oDispatchers...);
}

//-------------------------------------------------------------------------------------------

void IntLog(int n)
{
  std::cout << "IntLog: n = " << n << std::endl;
}


void StrLog(const std::string& str)
{
  std::cout << "StrLog: str = " << str << std::endl;
}
//-------------------------------------------------------------------------------------------


int main(int argc, char* argv[])
{
    Queue q;

    int n = 0;
    std::string str("asdf");
    q.push(n);
    q.push(str);

    auto oDispatcher = CreateDispatchers(
                                         [](int                n  ){ IntLog(n);   },
                                         [](const std::string& str){ StrLog(str); },
                                         [](float              f  ){ std::cout << "float = " << f << std::endl; }
                                        );
    // test
    //oDispatcher(n);
    //oDispatcher(n);
    //oDispatcher(str);

    while(!q.empty())
      q.pop(oDispatcher);

    return 0;
}