// 2007 Hiroyuki Ogasawara
// vim:ts=4 sw=4:
// http://dench.flatlib.jp/
/*!
	@file	StaticTaskSystem.h
	@author	Hiroyuki Ogasawara
	@date	2007/09/01
	@brief
*/


#ifndef	__FL_STATICTASKSYSTEM__H__
#define	__FL_STATICTASKSYSTEM__H__

namespace TS
{
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

struct Null_T {
};

template<
		typename TA= Null_T,
		typename TB= Null_T,
		typename TC= Null_T,
		typename TD= Null_T,
		typename TE= Null_T,
		typename TF= Null_T,
		typename TG= Null_T,
		typename TH= Null_T,
		typename TI= Null_T,
		typename TJ= Null_T,
		typename TK= Null_T,
		typename TL= Null_T,
		typename TM= Null_T,
		typename TN= Null_T,
		typename TO= Null_T,
		typename TP= Null_T,
		typename TQ= Null_T,
		typename TR= Null_T,
		typename TS= Null_T,
		typename TT= Null_T,
		typename TU= Null_T,
		typename TV= Null_T,
		typename TW= Null_T,
		typename TX= Null_T,
		typename TY= Null_T,
		typename TZ= Null_T >
struct Array {
	typedef	TA	Head;
	typedef	Array<TB,TC,TD,TE,TF,TG,TH,
					TI,TJ,TK,TL,TM,TN,TO,TP,
					TQ,TR,TS,TT,TU,TV,TW,TX,
					TY,TZ>	Tail;
};

template<>
struct Array<
	Null_T,Null_T,Null_T,Null_T,Null_T,Null_T,Null_T,Null_T,
	Null_T,Null_T,Null_T,Null_T,Null_T,Null_T,Null_T,Null_T,
	Null_T,Null_T,Null_T,Null_T,Null_T,Null_T,Null_T,Null_T,
	Null_T,Null_T>
		{
	typedef	Null_T	Head;
	typedef	Null_T	Tail;
};

template<typename A>
struct Length {
	enum {
		value= Length<A::Tail>::value + 1,
	};
};

template<>
struct Length<Array<> > {
	enum {
		value= 0,
	};
};


template<typename A, typename B, int C= 0>
struct Index {
	enum {
		value= Index<A::Tail,B,C+1>::value,
	};
};

template<typename A, int C>
struct Index<A,typename A::Head,C> {
	enum {
		value= C,
	};
};

template<typename B, int C>
struct Index<Array<>,B,C> {
	enum {
		value= -1,
	};
};


template<typename A, typename B, typename C>
struct Node {
	typedef	A	Head;
	typedef	B	TypeL;
	typedef	C	TypeS;
};

template<typename A, typename B, bool C>
struct HSortRef;

template<typename A, typename B>
struct HSortSub {
private:
	enum {
		value= B::value >= A::Head::value,
	};
	typedef	typename HSortRef<typename A::TypeL,B,value>::result	L1;
	typedef	typename HSortRef<typename A::TypeS,B,!value>::result	S1;
public:
	typedef	Node<typename A::Head,L1,S1>	result;
};

template<typename B>
struct HSortSub<Null_T,B> {
	typedef	Node<B,Null_T,Null_T>	result;
};

template<typename A, typename B, bool C>
struct HSortRef {
	typedef	typename HSortSub<A,B>::result	result;
};

template<typename A, typename B>
struct HSortRef<A,B,false> {
	typedef	A	result;
};

template<typename A, typename B=Null_T>
struct Sort {
	typedef	typename Sort<typename A::Tail, typename
					HSortSub<B,typename A::Head>::result>::result	result;
};
template<typename B>
struct Sort<Array<>,B> {
	typedef	B	result;
};


#define		__TS_FORCEINLINE	__forceinline
template<typename A>
struct ExecTask {
	__TS_FORCEINLINE static void	Exec()
	{
		ExecTask<A::TypeS>::Exec();
		A::Head::Exec();
		ExecTask<A::TypeL>::Exec();
	}
};

template<>
struct ExecTask<Null_T> {
	static void	Exec()
	{
	}
};





//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
}

#endif