Tuple实现源代码

//

// TUPLE COMPLETE CORRECT

//

 

/**************************************************************************

TypeOperator Definition

***************************************************************************/

 

/************************************************************************/

/*

template<class T> class TypeOperator

template<class T> class TypeOperator<T const>

template<class T> class TypeOperator<T&>

template<> class TypeOperator<void>

*/

/************************************************************************/

 

template<class T>

class TypeOperator{

public:

typedef T AgrT;

typedef T BareT;

typedef const T ConstT;

typedef T& RefT;

typedef T& RefBareT;

typedef T const& RefConstT;

};

 

template<class T>

class TypeOperator<T const> {

public:

typedef T const ArgT;

typedef T BareT;

typedef T const ConstT;

typedef T const& RefT;

typedef T& RefBareT;

typedef T const & RefConstT;

};

 

template<class T>

class TypeOperator<T&> {

public:

typedef T& ArgT;

typedef typename TypeOperator<T>::BareT BareT;

typedef T const ConstT;

typedef T& RefT;

typedef typename TypeOperator<T>::BareT& RefBareT;

typedef T const & RefConstT;

};

 

template<>

class TypeOperator<void> {

public:

typedef void ArgT;

typedef void BareT;

typedef void const ConstT;

typedef void RefT;

typedef void RefBareT;

typedef void RefConstT;

};

 

/**************************************************************************

Duo

**************************************************************************/

 

/************************************************************************/

/*

template<class T1, class T2> struct Duo 

template<class A> class Duo<A, void> 

*/

/************************************************************************/

 

//A duo is the assembly of two objects into a single type. This is similar

//to the std::pair class template in the standard library, but because we

//will add slightly different functionality to this very basic utility,

 

template<class T1, class T2>

struct Duo {

typedef T1 Type1; //type of first field

typedef T2 Type2; //type of second field

enum { N = 2 }; //number of fields

 

T1 value1;

T2 value2;

 

//constructor

Duo() : value1(), value2() {

};

 

Duo(const T1& a, const T2& b) : value1(a), value2(b) {

};

 

//copy constructor

template<class U1, class U2>

Duo(Duo<U1, U2> const& d) : value1(d.v1()), value2(d.v2()) {

};

 

template<class U1,class U2>

Duo<T1, T2>& operator=(Duo<U1, U2> const& d) {

value1 = d.value1;

value2 = d.value2;

 

return *this;

};

 

//field access

T1& v1() {

return value1;

};

T2& v2() {

return value2;

};

 

};

 

//comparison operators (allow mixed types):

template<class T1, class T2, class U1, class U2>

inline

bool operator==(Duo<T1, T2> const& d1, Duo<U1, U2> const& d2) {

return d1.v1() == d2.v1() && d1.v2() == d2.v2();

};

 

template<class T1, class T2, class U1, class U2>

inline

bool operator!=(Duo<T1, T2> const& d1, Duo<U1, U2> const& d2) {

return !(d1 == d2);

}

 

 

//To avoid the need for explicit type parameters, we can further add a function

//so that the field types can be deduced

 

template<class T1, class T2>

inline

Duo<T1, T2> make_duo(const T1& a, const T2& b) {

return Duo<T1, T2>(a, b);

}

 

template<class A, class B, class C>

class Duo<A, Duo<B, C> > {

public:

typedef A T1;

typedef Duo<B, C> T2;

enum { N = Duo<B, C>::N + 1 };

 

private:

T1 value1;

T2 value2;

 

public:

//the other public members are unchanged

//constructor

Duo() : value1(), value2() {

};

Duo(const T1& a, const T2& b) : value1(a), value2(b) {

};

 

//copy constructor

template<class D, class E, class F>

Duo(Duo<D, Duo<E, F> > const& d) {

value1 = d.v1();

value2 = d.v2();

};

 

template<class D,class E, class F>

Duo<T1, T2>& operator=(Duo<D, Duo<E, F> > const& d) {

value1 = d.value1;

value2 = d.value2;

 

return *this;

};

 

//field access

T1& v1() {

return value1;

};

T2& v2() {

return value2;

};

 

};

 

//partial specialization for Duo<> with only one field

template<class A>

class Duo<A, void> {

public:

typedef A T1;

typedef void T2;

enum { N = 1 };

 

private:

T1 value1;

 

public:

//constructor

Duo() : value1() {

};

Duo(T1 const& a) : value1(a) {

};

 

//field access

T1& v1() {

return value1;

};

 

/*********************************************************************

a void type can not reach

T2& v2() const {

return value2;

};

**********************************************************************/

 

};

 

/**************************************************************************

DuoT

***************************************************************************/

 

/************************************************************************/

