/**
 * @file
 * @brief 継承ツリーにタグ番号取得機能を付加し、それに基づくディスパッチ処理を実現するための型や関数を含むファイルです。
 * @author AKIYAMA Kouhei
 * @since 2012-04-19
 *
 * 使用例:
 * @code
 * struct Base : tagged_object::TaggedBase<Base>
 * {
 *   struct DerivedTypes;
 *   bool b;
 *   explicit Base(bool b) : b(b){}
 * };
 *
 * struct D1 : tagged_object::TaggedDerived<D1, Base>
 * {
 *   int i;
 *   D1(int i, bool b) : TaggedDerived(b), i(i){}
 * };
 *
 * struct TAGGED_DERIVED(D2, Base) //D2を二カ所書くのが気に入らなければTAGGED_DERIVEDマクロが使えます。
 * {
 *   double d;
 *   D1(double d, bool b) : TaggedDerived(b), d(d){}
 * };
 *
 * struct Base::DerivedTypes
 * {
 *   typedef boost::mpl::list<
 *       D1,
 *       D2
 *   > Types;
 * };
 *
 *
 * struct Printer
 * {
 *   double operator()(const D1 &d1){ std::cout << "D1 " << d1.i << std::endl; return d1.i;}
 *   double operator()(const D2 &d2){ std::cout << "D2 " << d2.d << std::endl; return d2.d;}
 * };
 * Base *pb = new D2(3.14, true);
 * const double result = dispatch<double>(Printer(), *pb);
 * @endcode
 */
#ifndef TAGGED_OBJECT_H_INCLUDED_20120419
#define TAGGED_OBJECT_H_INCLUDED_20120419

#include <stdexcept>
#include <boost/shared_ptr.hpp>
#include <boost/static_assert.hpp>
#include <boost/mpl/list.hpp>
#include <boost/mpl/index_of.hpp>
#include <boost/mpl/at.hpp>
#include <boost/mpl/size.hpp>
#include "boost/mpl/bool.hpp"
#include "boost/mpl/transform.hpp"

namespace tagged_object{

/**
 * タグ付きオブジェクトの実装を助ける基底クラスです。
 */
template<typename Base>
struct TaggedBase
{
	virtual ~TaggedBase(){}
	virtual int get_tag() const = 0;
};

/**
 * タグ付きオブジェクトの派生クラスの実装を助ける基底クラスです。
 */
template<typename Derived, typename Base>
struct TaggedDerived : Base
{
	TaggedDerived() : Base(){}

	template<typename T0>
	explicit TaggedDerived(const T0 &a0) : Base(a0){}

	template<typename T0, typename T1>
	explicit TaggedDerived(const T0 &a0, const T1 &a1) : Base(a0, a1){}

	template<typename T0, typename T1, typename T2>
	explicit TaggedDerived(const T0 &a0, const T1 &a1, const T2 &a2) : Base(a0, a1, a2){}

	virtual int get_tag() const
	{
		return boost::mpl::index_of<typename Base::DerivedTypes::Types, Derived>::type::value;
	}
};

#define TAGGED_DERIVED(D, B) D : tagged_object::TaggedDerived<D, B>


// ---------------------------------------------------------------------------
// Dispatcher
// ---------------------------------------------------------------------------

template<typename Types, int Index, typename Result, typename Fun, typename ArgPtr>
struct TaggedInvoker
{
	static Result call(Fun &f, ArgPtr a)
	{
		return invoke(f, a, boost::mpl::bool_<(Index < boost::mpl::size<Types>::value)>());
	}

	static Result invoke(Fun &f, ArgPtr a, boost::mpl::false_)
	{
		throw std::out_of_range("index out of range in TaggedInvoker.");
		//return Result(); //requires default constructor.
	}

	template<typename Arg>
	static Result invoke(Fun &f, Arg *a, boost::mpl::true_)
	{
		typedef typename boost::mpl::at_c<Types, Index>::type Derived;
		return f(*static_cast<Derived *>(a));
	}

	template<typename Arg>
	static Result invoke(Fun &f, const Arg *a, boost::mpl::true_)
	{
		typedef typename boost::mpl::at_c<Types, Index>::type Derived;
		return f(*static_cast<const Derived *>(a));
	}

	template<typename Arg>
	static Result invoke(Fun &f, const boost::shared_ptr<Arg> &a, boost::mpl::true_)
	{
		typedef typename boost::mpl::at_c<Types, Index>::type Derived;
		return f(boost::dynamic_pointer_cast<Derived>(a));
	}

