/*
    Copyright 2005-2012 Intel Corporation.  All Rights Reserved.

    This file is part of Threading Building Blocks.

    Threading Building Blocks is free software; you can redistribute it
    and/or modify it under the terms of the GNU General Public License
    version 2 as published by the Free Software Foundation.

    Threading Building Blocks is distributed in the hope that it will be
    useful, but WITHOUT ANY WARRANTY; without even the implied warranty
    of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Threading Building Blocks; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    As a special exception, you may use this file as part of a free software
    library without restriction.  Specifically, if other files instantiate
    templates or use macros or inline functions from this file, or you compile
    this file and link it with other files to produce an executable, this
    file does not by itself cause the resulting executable to be covered by
    the GNU General Public License.  This exception does not however
    invalidate any other reasons why the executable file might be covered by
    the GNU General Public License.
*/

#ifndef __TBB_tuple_H
#define __TBB_tuple_H

#if !TBB_PREVIEW_TUPLE
#error Set TBB_PREVIEW_TUPLE to include compat/tuple
#endif

#include <utility>
#include "../tbb_stddef.h"

// build preprocessor variables for varying number of arguments
// Need the leading comma so the empty __TBB_T_PACK will not cause a syntax error.
#if __TBB_VARIADIC_MAX <= 5
#define __TBB_T_PACK
#define __TBB_U_PACK
#define __TBB_CLASS_T_PACK
#define __TBB_CLASS_U_PACK
#define __TBB_NULL_TYPE_PACK
#define __TBB_REF_T_PARAM_PACK
#define __TBB_CONST_REF_T_PARAM_PACK
#define __TBB_T_PARAM_LIST_PACK
#define __TBB_CONST_NULL_REF_PACK
//
#elif __TBB_VARIADIC_MAX == 6
#define __TBB_T_PACK ,T5
#define __TBB_U_PACK ,U5
#define __TBB_CLASS_T_PACK , class T5
#define __TBB_CLASS_U_PACK , class U5
#define __TBB_NULL_TYPE_PACK , null_type
#define __TBB_REF_T_PARAM_PACK ,T5& t5
#define __TBB_CONST_REF_T_PARAM_PACK ,const T5& t5
#define __TBB_T_PARAM_LIST_PACK ,t5
#define __TBB_CONST_NULL_REF_PACK , const null_type&
//
#elif __TBB_VARIADIC_MAX == 7
#define __TBB_T_PACK ,T5, T6
#define __TBB_U_PACK ,U5, U6
#define __TBB_CLASS_T_PACK , class T5 , class T6
#define __TBB_CLASS_U_PACK , class U5 , class U6
#define __TBB_NULL_TYPE_PACK , null_type, null_type
#define __TBB_REF_T_PARAM_PACK ,T5& t5, T6& t6
#define __TBB_CONST_REF_T_PARAM_PACK ,const T5& t5, const T6& t6
#define __TBB_T_PARAM_LIST_PACK ,t5 ,t6
#define __TBB_CONST_NULL_REF_PACK , const null_type&, const null_type&
//
#elif __TBB_VARIADIC_MAX == 8
#define __TBB_T_PACK ,T5, T6, T7
#define __TBB_U_PACK ,U5, U6, U7
#define __TBB_CLASS_T_PACK , class T5 , class T6, class T7
#define __TBB_CLASS_U_PACK , class U5 , class U6, class U7
#define __TBB_NULL_TYPE_PACK , null_type, null_type, null_type
#define __TBB_REF_T_PARAM_PACK ,T5& t5, T6& t6, T7& t7
#define __TBB_CONST_REF_T_PARAM_PACK , const T5& t5, const T6& t6, const T7& t7
#define __TBB_T_PARAM_LIST_PACK ,t5 ,t6 ,t7
#define __TBB_CONST_NULL_REF_PACK , const null_type&, const null_type&, const null_type&
//
#elif __TBB_VARIADIC_MAX == 9
#define __TBB_T_PACK ,T5, T6, T7, T8
#define __TBB_U_PACK ,U5, U6, U7, U8
#define __TBB_CLASS_T_PACK , class T5, class T6, class T7, class T8
#define __TBB_CLASS_U_PACK , class U5, class U6, class U7, class U8
#define __TBB_NULL_TYPE_PACK , null_type, null_type, null_type, null_type
#define __TBB_REF_T_PARAM_PACK ,T5& t5, T6& t6, T7& t7, T8& t8
#define __TBB_CONST_REF_T_PARAM_PACK , const T5& t5, const T6& t6, const T7& t7, const T8& t8
#define __TBB_T_PARAM_LIST_PACK ,t5 ,t6 ,t7 ,t8
#define __TBB_CONST_NULL_REF_PACK , const null_type&, const null_type&, const null_type&, const null_type&
//
#elif __TBB_VARIADIC_MAX >= 10
#define __TBB_T_PACK ,T5, T6, T7, T8, T9
#define __TBB_U_PACK ,U5, U6, U7, U8, U9
#define __TBB_CLASS_T_PACK , class T5, class T6, class T7, class T8, class T9
#define __TBB_CLASS_U_PACK , class U5, class U6, class U7, class U8, class U9
#define __TBB_NULL_TYPE_PACK , null_type, null_type, null_type, null_type, null_type
#define __TBB_REF_T_PARAM_PACK ,T5& t5, T6& t6, T7& t7, T8& t8, T9& t9
#define __TBB_CONST_REF_T_PARAM_PACK , const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9
#define __TBB_T_PARAM_LIST_PACK ,t5 ,t6 ,t7 ,t8 ,t9
#define __TBB_CONST_NULL_REF_PACK , const null_type&, const null_type&, const null_type&, const null_type&, const null_type&
#endif



