130 lines
3.3 KiB
C++
130 lines
3.3 KiB
C++
#pragma once
|
|
#include <fc/utility.hpp>
|
|
|
|
namespace fc {
|
|
|
|
/**
|
|
* Provides a fast-compiling tuple that doesn't use fancy meta-programming
|
|
* techniques. It is limited to 4 parameters which is sufficient for most
|
|
* methods argument lists which is the primary use case for this tuple. Methods
|
|
* that require more than 4 parameters are probably better served by defining
|
|
* a struct.
|
|
*
|
|
* The members of the tuple are easily visited with a simple visitor functor
|
|
* of the form:
|
|
* @code
|
|
* struct visitor {
|
|
* template<typename MemberType>
|
|
* void operator()( MemberType& m );
|
|
*
|
|
* template<typename MemberType>
|
|
* void operator()( const MemberType& m );
|
|
* };
|
|
* @endcode
|
|
*/
|
|
template<typename A=void, typename B=void,typename C=void, typename D=void>
|
|
struct tuple {
|
|
tuple(){}
|
|
enum size_enum { size = 4 };
|
|
|
|
template<typename AA, typename BB, typename CC, typename DD>
|
|
tuple( AA&& aa, BB&& bb, CC&& cc, DD&& dd )
|
|
:a( fc::forward<AA>(aa) ),
|
|
b( fc::forward<BB>(bb) ),
|
|
c( fc::forward<CC>(cc) ),
|
|
d( fc::forward<DD>(dd) )
|
|
{}
|
|
|
|
template<typename V>
|
|
void visit( V&& v ) { v(a); v(b); v(c); v(d); }
|
|
template<typename V>
|
|
void visit( V&& v )const { v(a); v(b); v(c); v(d); }
|
|
|
|
A a;
|
|
B b;
|
|
C c;
|
|
D d;
|
|
};
|
|
|
|
template<>
|
|
struct tuple<> {
|
|
enum size_enum { size = 0 };
|
|
template<typename V>
|
|
void visit( V&& v)const{};
|
|
};
|
|
|
|
template<typename A>
|
|
struct tuple<A,void> {
|
|
enum size_enum { size = 1 };
|
|
template<typename AA>
|
|
tuple( AA&& aa ):a( fc::forward<AA>(aa) ){}
|
|
tuple( const tuple& t ):a(t.a){}
|
|
tuple( tuple&& t ):a(t.a){}
|
|
tuple(){}
|
|
|
|
template<typename V>
|
|
void visit( V&& v ) { v(a); }
|
|
template<typename V>
|
|
void visit( V&& v )const { v(a); }
|
|
|
|
A a;
|
|
};
|
|
|
|
template<typename A, typename B>
|
|
struct tuple<A,B> {
|
|
enum size_enum { size = 2 };
|
|
|
|
template<typename AA, typename BB>
|
|
tuple( AA&& aa, BB&& bb )
|
|
:a( fc::forward<AA>(aa) ),
|
|
b( fc::forward<BB>(bb) ){}
|
|
|
|
tuple(){}
|
|
|
|
template<typename V>
|
|
void visit( V&& v ) { v(a); v(b); }
|
|
template<typename V>
|
|
void visit( V&& v )const { v(a); v(b); }
|
|
|
|
A a;
|
|
B b;
|
|
};
|
|
|
|
template<typename A, typename B, typename C>
|
|
struct tuple<A, B, C > {
|
|
enum size_enum { size = 3 };
|
|
tuple(){}
|
|
|
|
template<typename AA, typename BB, typename CC>
|
|
tuple( AA&& aa, BB&& bb, CC&& cc )
|
|
:a( fc::forward<AA>(aa) ),
|
|
b( fc::forward<BB>(bb) ),
|
|
c( fc::forward<CC>(cc) )
|
|
{}
|
|
|
|
template<typename V>
|
|
void visit( V&& v ) { v(a); v(b); v(c); }
|
|
template<typename V>
|
|
void visit( V&& v )const { v(a); v(b); v(c); }
|
|
|
|
A a;
|
|
B b;
|
|
C c;
|
|
};
|
|
|
|
tuple<> make_tuple();
|
|
|
|
template<typename A>
|
|
tuple<A> make_tuple(A&& a){ return tuple<A>( fc::forward<A>(a) ); }
|
|
|
|
template<typename A,typename B>
|
|
tuple<A,B> make_tuple(A&& a, B&& b){ return tuple<A,B>( fc::forward<A>(a), fc::forward<B>(b) ); }
|
|
|
|
template<typename A,typename B, typename C>
|
|
tuple<A,B,C> make_tuple(A&& a, B&& b, C&& c){ return tuple<A,B,C>( fc::forward<A>(a), fc::forward<B>(b), fc::forward<C>(c) ); }
|
|
|
|
template<typename A,typename B, typename C,typename D>
|
|
tuple<A,B,C> make_tuple(A&& a, B&& b, C&& c, D&& d){
|
|
return tuple<A,B,C,D>( fc::forward<A>(a), fc::forward<B>(b), fc::forward<C>(c), fc::forward<D>(d) );
|
|
}
|
|
}
|