#include <iostream>
#include <vector>

enum class TypeID {
    String,
    Float,
    Integer
};

template <TypeID>
struct TypeIdentifier {
};

template <>
struct TypeIdentifier<TypeID::String> {
    typedef std::string type;
};

template <>
struct TypeIdentifier<TypeID::Float> {
    typedef float type;
};

template <>
struct TypeIdentifier<TypeID::Integer> {
    typedef int32_t type;
};

struct Data {
    template <typename T>
    std::vector<T> read();
};


template <>
std::vector<std::string> Data::read()
{
    return std::vector<std::string>{ "Zero", "One", "Two" };
}

template <>
std::vector<float> Data::read()
{
    return std::vector<float>{ 0.1, 0.2, 0.3 };
}

template <>
std::vector<int32_t> Data::read()
{
    return std::vector<int32_t>{ 10, 20, 30 };
}

template <typename T>
void print(const T &t)
{
    for (auto && i : t)
        std::cout << i << " ";
    std::cout << "\n";
}

template <typename T>
void printReverse(const T &t)
{
    for (auto it = t.rbegin(); it != t.rend(); it++)
        std::cout << *it << " ";
    std::cout << "\n";
}

template <template <typename> class P>
void dispatcher(const TypeID id, Data &d)
{
    switch (id) {
    case TypeID::String:
        P<TypeIdentifier<TypeID::String>::type>::call(d); break;
    case TypeID::Float:
        P<TypeIdentifier<TypeID::Float>::type>::call(d); break;
    case TypeID::Integer:
        P<TypeIdentifier<TypeID::Integer>::type>::call(d); break;
    }
}

template <typename T>
struct Proc {
    static void call(Data &d)
    {
        auto v = d.read<T>();
        print(v);
    }
};

template <>
struct Proc<int32_t> {
    static void call(Data &d)
    {
        std::cout << "Specialization for int32_t\n";

        auto v = d.read<int32_t>();
        print(v);
    }
};

template <typename T>
struct ProcTwo {
    static void call(Data &d)
    {
        auto v = d.read<T>();
        printReverse(v);
    }
};

template <>
struct ProcTwo<float> {
    static void call(Data &d)
    {
        std::cout << "Specialization for float\n";

        auto v = d.read<float>();
        printReverse(v);
    }
};

int main()
{
    Data d;

    dispatcher<Proc>(TypeID::String, d);
    dispatcher<Proc>(TypeID::Float, d);
    dispatcher<Proc>(TypeID::Integer, d);

    dispatcher<ProcTwo>(TypeID::String, d);
    dispatcher<ProcTwo>(TypeID::Float, d);
    dispatcher<ProcTwo>(TypeID::Integer, d);

    return 0;
}