/**
 * Tuples and cons pairs are both pretty common template metaprogramming hacks.
 * This set of classes attempts to implement a healthy balance between the two.
 * Tuples generally are implemented with a fixed length; cons pairs have a lot
 * of overhead and require a ton of typing.
 *
 * As with all template metaprograms, it may take a while to compile.
 */

#ifndef QXTUPLE_H

#ifndef QXNULL_DEFINED
#define QXNULL_DEFINED
struct QxNull {
    operator int() const { return 0; }
    enum { isNull = true };

    template<typename T>
    inline bool operator==(const T& p) { return false; }

    inline bool operator==(const QxNull& p) { return true; }
} NW;
#endif

namespace QxType {
struct NoExtend {
    typedef QxNull head;
    enum { length = 0, extends = false };
};

template <typename T1 = QxNull, typename T2 = QxNull, typename T3 = QxNull, typename T4 = QxNull, typename T5 = QxNull,
          typename T6 = QxNull, typename T7 = QxNull, typename T8 = QxNull, typename T9 = QxNull, typename EXTEND = QxType::NoExtend>
struct QxTypeList;

template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename EXTEND>
struct QxTypeList {
    typedef T1 head;
    typedef QxTypeList<T2, T3, T4, T5, T6, T7, T8, T9, NoExtend, EXTEND> tail;
    typedef EXTEND extend;
    enum { length = tail::length + 1, extends = EXTEND::extends };
};

template<typename EXTEND>
struct QxTypeList<NoExtend, NoExtend, NoExtend, NoExtend, NoExtend, NoExtend, NoExtend, NoExtend, NoExtend, EXTEND> {
    typedef typename EXTEND::head head;
    typedef typename EXTEND::tail tail;
    typedef EXTEND extend;
    enum { length = EXTEND::length, extends = EXTEND::extends };
};

template<>
struct QxTypeList<NoExtend, NoExtend, NoExtend, NoExtend, NoExtend, NoExtend, NoExtend, NoExtend, NoExtend, QxType::NoExtend> {
    typedef QxNull extend;
    enum { length = 0, extends = false };
};

template<typename TYPELIST, int INDEX, int STEP=0, bool END=(INDEX==STEP), bool ERROR=(TYPELIST::length==0)>
struct get {
    typedef typename get<typename TYPELIST::tail, INDEX, STEP+1>::type type;
};

template<typename TYPELIST, int INDEX, int STEP>
struct get<TYPELIST, INDEX, STEP, false, true> {}; // does not define type

template<typename TYPELIST, int INDEX, int STEP, bool ERROR>
struct get<TYPELIST, INDEX, STEP, true, ERROR> {
    typedef typename TYPELIST::head type;
};

template<typename TYPELIST, bool LONG=false> class QxTuple;

template<typename TYPELIST, int INDEX, bool LONG, bool EXT=(INDEX>8)> struct QxTupleValue;

template<typename TYPELIST, int INDEX> struct QxTupleValue<TYPELIST, INDEX, true, true> {
    static typename get<TYPELIST, INDEX>::type value(QxTuple<TYPELIST,true>* t) {
        return QxTupleValue<typename TYPELIST::extend, INDEX-9, TYPELIST::extend::extends>::value(&t->extend);
    }
    static void setValue(QxTuple<TYPELIST,true>* t, typename get<TYPELIST, INDEX>::type val) {
        QxTupleValue<typename TYPELIST::extend, INDEX-9, TYPELIST::extend::extends>::setValue(&t->extend, val);
    }
};

template<typename TYPELIST, bool LONG> struct QxTupleValue<TYPELIST, 0, LONG, false> {
    static typename get<TYPELIST, 0>::type value(QxTuple<TYPELIST,LONG>* t) { return t->t1; }
    static void setValue(QxTuple<TYPELIST,LONG>* t, typename get<TYPELIST, 0>::type val) { t->t1 = val; }
};

template<typename TYPELIST, bool LONG> struct QxTupleValue<TYPELIST, 1, LONG, false> {
    static typename get<TYPELIST, 1>::type value(QxTuple<TYPELIST,LONG>* t) { return t->t2; }
    static void setValue(QxTuple<TYPELIST,LONG>* t, typename get<TYPELIST, 1>::type val) { t->t2 = val; }
};

template<typename TYPELIST, bool LONG> struct QxTupleValue<TYPELIST, 2, LONG, false> {
    static typename get<TYPELIST, 2>::type value(QxTuple<TYPELIST,LONG>* t) { return t->t3; }
    static void setValue(QxTuple<TYPELIST,LONG>* t, typename get<TYPELIST, 2>::type val) { t->t3 = val; }
};

template<typename TYPELIST, bool LONG> struct QxTupleValue<TYPELIST, 3, LONG, false> {
    static typename get<TYPELIST, 3>::type value(QxTuple<TYPELIST,LONG>* t) { return t->t4; }
    static void setValue(QxTuple<TYPELIST,LONG>* t, typename get<TYPELIST, 3>::type val) { t->t4 = val; }
};

template<typename TYPELIST, bool LONG> struct QxTupleValue<TYPELIST, 4, LONG, false> {
    static typename get<TYPELIST, 4>::type value(QxTuple<TYPELIST,LONG>* t) { return t->t5; }
    static void setValue(QxTuple<TYPELIST,LONG>* t, typename get<TYPELIST, 4>::type val) { t->t5 = val; }
};

template<typename TYPELIST, bool LONG> struct QxTupleValue<TYPELIST, 5, LONG, false> {
    static typename get<TYPELIST, 5>::type value(QxTuple<TYPELIST,LONG>* t) { return t->t6; }
    static void setValue(QxTuple<TYPELIST,LONG>* t, typename get<TYPELIST, 5>::type val) { t->t6 = val; }
};

template<typename TYPELIST, bool LONG> struct QxTupleValue<TYPELIST, 6, LONG, false> {
    static typename get<TYPELIST, 6>::type value(QxTuple<TYPELIST,LONG>* t) { return t->t7; }
    static void setValue(QxTuple<TYPELIST,LONG>* t, typename get<TYPELIST, 6>::type val) { t->t7 = val; }
};

template<typename TYPELIST, bool LONG> struct QxTupleValue<TYPELIST, 7, LONG, false> {
    static typename get<TYPELIST, 7>::type value(QxTuple<TYPELIST,LONG>* t) { return t->t8; }
    static void setValue(QxTuple<TYPELIST,LONG>* t, typename get<TYPELIST, 7>::type val) { t->t8 = val; }
};

template<typename TYPELIST, bool LONG> struct QxTupleValue<TYPELIST, 8, LONG, false> {
    static typename get<TYPELIST, 8>::type value(QxTuple<TYPELIST,LONG>* t) { return t->t9; }
    static void setValue(QxTuple<TYPELIST,LONG>* t, typename get<TYPELIST, 8>::type val) { t->t9 = val; }
};

template<typename TYPELIST>
class QxTuple<TYPELIST,false> {
public:
    template<int INDEX> typename get<TYPELIST, INDEX>::type value() { return QxTupleValue<TYPELIST, INDEX, false>::value(this); }
    template<int INDEX> void setValue(typename get<TYPELIST, INDEX>::type val) { QxTupleValue<TYPELIST, INDEX, false>::setValue(this, val); }
        
// if only we could get away with making these protected
    typename get<TYPELIST, 0>::type t1;
    typename get<TYPELIST, 1>::type t2;
    typename get<TYPELIST, 2>::type t3;
    typename get<TYPELIST, 3>::type t4;
    typename get<TYPELIST, 4>::type t5;
    typename get<TYPELIST, 5>::type t6;
    typename get<TYPELIST, 6>::type t7;
    typename get<TYPELIST, 7>::type t8;
    typename get<TYPELIST, 8>::type t9;
};

template<typename TYPELIST>
class QxTuple<TYPELIST,true> {
public:
    template<int INDEX> typename get<TYPELIST, INDEX>::type value() { return QxTupleValue<TYPELIST, INDEX, true>::value(this); }
    template<int INDEX> void setValue(typename get<TYPELIST, INDEX>::type val) { QxTupleValue<TYPELIST, INDEX, true>::setValue(this, val); }

// if only we could get away with making these protected
    typename get<TYPELIST, 0>::type t1;
    typename get<TYPELIST, 1>::type t2;
    typename get<TYPELIST, 2>::type t3;
    typename get<TYPELIST, 3>::type t4;
    typename get<TYPELIST, 4>::type t5;
    typename get<TYPELIST, 5>::type t6;
    typename get<TYPELIST, 6>::type t7;
    typename get<TYPELIST, 7>::type t8;
    typename get<TYPELIST, 8>::type t9;
    QxTuple<typename TYPELIST::extend> extend;
};

}

