code_review

#ifndef MULTIDISPATCHER2_H_INCLUDED
#define MULTIDISPATCHER2_H_INCLUDED

#include <map>
#include <typeinfo>

/**
    @param ReturnType - type of the return value of handler functions
    @param T1, T2 - base types for dispatching types
    @param default_callback_func - default handler if there is no dispatch for such types
*/
template<
    typename ReturnType,
    typename T1,
    typename T2,
    ReturnType(*default_callback_func)(T1&, T2&)
    >
class Dispatcher2
{
private:

    // Map key

    struct TypeInfo
    {
        const std::type_info& ti1;
        const std::type_info& ti2;

        TypeInfo(const std::type_info& _ti1, const std::type_info& _ti2):
            ti1(_ti1), ti2(_ti2)
        {
        }

        bool operator == (const TypeInfo& typeinfo) const
        {
            return (ti1==typeinfo.ti1 && ti2==typeinfo.ti2);
        }

    };

    struct TypeInfoComp : public std::binary_function<const TypeInfo&, const TypeInfo&, bool>
    {
        bool operator () (const TypeInfo& t1, const TypeInfo& t2) const
        {
            return t1.ti1.before(t2.ti1) || (!(t2.ti1.before(t1.ti1)) && t2.ti2.before(t1.ti2));
        }
    };

    typedef TypeInfo KeyType;

    // Map value

    typedef ReturnType(*CallbackType)(T1&, T2&);

    // Map itself

    typedef std::map<KeyType, CallbackType, TypeInfoComp> MapType;
    MapType callbacks;

public:

    Dispatcher2()
    {
    }

    /**
        add dispatch callback
        @param CT1, CT2 - concrete types (dispatching pair)
    */
    template<typename CT1, typename CT2, ReturnType(*callback)(CT1&, CT2&)>
    void add()
    {
        const KeyType key(typeid(CT1), typeid(CT2));

        struct Local
        {
            static ReturnType trampoline(T1& t1, T2& t2)
            {
                return callback(
                    dynamic_cast<CT1&>(t1),
                    dynamic_cast<CT2&>(t2)
                );
            }
        };

        callbacks[key] = &Local::trampoline;
    }

    void clear()
    {
        callbacks.clear();
    }

    ReturnType run(T1 &t1, T2 &t2)
    {
        try
        {
            // check if dispatcher callback is registered
            const KeyType key(typeid(t1), typeid(t2));

            typename MapType::iterator i = callbacks.find(key);
            if (i != callbacks.end())
            {
                return (*i).second(t1,t2);
            }
        }
        catch (std::exception& e)
        {
        }

        return default_callback_func(t1, t2);
    }

    ReturnType run(T1 *t1, T2 *t2)
    {
        return run(*t1, *t2);
    }

};

#endif // MULTIDISPATCHER2_H_INCLUDED

        struct Thing {
          virtual ~Thing() {}
        };

        struct Rock : Thing {};
        struct Paper : Thing {};
        struct Scissors : Thing {};

        bool Thing_Thing(Thing&, Thing&) { cout << " (T:T) "; return false; }
        bool Paper_Rock(Paper&, Rock&) { cout << " (P:R) "; return true; }
        bool Rock_Scissors(Rock&, Scissors&) { cout << " (R:S) "; return true; }
        bool Sciccors_Paper(Scissors&, Paper&) { cout << " (S:P) "; return true; }

        int main(int, char **)
        {
          Dispatcher2<bool, Thing, Thing, Thing_Thing> compare;

          compare.add<Paper, Rock, Paper_Rock>();
          compare.add<Rock, Scissors, Rock_Scissors>();
          compare.add<Scissors, Paper, Sciccors_Paper>();

          Thing* paper = new Paper();
          Thing* rock = new Rock();

          std::cout << std::boolalpha;
          std::cout << "Paper : Rock " << compare.run(paper, rock) << std::endl;
          std::cout << "Rock : Paper " << compare.run(rock, paper) << std::endl;