namespace tbb {
namespace interface5 {
namespace internal {
struct null_type { };
}
using internal::null_type;

// tuple forward declaration
template <class T0=null_type, class T1=null_type, class T2=null_type, class T3=null_type, class T4=null_type
#if __TBB_VARIADIC_MAX >= 6
, class T5=null_type
#if __TBB_VARIADIC_MAX >= 7
, class T6=null_type
#if __TBB_VARIADIC_MAX >= 8
, class T7=null_type
#if __TBB_VARIADIC_MAX >= 9
, class T8=null_type
#if __TBB_VARIADIC_MAX >= 10
, class T9=null_type
#endif
#endif
#endif
#endif
#endif
>
class tuple;

namespace internal {

// const null_type temp
inline const null_type cnull() { return null_type(); }

// cons forward declaration
template <class HT, class TT> struct cons;

// type of a component of the cons
template<int N, class T>
struct component {
    typedef typename T::tail_type next;
    typedef typename component<N-1,next>::type type;
};

template<class T>
struct component<0,T> {
    typedef typename T::head_type type;
};

template<>
struct component<0,null_type> {
    typedef null_type type;
};

// const version of component

template<int N, class T>
struct component<N, const T>
{
    typedef typename T::tail_type next;
    typedef const typename component<N-1,next>::type type;
};

template<class T>
struct component<0, const T>
{
    typedef const typename T::head_type type;
};


// helper class for getting components of cons
template< int N>
struct get_helper {
template<class HT, class TT>
inline static typename component<N, cons<HT,TT> >::type& get(cons<HT,TT>& ti) {
    return get_helper<N-1>::get(ti.tail);
}
template<class HT, class TT>
inline static typename component<N, cons<HT,TT> >::type const& get(const cons<HT,TT>& ti) {
    return get_helper<N-1>::get(ti.tail);
}
};

template<>
struct get_helper<0> {
template<class HT, class TT>
inline static typename component<0, cons<HT,TT> >::type& get(cons<HT,TT>& ti) {
    return ti.head;
}
template<class HT, class TT>
inline static typename component<0, cons<HT,TT> >::type const& get(const cons<HT,TT>& ti) {
    return ti.head;
}
};

// traits adaptor
template <class T0, class T1, class T2, class T3, class T4 __TBB_CLASS_T_PACK>
struct tuple_traits {
    typedef cons <T0, typename tuple_traits<T1, T2, T3, T4 __TBB_T_PACK , null_type>::U > U;
};

template <>
struct tuple_traits<class T0, null_type, null_type, null_type, null_type __TBB_NULL_TYPE_PACK > {
    typedef cons<T0, null_type> U;
};

template<>
struct tuple_traits<null_type, null_type, null_type, null_type, null_type __TBB_NULL_TYPE_PACK > {
    typedef null_type U;
};


// core cons defs
template <class HT, class TT>
struct cons{

    typedef HT head_type;
    typedef TT tail_type;

    HT head; 
    TT tail;

    static const int length = 1 + tail_type::length;

