// dispatch.cpp
//
// Copyright (c) 2010
// Steven Watanabe
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

// implements a dynamic dispatcher for boost::any.

#include <boost/any.hpp>
#include <boost/array.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/size.hpp>
#include <boost/thread/once.hpp>
#include <stdexcept>
#include <typeinfo>
#include <iostream>

// A POD pair used in the static table.  It needs to
// have a trivial constructor.  The actual initialization
// will be handled by boost::call_once
template<class T>
struct type_pair {
    const std::type_info* first;
    T second;
};

// comparison operator used to sort the table,
// so that we can do a binary search instead
// of a linear search.
template<class T>
bool operator<(const type_pair<T>& lhs, const type_pair<T>& rhs) {
    return lhs.first->before(*rhs.first) != false;
}

// dummy template needed for mpl::for_each
template<class T>
struct wrap {};

// trampoline function that forwards the overload of
// f for a specific type.
template<class T1, class F, class T>
typename F::result_type dispatch_func(F& f, T& t) {
    using boost::any_cast;
    return f(any_cast<T1&>(t));
}

// exception thrown if we're passed a type that
// we don't know what to do with.
struct bad_function_call : std::runtime_error {
    bad_function_call() : std::runtime_error("bad_function_call") {}
};

// a function object that dispatches
// an any that holds one of a fixed set of types.
template<class Types, class F, class T>
class static_dispatcher {
public:
    typedef typename F::result_type result_type;
    static_dispatcher(const F& f) : f(f) {
        boost::once_flag flag = BOOST_ONCE_INIT;
        boost::call_once(flag, &do_init);
    }
    typename F::result_type operator()(T& t) {
        element_type element = { &t.type(), 0 };
        typename table_type::iterator pos = std::lower_bound(table.begin(), table.end(), element);
        if(pos == table.end()) {
            throw bad_function_call();
        } else {
            return pos->second(f, t);
        }
    }
private:
    typedef typename F::result_type (*function_type)(F&, T&);
    typedef type_pair<function_type> element_type;
    typedef boost::array<element_type, boost::mpl::size<Types>::value> table_type;
    static table_type table;
    struct initializer {
        template<class T1>
        void operator()(const wrap<T1>&) {
            element_type result = {
                &typeid(T1),
                static_cast<function_type>(&dispatch_func<T1, F, T>)
            };
            *(*current)++ = result;
        }
        element_type** current;
    };
    static void do_init() {
        element_type* current = &table[0];
        initializer init = { &current };
        boost::mpl::for_each<Types, wrap<boost::mpl::_> >(init);
        std::sort(table.begin(), table.end());
    }
    F f;
};

template<class Types, class F, class T>
typename static_dispatcher<Types, F, T>::table_type static_dispatcher<Types, F, T>::table;

// Now let's have a simple function object.
struct print {
    typedef void result_type;
    template<class T>
    void operator()(const T& t) const {
        std::cout << t << std::endl;
    }
};

int main() {
    static_dispatcher<boost::mpl::vector<int, char, double>, print, boost::any> f = print();
    boost::any a = 1;
    f(a);
    a = 2.5;
    f(a);
    a = 'a';
    f(a);
}