typelist.h

来自「C++封装的视频采集代码」· C头文件 代码 · 共 791 行 · 第 1/3 页

// returns a typelist that is TList followed by T and NullType-terminated
////////////////////////////////////////////////////////////////////////////////

        template <class TList, class T>
        struct Append;

        template <class Head, class Tail, class T>
        struct Append<Typelist<Head, Tail>, T>
        {
            typedef Typelist<Head, typename Append<Tail, T>::Result> Result;
        };

        template <class Head, class Tail>
        struct Append<NullType, Typelist<Head, Tail> >
        {
            typedef Typelist<Head, Tail> Result;
        };

        template <class T>
        struct Append<NullType, T>
        {
            typedef TYPELIST_1(T) Result;
        };

        template <>
        struct Append<NullType, NullType>
        {
            typedef NullType Result;
        };

////////////////////////////////////////////////////////////////////////////////
// class template Erase
// Erases the first occurence, if any, of a type in a typelist
// Invocation (TList is a typelist and T is a type):
// Erase<TList, T>::Result
// returns a typelist that is TList without the first occurence of T
////////////////////////////////////////////////////////////////////////////////

        template<class TList, class T>
        struct Erase
        {
            typedef Typelist<typename TList::Head,
                    typename Erase<typename TList::Tail, T>::Result> Result;
        };

        template <class T, class Tail>
        struct Erase<Typelist<T, Tail>, T>
        {
            typedef Tail Result;
        };

        template <class T>
        struct Erase<NullType, T>
        {
            typedef NullType Result;
        };

////////////////////////////////////////////////////////////////////////////////
// class template EraseAll
// Erases all first occurences, if any, of a type in a typelist
// Invocation (TList is a typelist and T is a type):
// EraseAll<TList, T>::Result
// returns a typelist that is TList without any occurence of T
////////////////////////////////////////////////////////////////////////////////

        template<class TList, class T>
        struct EraseAll
        {
            typedef Typelist<typename TList::Head,
                    typename EraseAll<typename TList::Tail, T>::Result> Result;
        };

        template <class T, class Tail>
        struct EraseAll<Typelist<T, Tail>, T>
        {
            typedef typename EraseAll<Tail, T>::Result Result;
        };

        template <class T>
        struct EraseAll<NullType, T>
        {
            typedef NullType 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 <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;
        };

        template <>
        struct NoDuplicates<NullType>
        {
            typedef NullType 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
        {
            typedef Typelist<typename TList::Head,
                    typename Replace<typename TList::Tail, T, U>::Result> Result;
        };

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

        template <class T, class U>
        struct Replace<NullType, T, U>
        {
            typedef NullType 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
        {
            typedef Typelist<typename TList::Head,
                    typename ReplaceAll<typename TList::Tail, T, U>::Result>
                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 T, class U>
        struct ReplaceAll<NullType, T, U>
        {
            typedef NullType 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 Head, class Tail>
        struct Reverse< Typelist<Head, Tail> >
        {
            typedef typename Append<
                typename Reverse<Tail>::Result, Head>::Result Result;
        };

        template <>
        struct Reverse<NullType>
        {
            typedef NullType 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):
// MostDerived<TList, T>::Result
// returns the type in TList that's the most derived from T
////////////////////////////////////////////////////////////////////////////////

        template <class TList, class T>
        struct MostDerived;

        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<
                ::Loki::Conversion<const volatile Head *, const volatile Candidate *>::exists==1 &&
                ::Loki::Conversion<const volatile Candidate *, const volatile void *>::sameType==0,
                Head, Candidate>::Result Result;
        };

        template <class T>
        struct MostDerived<NullType, T>
        {
            typedef T 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 <class Head, class Tail>
        struct DerivedToFront< Typelist<Head, Tail> >
        {
        private:
            typedef typename MostDerived<Tail, Head>::Result TheMostDerived;
            typedef typename Replace<Tail, TheMostDerived, Head>::Result Temp;
            typedef typename DerivedToFront<Temp>::Result L;

        public:
            typedef Typelist<TheMostDerived, L> Result;
        };

        template <>
        struct DerivedToFront<NullType>
        {
            typedef NullType Result;
        };

    }   // namespace TL
}   // namespace Loki

////////////////////////////////////////////////////////////////////////////////
// Change log:
// June     09, 2001: Fix bug in parameter list of macros TYPELIST_23 to TYPELIST_27
//          (credit due to Dave Taylor)
// June     20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
// November 22, 2001: fixed bug in DerivedToFront
//          (credit due to Gianni Luciani who noticed the bug first;
//          Adam Wilkshire;
//          Friedrik Hedman who fixed the bug but didn't send the fix;
//          Kevin Cline who sent the first actual fix)
// July     16, 2002: Ported by Terje Sletteb