#ifndef QX_NO_USING
using QxType::QxTypeList;
using QxType::QxTuple;
#endif

#ifndef QX_NO_MACROS
#define Qx1Tuple(a) QxTuple<QxTypeList<a > >
#define QxPair(a, b) QxTuple<QxTypeList<a, b > >
#define QxTriple(a, b, c) QxTuple<QxTypeList<a, b, c > >
#define Qx4Tuple(a, b, c, d) QxTuple<QxTypeList<a, b, c, d > >
#define Qx5Tuple(a, b, c, d, e) QxTuple<QxTypeList<a, b, c, d, e > >
#define Qx6Tuple(a, b, c, d, e, f) QxTuple<QxTypeList<a, b, c, d, e, f > >
#define Qx7Tuple(a, b, c, d, e, f, g) QxTuple<QxTypeList<a, b, c, d, e, f, g > >
#define Qx8Tuple(a, b, c, d, e, f, g, h) QxTuple<QxTypeList<a, b, c, d, e, f, g, h > >
#define Qx9Tuple(a, b, c, d, e, f, g, h, i) QxTuple<QxTypeList<a, b, c, d, e, f, g, h, i > >
#define QxLongTuple(a, b, c, d, e, f, g, h, i, j) QxTuple<QxTypeList<a, b, c, d, e, f, g, h, i, j >, true >
#endif

#endif