    // default constructors
    explicit cons() : head(), tail() { }

    // non-default constructors
    cons(head_type& h, const tail_type& t) : head(h), tail(t) { }

    template <class T0, class T1, class T2, class T3, class T4 __TBB_CLASS_T_PACK >
    cons(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4 __TBB_CONST_REF_T_PARAM_PACK) :
        head(t0), tail(t1, t2, t3, t4 __TBB_T_PARAM_LIST_PACK, cnull()) { }

    template <class T0, class T1, class T2, class T3, class T4 __TBB_CLASS_T_PACK >
    cons(T0& t0, T1& t1, T2& t2, T3& t3, T4& t4 __TBB_REF_T_PARAM_PACK) :
        head(t0), tail(t1, t2, t3, t4 __TBB_T_PARAM_LIST_PACK , cnull()) { }

    template <class HT1, class TT1>
    cons(const cons<HT1,TT1>& other) : head(other.head), tail(other.tail) { }

    cons& operator=(const cons& other) { head = other.head; tail = other.tail; return *this; }

    friend bool operator==(const cons& me, const cons& other) {
        return me.head == other.head && me.tail == other.tail;
    }
    friend bool operator<(const cons& me, const cons& other)  {
        return me.head < other.head || (!(other.head < me.head) && me.tail < other.tail);
    }
    friend bool operator>(const cons& me, const cons& other)  { return other<me; }
    friend bool operator!=(const cons& me, const cons& other) { return !(me==other); }
    friend bool operator>=(const cons& me, const cons& other) { return !(me<other); }
    friend bool operator<=(const cons& me, const cons& other) { return !(me>other); }

    template<class HT1, class TT1>
    friend bool operator==(const cons<HT,TT>& me, const cons<HT1,TT1>& other) {
        return me.head == other.head && me.tail == other.tail;
    }

    template<class HT1, class TT1>
    friend bool operator<(const cons<HT,TT>& me, const cons<HT1,TT1>& other) {
        return me.head < other.head || (!(other.head < me.head) && me.tail < other.tail);
    }

    template<class HT1, class TT1>
    friend bool operator>(const cons<HT,TT>& me, const cons<HT1,TT1>& other) { return other<me; }

    template<class HT1, class TT1>
    friend bool operator!=(const cons<HT,TT>& me, const cons<HT1,TT1>& other) { return !(me==other); }

    template<class HT1, class TT1>
    friend bool operator>=(const cons<HT,TT>& me, const cons<HT1,TT1>& other) { return !(me<other); }

    template<class HT1, class TT1>
    friend bool operator<=(const cons<HT,TT>& me, const cons<HT1,TT1>& other) { return !(me>other); }


};  // cons


template <class HT>
struct cons<HT,null_type> { 

    typedef HT head_type;
    typedef null_type tail_type;
    static const int length = 1;
    head_type head; 

    // default constructor
    cons() : head() { /*std::cout << "default constructor 1\n";*/ }

    cons(const null_type&, const null_type&, const null_type&, const null_type&, const null_type& __TBB_CONST_NULL_REF_PACK) : head() { /*std::cout << "default constructor 2\n";*/ }

    // non-default constructor
    template<class T1>
    cons(T1& t1, const null_type&, const null_type&, const null_type&, const null_type& __TBB_CONST_NULL_REF_PACK) : head(t1) { /*std::cout << "non-default a1, t1== " << t1 << "\n";*/}

    cons(head_type& h, const null_type& = null_type() ) : head(h) { }
    cons(const head_type& t0, const null_type&, const null_type&, const null_type&, const null_type& __TBB_CONST_NULL_REF_PACK) : head(t0) { }

    // converting constructor
    template<class HT1>
    cons(HT1 h1, const null_type&, const null_type&, const null_type&, const null_type& __TBB_CONST_NULL_REF_PACK) : head(h1) { }

    // copy constructor
    template<class HT1>
    cons( const cons<HT1, null_type>& other) : head(other.head) { }

    // assignment operator
    cons& operator=(const cons& other) { head = other.head; return *this; }

    friend bool operator==(const cons& me, const cons& other) { return me.head == other.head; }
    friend bool operator<(const cons& me, const cons& other) { return me.head < other.head; }
    friend bool operator>(const cons& me, const cons& other) { return other<me; }
    friend bool operator!=(const cons& me, const cons& other) {return !(me==other); }
    friend bool operator<=(const cons& me, const cons& other) {return !(me>other); }
    friend bool operator>=(const cons& me, const cons& other) {return !(me<other); }

