tuple.h

Go to the documentation of this file.

#ifndef TAG_TUPLE_H
#define TAG_TUPLE_H

namespace tag
{
    //
    // Typesafe, varadic arguments are provided by a typelist
    //

    template<class C, class D> class T_list;

    #ifndef  DOXYGEN_IGNORE_INTERNAL
    namespace Internal
    {
        struct null{};
        
        static null nv;

        //Index the list, retrieving the value and the type
        //with a good optimizer, this should be constant time at run-time.
        template<class C, class D, int i> struct index_l
        {
            typedef typename index_l<typename D::val_type, typename D::next_type, i-1>::val_type val_type;  

            static const val_type& value(const T_list<C,D>& l)
            {   
                return index_l<typename D::val_type, typename D::next_type, i-1>::value(l.next);
            }
        };

        template<class C, class D> struct index_l<C,D,0>
        {
            typedef C val_type;
            static const val_type& value(const T_list<C,D>& l)
            {
                return l.val;
            }
        };

        //Compute the length of a list
        template<class C, class D> struct length
        {
            enum
            {
                len = length<typename D::val_type, typename D::next_type>::len + 1
            };
        };

        template<> struct length<null, null>
        {
            enum
            {
                len = 0
            };
        };
    

        template<class C, class D, int i> struct T_index_forward
        {
            enum
            {
                len = length<C,D>::len
            };

            typedef typename index_l<C,D,len-i-1>::val_type val_type;

            static const val_type& value(const T_list<C,D>& l)
            {   
                return index_l<C, D, len-i-1>::value(l);
            }
        };
    }
    #endif


    template<class C, class D> struct T_list
    {
        const C& val;
        typedef C val_type;

        const D& next;
        typedef D next_type;
        
        
        T_list(const C& c, const D& d)
        :val(c),next(d){}

        template<class X> T_list<X, T_list<C, D> > operator,(const X& c) const
        {
             return T_list<X, T_list<C, D> >(c, *this);
        }

        template<int i> const typename Internal::T_index_forward<C,D,i>::val_type& index() const
        {
            return Internal::T_index_forward<C,D,i>::value(*this);
        }

        template<int i> class index_type
        {   
            typedef typename Internal::T_index_forward<C,D,i>::val_type type;
        };

        enum
        {
            elements = (Internal::length<C,D>::len)
        };
        
    };
    

    template<class C, class D> struct V_list
    {
        #ifndef DOXYGEN_IGNORE_INTERNAL
        C val;
        typedef C val_type;

        D next;
        typedef D next_type;
        
        
        V_list(const C& c, const D& d)
        :val(c),next(d){}

        template<class X> V_list<X, V_list<C, D> > operator,(const X& c) 
        {
             return V_list<X, V_list<C, D> >(c, *this);
        }
        #endif
    };


    #ifndef DOXYGEN_IGNORE_INTERNAL
    //This class converts a typelist in to an equivalent V_list
    //This allows R_list to figure out the T_list it should allow
    //assignment from.
    namespace Internal
    {
        template<class X, class Y> struct r2v
        {
            typedef V_list<X, typename r2v<typename Y::val_type, typename Y::next_type>::v> v;
        };

        template<> struct r2v<Internal::null, Internal::null>
        {
            typedef V_list<null, null> v;
        };
    }
    #endif

    #ifndef DOXYGEN_IGNORE_INTERNAL
    template<class C, class D> struct R_list
    {
        private:
            typedef typename Internal::r2v<C,D>::v equivalent_V_list;
            R_list(const R_list& );
            void operator=(const R_list&);


        public:
            C& val;
            typedef C val_type;

            D& next;
            typedef D next_type;
            
            R_list(C& c, D& d)
            :val(c),next(d){}

            template<class X> R_list<X, R_list<C, D> > operator,(X& c) 
            {
                 return R_list<X, R_list<C, D> >(c, *this);
            }

                
            template<class X, class Y> friend class R_list;
            void operator=(const equivalent_V_list& vlist)
            {
                val = vlist.val;
                next = vlist.next;
            }
    };
    #endif
    