/*

template<int N, class T> class DuoT 

template<class A, class B> class DuoT<1, Duo<A, B> >

template<class A, class B>class DuoT<2, Duo<A, B> >  

template<int N, class A, class B, class C> class DuoT<N, Duo<A, Duo<B, C> > >

template<class A, class B, class C> class DuoT<1, Duo<A, Duo<B, C> > >

template<class A, class B, class C> class DuoT<2, Duo<A, Duo<B, C> > >

*/

/************************************************************************/

 

template<int N, class T>

class DuoT {

public:

typedef void ResultT; //in general, the result type is void

//but it is usually can not be used

//ensures that the result type is void 

//for non-Duos

};

 

//Fairly simple partial specializations take care of retrieving the 

//types from nonrecursive Duos:

//-------------------------------------------------------------------------

template<class A, class B>

class DuoT<1, Duo<A, B> > {

public:

typedef A ResultT;

};

 

template<class A, class B>

class DuoT<2, Duo<A, B> > {

public:

typedef B ResultT;

};

//-------------------------------------------------------------------------

 

//With this in place, the nth type of a recursive duo, in general, is the 

//(n-1)th type of the second field

//-------------------------------------------------------------------------

template<int N, class A, class B, class C>

class DuoT<N, Duo<A, Duo<B, C> > > {

public:

typedef typename DuoT<N - 1, Duo<B, C> >::ResultT ResultT;

};

//-------------------------------------------------------------------------

 

//-------------------------------------------------------------------------

//however, the request for the first type of a recurssion duo ends the recursion

template<class A, class B, class C>

class DuoT<1, Duo<A, Duo<B, C> > > {

public:

typedef A ResultT;

};

 

//note that the case for the second type of recursive duo also needs a partial

//specialization to avooidambiguity with the nonrecursive case

 

template<class A, class B, class C>

class DuoT<2, Duo<A, Duo<B, C> > > {

public:

typedef B ResultT;

};

//-------------------------------------------------------------------------

 

/**************************************************************************

DuoValue

***************************************************************************/

//primary template for value of Nth field of (duo) T

template<int N, class T>

class DuoValue {

public:

static void get(T&) {

 

};

static void get(T const&) {

 

};

};

 

//specialization for 1st field of a plain duo

 

template<class A, class B>

class DuoValue<1, Duo<A, B> > {

public:

static A& get(Duo<A, B>& d) {

return d.v1();

};

 

static A const& get(Duo<A, B> const& d) {

return d.v1();

};

};

 

//specialization for 2nd field of a plain duo

 

template<class A, class B>

class DuoValue<2, Duo<A, B> > {

public:

static B& get(Duo<A, B>& d) {

return d.v2();

};

 

static B const& get(Duo<A, B> const& d) {

return d.v2();

};

};

 

// specialization for Nth field of recursive duo

 

template<int N, class A, class B, class C>

class DuoValue<N, Duo<A, Duo<B, C> > > {

public:

static

typename TypeOperator<typename DuoT<N - 1, Duo <B, C> >::ResultT>::RefT

get(Duo<A, Duo<B, C> >& d) {

return DuoValue<N - 1, Duo<B, C> >::get(d.v2());

};

static

typename TypeOperator<typename DuoT<N - 1, Duo<B, C> >::ResultT>::RefConstT

get(Duo<A, Duo<B, C> > const& d) {

return DuoValue<N - 1, Duo<B, C> >::get(d.v2());

};

};

 

// specialization for 1st field of recursive duo

 

template<class A, class B, class C>

class DuoValue<1, Duo<A, Duo<B, C> > > {

public:

static A& get(Duo<A, Duo<B, C> >& d) {

return d.v1();

};

static A const& get(Duo<A, Duo<B, C> > const& d) {

return d.v1();

};

};

 

// specialization for 2nd field of recursive duo

 

template<class A, class B, class C>

class DuoValue<2, Duo<A, Duo<B, C> > > {

public:

static B& get(Duo<A, Duo<B, C> >& d) {

return d.v2().v1();

};

static B const& get(Duo<A, Duo<B, C> > const& d) {

return d.v2().v1();

};

};

 

/*************************************************************************

Val

***************************************************************************/

template<int N, class A, class B>

inline

typename TypeOperator<typename DuoT<N, Duo<A, B> >::ResultT >::RefT

val(Duo<A, B>& d) {

return DuoValue<N, Duo<A, B> >::get(d);

}

 

template<int N, class A, class B>

inline

typename TypeOperator<typename DuoT<N, Duo<A, B> >::ResultT >::RefConstT

val(Duo<A, B> const& d) {

return DuoValue<N, Duo<A, B> >::get(d);

}

 

/***************************************************************************

Tuple

****************************************************************************/

 

//type that represents unused type parameters

class NullT {

};

 

//Tuple<> in general derives from Tuple<> with one more NullT

template<

class P1,

class P2 = NullT,

class P3 = NullT,