    template<class HT1>
    friend bool operator==(const cons<HT,null_type>& me, const cons<HT1,null_type>& other) {
        return me.head == other.head;
    }

    template<class HT1>
    friend bool operator<(const cons<HT,null_type>& me, const cons<HT1,null_type>& other) {
        return me.head < other.head;
    }

    template<class HT1>
    friend bool operator>(const cons<HT,null_type>& me, const cons<HT1,null_type>& other) { return other<me; }

    template<class HT1>
    friend bool operator!=(const cons<HT,null_type>& me, const cons<HT1,null_type>& other) { return !(me==other); }

    template<class HT1>
    friend bool operator<=(const cons<HT,null_type>& me, const cons<HT1,null_type>& other) { return !(me>other); }

    template<class HT1>
    friend bool operator>=(const cons<HT,null_type>& me, const cons<HT1,null_type>& other) { return !(me<other); }

};  // cons

template <>
struct cons<null_type,null_type> { typedef null_type tail_type; static const int length = 0; };

// wrapper for default constructor
template<class T>
inline const T wrap_dcons(T*) { return T(); }
} // namespace internal

// tuple definition
template<class T0, class T1, class T2, class T3, class T4 __TBB_CLASS_T_PACK >
class tuple : public internal::tuple_traits<T0, T1, T2, T3, T4 __TBB_T_PACK >::U {
    // friends
    template <class T> friend class tuple_size;
    template<int N, class T> friend struct tuple_element;

    // stl components
    typedef tuple<T0,T1,T2,T3,T4 __TBB_T_PACK > value_type;
    typedef value_type *pointer;
    typedef const value_type *const_pointer;
    typedef value_type &reference;
    typedef const value_type &const_reference;
    typedef size_t size_type;

    typedef typename internal::tuple_traits<T0,T1,T2,T3, T4 __TBB_T_PACK >::U my_cons;
public:

    tuple(const T0& t0=internal::wrap_dcons((T0*)NULL)
          ,const T1& t1=internal::wrap_dcons((T1*)NULL)
          ,const T2& t2=internal::wrap_dcons((T2*)NULL)
          ,const T3& t3=internal::wrap_dcons((T3*)NULL)
          ,const T4& t4=internal::wrap_dcons((T4*)NULL)
#if __TBB_VARIADIC_MAX >= 6
          ,const T5& t5=internal::wrap_dcons((T5*)NULL)
#if __TBB_VARIADIC_MAX >= 7
          ,const T6& t6=internal::wrap_dcons((T6*)NULL)
#if __TBB_VARIADIC_MAX >= 8
          ,const T7& t7=internal::wrap_dcons((T7*)NULL)
#if __TBB_VARIADIC_MAX >= 9
          ,const T8& t8=internal::wrap_dcons((T8*)NULL)
#if __TBB_VARIADIC_MAX >= 10
          ,const T9& t9=internal::wrap_dcons((T9*)NULL)
#endif
#endif
#endif
#endif
#endif
          ) :
        internal::tuple_traits<T0,T1,T2,T3,T4 __TBB_T_PACK >::U(t0,t1,t2,t3,t4 __TBB_T_PARAM_LIST_PACK) { }

    template<int N>
    struct internal_tuple_element {
        typedef typename internal::component<N,my_cons>::type type;
    };

    template<int N>
    typename internal_tuple_element<N>::type& get() { return internal::get_helper<N>::get(*this); }

    template<int N>
    typename internal_tuple_element<N>::type const& get() const { return internal::get_helper<N>::get(*this); }

    template<class U1, class U2>
    tuple& operator=(const internal::cons<U1,U2>& other) {
        my_cons::operator=(other);
        return *this;
    }

    template<class U1, class U2>
    tuple& operator=(const std::pair<U1,U2>& other) {
        // __TBB_ASSERT(tuple_size<value_type>::value == 2, "Invalid size for pair to tuple assignment");
        this->head = other.first;
        this->tail.head = other.second;
        return *this;
    }