    #ifndef DOXYGEN_IGNORE_INTERNAL
    typedef R_list<Internal::null,Internal::null> R_ListEnd;
    typedef V_list<Internal::null,Internal::null> V_ListEnd;


    static  R_ListEnd R_TupleHead(Internal::nv, Internal::nv);
    static  V_ListEnd V_TupleHead(Internal::nv, Internal::nv);
    template<class A, class B, class C=Internal::null, class D=Internal::null, class E=Internal::null, class F=Internal::null, class G=Internal::null, class H=Internal::null, class I=Internal::null, class J=Internal::null> struct V_tuple
    {
        typedef V_list<J,V_list<I, V_list<H, V_list<G, V_list<F, V_list<E, V_list<D, V_list<C, V_list<B, V_list<A, V_ListEnd> > > > > > > > > > type;
    };

    template<class A, class B, class C, class D, class E, class F, class G, class H, class I> struct V_tuple<A,B,C,D,E,F,G,H,I,Internal::null>
    {
        typedef V_list<I, V_list<H, V_list<G, V_list<F, V_list<E, V_list<D, V_list<C, V_list<B, V_list<A, V_ListEnd> > > > > > > > > type;
    };

    template<class A, class B, class C, class D, class E, class F, class G, class H> struct V_tuple<A,B,C,D,E,F,G,H,Internal::null,Internal::null>
    {
        typedef V_list<H, V_list<G, V_list<F, V_list<E, V_list<D, V_list<C, V_list<B, V_list<A, V_ListEnd> > > > > > > > type;
    };

    template<class A, class B, class C, class D, class E, class F, class G> struct V_tuple<A,B,C,D,E,F,G,Internal::null,Internal::null,Internal::null>
    {
        typedef V_list<G, V_list<F, V_list<E, V_list<D, V_list<C, V_list<B, V_list<A, V_ListEnd> > > > > > > type;
    };

    template<class A, class B, class C, class D, class E, class F> struct V_tuple<A,B,C,D,E,F,Internal::null,Internal::null,Internal::null,Internal::null>
    {
        typedef V_list<F, V_list<E, V_list<D, V_list<C, V_list<B, V_list<A, V_ListEnd> > > > > > type;
    };

    template<class A, class B, class C, class D, class E> struct V_tuple<A,B,C,D,E,Internal::null,Internal::null,Internal::null,Internal::null,Internal::null>
    {
        typedef V_list<E, V_list<D, V_list<C, V_list<B, V_list<A, V_ListEnd> > > > > type;
    };

    template<class A, class B, class C, class D> struct V_tuple<A,B,C,D,Internal::null,Internal::null,Internal::null,Internal::null,Internal::null,Internal::null>
    {
        typedef V_list<D, V_list<C, V_list<B, V_list<A, V_ListEnd> > > > type;
    };

    template<class A, class B, class C> struct V_tuple<A,B,C,Internal::null,Internal::null,Internal::null,Internal::null,Internal::null,Internal::null,Internal::null>
    {
        typedef V_list<C, V_list<B, V_list<A, V_ListEnd> > > type;
    };

    template<class A, class B> struct V_tuple<A,B,Internal::null,Internal::null,Internal::null,Internal::null,Internal::null,Internal::null,Internal::null>
    {
        typedef V_list<B, V_list<A, V_ListEnd> > type;
    };
    #else
    template<class A, class B, class C, ...> struct V_tuple
    {
        typedef V_list<..., V_list<C, V_list<B, V_list<A, V_ListEnd> > > > type;
    };
    #endif





    typedef T_list<Internal::null,Internal::null> T_ListEnd;
    static const T_ListEnd TupleHead=T_ListEnd(Internal::null(), Internal::null());
}

#define make_tuple(...) ((tag::TupleHead, ## __VA_ARGS__))


#define make_vtuple(...) ((tag::V_TupleHead, ## __VA_ARGS__))

#define make_rtuple(...) ((tag::R_TupleHead, ## __VA_ARGS__))


#endif

---