	template<typename Arg>
	static Result invoke(Fun &f, const boost::shared_ptr<const Arg> &a, boost::mpl::true_)
	{
		typedef typename boost::mpl::at_c<Types, Index>::type Derived;
		return f(boost::dynamic_pointer_cast<const Derived>(a));
	}
};

template<typename Types, typename Result, typename Fun, typename ArgPtr>
Result dispatch(Fun &f, ArgPtr a, int argtype)
{
	if(!a){
		throw std::invalid_argument("argument is NULL.");
	}
	BOOST_STATIC_ASSERT(boost::mpl::size<Types>::value <= 20);
	switch(argtype){
	case 0: return TaggedInvoker<Types, 0, Result, Fun, ArgPtr>::call(f, a);
	case 1: return TaggedInvoker<Types, 1, Result, Fun, ArgPtr>::call(f, a);
	case 2: return TaggedInvoker<Types, 2, Result, Fun, ArgPtr>::call(f, a);
	case 3: return TaggedInvoker<Types, 3, Result, Fun, ArgPtr>::call(f, a);
	case 4: return TaggedInvoker<Types, 4, Result, Fun, ArgPtr>::call(f, a);
	case 5: return TaggedInvoker<Types, 5, Result, Fun, ArgPtr>::call(f, a);
	case 6: return TaggedInvoker<Types, 6, Result, Fun, ArgPtr>::call(f, a);
	case 7: return TaggedInvoker<Types, 7, Result, Fun, ArgPtr>::call(f, a);
	case 8: return TaggedInvoker<Types, 8, Result, Fun, ArgPtr>::call(f, a);
	case 9: return TaggedInvoker<Types, 9, Result, Fun, ArgPtr>::call(f, a);
	case 10: return TaggedInvoker<Types, 10, Result, Fun, ArgPtr>::call(f, a);
	case 11: return TaggedInvoker<Types, 11, Result, Fun, ArgPtr>::call(f, a);
	case 12: return TaggedInvoker<Types, 12, Result, Fun, ArgPtr>::call(f, a);
	case 13: return TaggedInvoker<Types, 13, Result, Fun, ArgPtr>::call(f, a);
	case 14: return TaggedInvoker<Types, 14, Result, Fun, ArgPtr>::call(f, a);
	case 15: return TaggedInvoker<Types, 15, Result, Fun, ArgPtr>::call(f, a);
	case 16: return TaggedInvoker<Types, 16, Result, Fun, ArgPtr>::call(f, a);
	case 17: return TaggedInvoker<Types, 17, Result, Fun, ArgPtr>::call(f, a);
	case 18: return TaggedInvoker<Types, 18, Result, Fun, ArgPtr>::call(f, a);
	case 19: return TaggedInvoker<Types, 19, Result, Fun, ArgPtr>::call(f, a);
	}
	assert(argtype >= 0 && argtype < 19);
	throw std::out_of_range("argtype out of range.");
}


// reference

template<typename Result, typename Fun, typename Base>
inline Result dispatch(Fun &f, Base &a)
{
	return dispatch<typename Base::DerivedTypes::Types, Result>(f, &a, a.get_tag());
}
template<typename Result, typename Fun, typename Base>
inline Result dispatch(const Fun &f, Base &a)
{
	return dispatch<typename Base::DerivedTypes::Types, Result>(f, &a, a.get_tag());
}

template<typename Result, typename Fun, typename Base>
inline Result dispatch(Fun &f, const Base &a)
{
	return dispatch<typename Base::DerivedTypes::Types, Result>(f, &a, a.get_tag());
}
template<typename Result, typename Fun, typename Base>
inline Result dispatch(const Fun &f, const Base &a)
{
	return dispatch<typename Base::DerivedTypes::Types, Result>(f, &a, a.get_tag());
}

// shared_ptr

template<typename Result, typename Fun, typename Base>
inline Result dispatch(Fun &f, const boost::shared_ptr<Base> &a)
{
	return dispatch<typename Base::DerivedTypes::Types, Result>(f, a, a ? a->get_tag() : -1);
}

template<typename Result, typename Fun, typename Base>
inline Result dispatch(const Fun &f, const boost::shared_ptr<Base> &a)
{
	return dispatch<typename Base::DerivedTypes::Types, Result>(f, a, a ? a->get_tag() : -1);
}

template<typename Result, typename Fun, typename Base>
inline Result dispatch(Fun &f, const boost::shared_ptr<const Base> &a)
{
	return dispatch<typename Base::DerivedTypes::Types, Result>(f, a, a ? a->get_tag() : -1);
}

template<typename Result, typename Fun, typename Base>
inline Result dispatch(const Fun &f, const boost::shared_ptr<const Base> &a)
{
	return dispatch<typename Base::DerivedTypes::Types, Result>(f, a, a ? a->get_tag() : -1);
}


}//namespace tagged_object
#endif