/*=============================================================================
    Copyright (c) 2006 Joel de Guzman

    Use, modification and distribution is subject to 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)
==============================================================================*/
#if !defined(BOOST_OVERLOAD_06162006_2345)
#define BOOST_OVERLOAD_06162006_2345

#include <boost/function.hpp>
#include <boost/tuple/tuple.hpp>

namespace boost
{   
    struct final_overload_function
    {
        struct final;
        static int const index = -1;
        void operator()(final*) const {}
    };

    template <typename Base, typename Derived, typename Sig>
    struct overload_function;

    template <typename Base, typename Derived, typename R>
    struct overload_function<Base, Derived, R()> : Base
    {
        using Base::operator();
        static int const index = Base::index + 1;
            
        R operator()() const
        {
            return get<index>(static_cast<Derived const*>(this)->functions)();
        }
    };

    template <typename Base, typename Derived, typename R, typename A0>
    struct overload_function<Base, Derived, R(A0)> : Base
    {
        using Base::operator();
        static int const index = Base::index + 1;
            
        R operator()(A0 a0) const
        {
            return get<index>(static_cast<Derived const*>(this)->functions)(a0);
        }
    };

    template <typename Base, typename Derived, typename R, typename A0, typename A1>
    struct overload_function<Base, Derived, R(A0, A1)> : Base
    {
        using Base::operator();
        static int const index = Base::index + 1;
            
        R operator()(A0 a0, A1 a1) const
        {
            return get<index>(static_cast<Derived const*>(this)->functions)(a0, a1);
        }
    };

    template <typename Base, typename Derived, typename R, typename A0, typename A1, typename A2>
    struct overload_function<Base, Derived, R(A0, A1, A2)> : Base
    {
        using Base::operator();
        static int const index = Base::index + 1;
            
        R operator()(A0 a0, A1 a1, A2 a2) const
        {
            return get<index>(static_cast<Derived const*>(this)->functions)(a0, a1, a2);
        }
    };
    
    template <typename Sig0, typename Sig1, typename Sig2, typename Sig3>
    struct overload;

    namespace detail
    {
        template <typename Sig0, typename Sig1, typename Sig2, typename Sig3>
        struct compose_overload_base
        {
            typedef overload<Sig0, Sig1, Sig2, Sig3> derived;
            typedef overload_function<final_overload_function, derived, Sig0> ov1;
            typedef overload_function<ov1, derived, Sig1> ov2;
            typedef overload_function<ov2, derived, Sig2> ov3;
            typedef overload_function<ov3, derived, Sig3> ov4;
            typedef ov4 type;
        }; 
    }
    
    template <typename Sig0, typename Sig1, typename Sig2, typename Sig3>
    struct overload : detail::compose_overload_base<Sig0, Sig1, Sig2, Sig3>::type
    {
        typedef 
            tuple<
                boost::function<Sig0>
              , boost::function<Sig1>
              , boost::function<Sig2>
              , boost::function<Sig3>
            > 
        functions_type;

        template <int N, typename F>
        void set(F const& f)
        {
            get<N>(functions) = f;
        }
        
        functions_type functions;
    };
}

#endif