    friend bool operator==(const tuple& me, const tuple& other) {return static_cast<const my_cons &>(me)==(other);}
    friend bool operator<(const tuple& me,  const tuple& other) {return static_cast<const my_cons &>(me)<(other);}
    friend bool operator>(const tuple& me,  const tuple& other) {return static_cast<const my_cons &>(me)>(other);}
    friend bool operator!=(const tuple& me, const tuple& other) {return static_cast<const my_cons &>(me)!=(other);}
    friend bool operator>=(const tuple& me, const tuple& other) {return static_cast<const my_cons &>(me)>=(other);}
    friend bool operator<=(const tuple& me, const tuple& other) {return static_cast<const my_cons &>(me)<=(other);}

    template<class U0, class U1, class U2, class U3, class U4 __TBB_CLASS_U_PACK >
    friend bool operator==(const tuple& me, const tuple<U0,U1,U2,U3,U4 __TBB_U_PACK >& other) {
        return static_cast<const my_cons &>(me)==(other);
    }

    template<class U0, class U1, class U2, class U3, class U4 __TBB_CLASS_U_PACK >
    friend bool operator<(const tuple& me, const tuple<U0,U1,U2,U3,U4 __TBB_U_PACK >& other) {
        return static_cast<const my_cons &>(me)<(other);
    }

    template<class U0, class U1, class U2, class U3, class U4 __TBB_CLASS_U_PACK >
    friend bool operator>(const tuple& me, const tuple<U0,U1,U2,U3,U4 __TBB_U_PACK >& other) {
        return static_cast<const my_cons &>(me)>(other);
    }

    template<class U0, class U1, class U2, class U3, class U4 __TBB_CLASS_U_PACK >
    friend bool operator!=(const tuple& me, const tuple<U0,U1,U2,U3,U4 __TBB_U_PACK >& other) {
        return static_cast<const my_cons &>(me)!=(other);
    }

    template<class U0, class U1, class U2, class U3, class U4 __TBB_CLASS_U_PACK >
    friend bool operator>=(const tuple& me, const tuple<U0,U1,U2,U3,U4 __TBB_U_PACK >& other) {
        return static_cast<const my_cons &>(me)>=(other);
    }

    template<class U0, class U1, class U2, class U3, class U4 __TBB_CLASS_U_PACK >
    friend bool operator<=(const tuple& me, const tuple<U0,U1,U2,U3,U4 __TBB_U_PACK >& other) {
        return static_cast<const my_cons &>(me)<=(other);
    }

};  // tuple

// empty tuple
template<>
class tuple<null_type, null_type, null_type, null_type, null_type __TBB_NULL_TYPE_PACK > : public null_type {
    typedef null_type inherited;
};

// helper classes

template < class T>
class tuple_size {
public:
    static const size_t value = 1 + tuple_size<typename T::tail_type>::value;
};

template <>
class tuple_size<tuple<> > { 
public:
    static const size_t value = 0;
};

template <>
class tuple_size<null_type> {
public:
    static const size_t value = 0;
};

template<int N, class T>
struct tuple_element {
    typedef typename internal::component<N, typename T::my_cons>::type type;
};

template<int N, class T0, class T1, class T2, class T3, class T4 __TBB_CLASS_T_PACK >
inline static typename tuple_element<N,tuple<T0,T1,T2,T3,T4 __TBB_T_PACK > >::type&
    get(tuple<T0,T1,T2,T3,T4 __TBB_T_PACK >& t) { return t.get<N>(); }

template<int N, class T0, class T1, class T2, class T3, class T4 __TBB_CLASS_T_PACK >
inline static typename tuple_element<N,tuple<T0,T1,T2,T3,T4 __TBB_T_PACK > >::type const&
    get(const tuple<T0,T1,T2,T3,T4 __TBB_T_PACK >& t) { return t.get<N>(); }

}  // interface5
} // tbb

#if TBB_IMPLEMENT_CPP0X
namespace std {
using tbb::interface5::tuple;
using tbb::interface5::tuple_size;
using tbb::interface5::tuple_element;
using tbb::interface5::get;
}
#endif

#undef __TBB_T_PACK
#undef __TBB_U_PACK
#undef __TBB_CLASS_T_PACK
#undef __TBB_CLASS_U_PACK
#undef __TBB_NULL_TYPE_PACK
#undef __TBB_REF_T_PARAM_PACK
#undef __TBB_CONST_REF_T_PARAM_PACK
#undef __TBB_T_PARAM_LIST_PACK
#undef __TBB_CONST_NULL_REF_PACK
 
#endif /* __TBB_tuple_H */