class P4 = NullT,

class P5 = NullT

>

class Tuple : public Duo<P1, typename Tuple<P2, P3, P4, P5, NullT>::BaseT > {

public:

typedef Duo<P1, typename Tuple<P2, P3, P4, P5, NullT>::BaseT> BaseT;

 

//constructor

Tuple() { };

Tuple(typename TypeOperator<P1>::RefConstT a1,

typename TypeOperator<P2>::RefConstT a2,

typename TypeOperator<P3>::RefConstT a3 = NullT(),

typename TypeOperator<P4>::RefConstT a4 = NullT(),

typename TypeOperator<P5>::RefConstT a5 = NullT()

)

: BaseT(a1, Tuple<P2, P3, P4, P5, NullT>(a2, a3, a4, a5)) {

 

};

};

 

//We need a partial specialization to end this recursion with the derivation

//from a nonrecursive duo:

 

template<class P1, class P2>

class Tuple<P1, P2, NullT, NullT, NullT> : public Duo<P1, P2> {

public:

typedef Duo<P1, P2> BaseT;

 

//constructor

Tuple() { };

Tuple(

typename TypeOperator<P1>::RefConstT a1,

typename TypeOperator<P2>::RefConstT a2,

typename TypeOperator<NullT>::RefConstT = NullT(),

typename TypeOperator<NullT>::RefConstT = NullT(),

typename TypeOperator<NullT>::RefConstT = NullT()

) : BaseT(a1, a2) {

 

};

};

 

//specialization for singletons

 

template<class P1>

class Tuple<P1, NullT, NullT, NullT, NullT> : public Duo<P1, void> {

public:

typedef Duo<P1, void> BaseT;

 

//constructor

Tuple() { };

Tuple(

typename TypeOperator<P1>::RefConstT a1,

typename TypeOperator<NullT>::RefConstT = NullT(),

typename TypeOperator<NullT>::RefConstT = NullT(),

typename TypeOperator<NullT>::RefConstT = NullT(),

typename TypeOperator<NullT>::RefConstT = NullT()

) : BaseT(a1) {

 

};

};

 

/**************************************************************************

MAKE_TUPLE

***************************************************************************/

// convenience function for 1 argument

template<class T1>

inline

Tuple<T1> make_tuple(const T1& a1) {

return Tuple<T1>(a1);

}

 

// convenience function for 2 arguments

template<class T1, class T2>

inline

Tuple<T1, T2> make_tuple(const T1& a1, const T2& a2) {

return Tuple<T1, T2> (a1, a2);

}

 

// convenience function for 3 arguments

template<class T1, class T2, class T3>

inline

Tuple<T1, T2, T3> make_tuple(const T1& a1, const T2& a2, const T3& a3) {

return Tuple<T1, T2, T3>(a1, a2, a3);

}

 

// convenience function for 4 arguments

template<class T1, class T2, class T3, class T4>

inline

Tuple<T1, T2, T3, T4> make_tuple(const T1& a1, const T2& a2,

const T3& a3, const T4& a4) {

return Tuple<T1, T2, T3, T4>(a1, a2, a3, a4);

}

 

// convenience function for 5 arguments

template<class T1, class T2, class T3, class T4, class T5>

inline

Tuple<T1, T2, T3, T4, T5> make_tuple(const T1& a1, const T2& a2,

const T3& a3, const T4& a4,

const T5& a5)

{

return Tuple<T1, T2, T3, T4, T5> (a1, a2, a3, a4, a5);

}

 

/**************************************************************************

DRIVER

**************************************************************************/

 

 

#include <iostream>

 

//DRIVER---2

 

int main() {

// create and use tuple with only one field

Tuple<int> t1;

val<1>(t1) += 42;

std::cout << t1.v1() << std::endl;

 

//creat and use duo

std::cout << "test duo" << std::endl;

Tuple<bool, int> t2;

std::cout << val<1>(t2) << " , ";

std::cout << t2.v1() << std::endl;

 

//creat and use triple

std::cout << "test triple" << std::endl;

Tuple<bool, int, double> t3;

val<1>(t3) = true;

val<2>(t3) = 42;

val<3>(t3) = 0.2;

 

std::cout << val<1>(t3) << ", ";

std::cout << val<2>(t3) << ", ";

std::cout << val<3>(t3) << std::endl;

 

t3 = make_tuple(false, 23, 13.13);

 

std::cout << val<1>(t3) << ", ";

std::cout << val<2>(t3) << ", ";

std::cout << val<3>(t3) << std::endl;

 

// create and use quadruple

std::cout << "quadruple" << std::endl;

Tuple<bool,int,float,double> t4(true, 42, 13, 1.95583);

std::cout << val<4>(t4) << std::endl;

std::cout << t4.v2().v2().v2() << std::endl;

 

return 0;

}

//

//