typelist.h

Ｃ＋＋程序设计新思维中提到的TypeList 实现品

        template <class T, class Tail>
        struct EraseAll<TypeList<T, Tail>, T>
        {
            // Go all the way down the list removing the type
            typedef typename EraseAll<Tail, T>::Result Result;
        };
        template <class Head, class Tail, class T>
        struct EraseAll<TypeList<Head, Tail>, T>
        {
            // Go all the way down the list removing the type
            typedef TypeList<Head, 
                    typename EraseAll<Tail, T>::Result>
                Result;
        };

//------------------------------------------------------------------------------
// class template NoDuplicates
// Removes all duplicate types in a typelist
// Invocation (TList is a typelist):
// NoDuplicates<TList, T>::Result
//------------------------------------------------------------------------------

        template <class TList> struct NoDuplicates;
        
        template <> struct NoDuplicates<NullType>
        {
            typedef NullType Result;
        };

        template <class Head, class Tail>
        struct NoDuplicates< TypeList<Head, Tail> >
        {
        private:
            typedef typename NoDuplicates<Tail>::Result L1;
            typedef typename Erase<L1, Head>::Result L2;
        public:
            typedef TypeList<Head, L2> Result;
        };

//------------------------------------------------------------------------------
// class template Replace
// Replaces the first occurence of a type in a typelist, with another type
// Invocation (TList is a typelist, T, U are types):
// Replace<TList, T, U>::Result
// returns a typelist in which the first occurence of T is replaced with U
//------------------------------------------------------------------------------

        template <class TList, class T, class U> struct Replace;
        
        template <class T, class U>
        struct Replace<NullType, T, U>
        {
            typedef NullType Result;
        };

        template <class T, class Tail, class U>
        struct Replace<TypeList<T, Tail>, T, U>
        {
            typedef TypeList<U, Tail> Result;
        };

        template <class Head, class Tail, class T, class U>
        struct Replace<TypeList<Head, Tail>, T, U>
        {
            typedef TypeList<Head,
                    typename Replace<Tail, T, U>::Result>
                Result;
        };

//------------------------------------------------------------------------------
// class template ReplaceAll
// Replaces all occurences of a type in a typelist, with another type
// Invocation (TList is a typelist, T, U are types):
// Replace<TList, T, U>::Result
// returns a typelist in which all occurences of T is replaced with U
//------------------------------------------------------------------------------

        template <class TList, class T, class U> struct ReplaceAll;
        
        template <class T, class U>
        struct ReplaceAll<NullType, T, U>
        {
            typedef NullType Result;
        };
        
        template <class T, class Tail, class U>
        struct ReplaceAll<TypeList<T, Tail>, T, U>
        {
            typedef TypeList<U, typename ReplaceAll<Tail, T, U>::Result> Result;
        };
        
        template <class Head, class Tail, class T, class U>
        struct ReplaceAll<TypeList<Head, Tail>, T, U>
        {
            typedef TypeList<Head,
                    typename ReplaceAll<Tail, T, U>::Result>
                Result;
        };

//------------------------------------------------------------------------------
// class template Reverse
// Reverses a typelist
// Invocation (TList is a typelist):
// Reverse<TList>::Result
// returns a typelist that is TList reversed
//------------------------------------------------------------------------------
        template <class TList> struct Reverse;
        
        template <class T>
        struct Reverse<TypeList<T,NullType> >
        {
            typedef TypeList<T,NullType> Result;
        };
        
        template <class Head, class Tail>
        struct Reverse< TypeList<Head, Tail> >
        {
            typedef typename Append<
                typename Reverse<Tail>::Result, Head>::Result Result;
        };

		template<class TList,class T>
		struct PushFront{
			typedef typename Reverse<TList>::Result	  rtypes;
			typedef typename Append<rtypes,T>::Result atypes;
			typedef typename Reverse<atypes>::Result  Result;
		};
		template<class T>
		struct PushFront<NullType,T>{
			typedef TypeList<T,NullType>  Result;
		};

//------------------------------------------------------------------------------
// class template RemovePointer
// Remove pointer of all element of a typelist
// Invocation (TList is a typelist):
// RemovePointer<TList>::Result
// returns a typelist that is TList no pointer
//------------------------------------------------------------------------------
		namespace priv{
			template<class T>
			struct RemovePointerHelper{
				typedef T type;
			};
			template<class T>
			struct RemovePointerHelper<T*>{
				typedef T type;
			};
		}


		template <class TList> struct RemovePointer;

        template <>
        struct RemovePointer<NullType>
        {
            typedef NullType Result;
        };
        template <class Head, class Tail>
        struct RemovePointer<TypeList<Head, Tail> >
        {
			typedef TypeList<typename priv::RemovePointerHelper<Head>::type,
                    typename RemovePointer<Tail>::Result>
                Result;
        };

//------------------------------------------------------------------------------
// class template MostDerived
// Finds the type in a typelist that is the most derived from a given type
// Invocation (TList is a typelist, T is a type):
// Replace<TList, T>::Result
// returns the type in TList that's the most derived from T
//------------------------------------------------------------------------------

        //template <class TList, class T> struct MostDerived;
        //
        //template <class T>
        //struct MostDerived<NullType, T>
        //{
        //    typedef T Result;
        //};
        //
        //template <class Head, class Tail, class T>
        //struct MostDerived<TypeList<Head, Tail>, T>
        //{
        //private:
        //    typedef typename MostDerived<Tail, T>::Result Candidate;
        //public:
        //    typedef typename Select<
        //        SUPERSUBCLASS(Candidate, Head),
        //            Head, Candidate>::Result Result;
        //};

//------------------------------------------------------------------------------
// class template DerivedToFront
// Arranges the types in a typelist so that the most derived types appear first
// Invocation (TList is a typelist):
// DerivedToFront<TList>::Result
// returns the reordered TList 
//------------------------------------------------------------------------------

        //template <class TList> struct DerivedToFront;
        //
        //template <>
        //struct DerivedToFront<NullType>
        //{
        //    typedef NullType Result;
        //};
        //
        //template <class Head, class Tail>
        //struct DerivedToFront< TypeList<Head, Tail> >
        //{
        //private:
        //    typedef typename MostDerived<Tail, Head>::Result
        //        TheMostDerived;
        //    typedef typename Replace<Tail, 
        //        TheMostDerived, Head>::Result L;
        //public:
        //    typedef TypeList<TheMostDerived, L> Result;
        //};
        
    }   // namespace TL
}
#endif //__DNC_TYPELIST_H__