This is the mail archive of the
libstdc++@gcc.gnu.org
mailing list for the libstdc++ project.
Re: Tuple: mark 2
- From: Chris Jefferson <caj at cs dot york dot ac dot uk>
- To: libstdc++ <libstdc++ at gcc dot gnu dot org>
- Date: Sun, 24 Oct 2004 14:22:19 +0100
- Subject: Re: Tuple: mark 2
- References: <417AD78B.7060105@cs.york.ac.uk>
OK, just before it gets committed, one very simple simplification. I was
adding a specialisation to some thing for const T& when I didn't have
to, as T& would have done.
Sorry
Chris
// 2004-09-23 Chris Jefferson <chris@bubblescope.net>
// Copyright (C) 2004 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library 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 this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// Tuple
#include<stdio.h>
#ifndef SIZE
#define SIZE 10
#endif
// This defines how far lines should be indented
int indent = 0;
// This defines how far the last drawn line went horizontally
int horizontalpos = 0;
// Just prints out as many spaces as the current indent
void
do_indent()
{
int i;
for (i = 0; i < indent; i++)
printf(" ");
}
/* Checks to see if printing the next line will overflow the line.
* If so, go onto the next line
*/
void
check_horizontal(int length)
{
horizontalpos += length;
if(horizontalpos > 79)
{
printf("\n");
indent+=6;
do_indent();
horizontalpos = indent + length;
indent-=6;
}
}
char buffer[1000];
/* line takes a line to print, and indents
* it to the level set by the global 'indent'
*/
void
line(char* str)
{
do_indent();
printf(str);
printf("\n");
horizontalpos = 0;
}
/* loopprint prints as follows:
* 'start body(0) seperate body(1) ... body(loop-1) end'
* where body(i) is the string body with up to 3 occurances of %d
* replaced with i
* if i=0; then simply 'start end' is outputted
*/
void
loopprint_noindent(int loop, char* start, char* body, char *end)
{
int i = 0;
printf(start);
horizontalpos += strlen(start);
for (i = 0; i < loop-1; i++)
{
check_horizontal(strlen(body) + 2);
printf(body, i, i, i, i, i);
printf(", ");
}
if(loop != 0)
{
check_horizontal(strlen(body) + 2);
printf(body, loop-1, loop-1, loop-1, loop-1, loop-1, loop-1);
}
check_horizontal(strlen(end));
printf(end);
if(strlen(end) != 0 && end[strlen(end)-1] == '\n')
horizontalpos = 0;
}
void
loopprint(int loop, char* start, char* body, char *end)
{
do_indent();
horizontalpos = indent;
loopprint_noindent(loop, start, body, end);
}
/* looplist just takes an integer loop and a char* body, and writes
* body(0)\n body(1)\n body(2)\n ... body(loop-1)\n
* where body(i) replaces all occurances of %d with i
*/
void
looplist(int loop,char* body)
{
int i;
for (i = 0; i < loop; i++)
{
do_indent();
printf(body, i, i, i);
printf("\n");
}
}
// These are just a bunch of functions that generate commonly used things
void
braceopen()
{
line("{");
indent += 2;
}
void
braceclose()
{
indent -= 2;
line("}");
}
void
classclose()
{
indent -= 2;
line("};");
line("");
}
//Now the functions that generate the various parts of the header
void
print_copyright()
{
line("// 2004-09-23 Chris Jefferson <chris@bubblescope.net>");
line("// This header is automatically generated.");
line("// See maketuple.c for details");
line("");
line("// Copyright (C) 2004 Free Software Foundation, Inc.");
line("//");
line("// This file is part of the GNU ISO C++ Library. This library is free");
line("// software; you can redistribute it and/or modify it under the");
line("// terms of the GNU General Public License as published by the");
line("// Free Software Foundation; either version 2, or (at your option)");
line("// any later version.");
line("");
line("// This library is distributed in the hope that it will be useful,");
line("// but WITHOUT ANY WARRANTY; without even the implied warranty of");
line("// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the");
line("// GNU General Public License for more details.");
line("");
line("// You should have received a copy of the GNU General Public License along");
line("// with this library; see the file COPYING. If not, write to the Free");
line("// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,");
line("// USA.");
line("");
line("// Tuple");
}
void
reference_wrapper()
{
line("/* reference_wrapper provides a way to annotate that a reference");
line(" * to an object should be passed");
line(" */");
line("template<typename _T>");
indent += 2;
line("class reference_wrapper");
braceopen();
line("_T& __data;");
line("public:");
indent += 2;
line("typedef _T type;");
line("explicit reference_wrapper(_T& __indata): __data(__indata)");
line("{ }");
line("");
line("operator _T& () const");
braceopen();
line("return this->get();");
braceclose();
line("");
line("_T&");
line("get() const");
braceopen();
line("return __data;");
braceclose();
indent -= 2;
classclose();
indent -= 2;
line("// ref denotes a reference should be taken to a variable");
line("template<typename _T>");
indent += 2;
line("reference_wrapper<_T>");
line("ref(_T& __t)");
braceopen();
line("return reference_wrapper<_T>(__t);");
braceclose();
indent -= 2;
line("");
line("// cref denotes a const reference should be taken to a variable");
line("template<typename _T>");
indent += 2;
line("reference_wrapper<_T const>");
line("cref(const _T& __t)");
braceopen();
line("return reference_wrapper<_T const>(__t);");
braceclose();
indent -= 2;
line("");
}
void
add_reference()
{
line("// Adds a const reference to a non-reference type");
line("template<typename _T>");
indent += 2;
line("struct __add_const_ref");
braceopen();
line("typedef const _T& type;");
classclose();
indent -= 2;
line("template<typename _T>");
indent += 2;
line("struct __add_const_ref<_T&>");
braceopen();
line("typedef _T& type;");
classclose();
indent -= 2;
line("// adds a reference to a non-reference type");
line("template<typename _T>");
indent += 2;
line("struct __add_ref");
braceopen();
line("typedef _T& type;");
classclose();
indent -= 2;
line("template<typename _T>");
indent += 2;
line("struct __add_ref<_T&>");
braceopen();
line("typedef _T& type;");
classclose();
indent -= 2;
}
void
printClass(int in)
{
braceopen();
looplist(in, "_T%d __t%d;");
line("public:");
indent += 2;
// Blank constructor
line("tuple()");
line("{ }");
line("");
// Explicit constructor
loopprint(in, "explicit tuple(",
"typename __add_const_ref<_T%d>::type __in%d", "):\n");
loopprint(in, "", "__t%d(__in%d)", "\n");
line("{ }");
line("");
// Copy constructor
line("tuple(const tuple& __in):");
loopprint(in, "", "__t%d(__in.__t%d)", "\n");
line("{ }");
// Copy from other tuple constructor
loopprint(in, "template <", "typename _U%d", ">\n");
loopprint(in, "tuple(const tuple<", "_U%d", ">& __in):\n");
loopprint(in, "", "__t%d(__in.__t%d)", "\n");
line("{ }");
line("");
// Pair goes here
if(in == 2)
{
line("template<class _U1, class _U2>");
line(" tuple(const std::pair<_U1, _U2>& __u): __t0(__u.first), __t1(__u.second)");
line(" { }");
line("");
}
// operator = from identical
line("tuple& operator=(const tuple& __in)");
braceopen();
looplist(in, "__t%d=__in.__t%d;");
line("return *this;");
braceclose();
line("");
loopprint(in, "template <", "typename _U%d", ">\n");
line("tuple&");
loopprint(in, "operator=(const tuple<", "_U%d", ">& __in)\n");
braceopen();
looplist(in, "__t%d=__in.__t%d;");
line("return *this;");
braceclose();
line("template<int __i, typename _U>");
line(" friend class __get_helper;");
loopprint(SIZE, "template<", "typename", ">\n");
line("friend class tuple;");
indent -= 2;
classclose();
}
void tuple_classes() {
int i;
// Do the empty tuple class
line("// The empty tuple");
line("template<>");
indent += 2;
loopprint(SIZE, "class tuple<", "_NullClass", ">\n");
braceopen();
line("public:");
indent += 2;
// Blank constructor
line("tuple()");
line("{ }");
line("");
// no explicit constructor
// Copy constructor
line("tuple(const tuple& __in)");
line("{ }");
line("");
// no copy from other tuple constructor
// operator = from identical
line("tuple& operator=(const tuple& __in)");
braceopen();
line("return *this;");
braceclose();
// no operator = from other
indent -= 2;
classclose();
indent -= 2;
// Now do all the other classes
for (i = 1; i <= SIZE; i++)
{
loopprint(i, "template<", "typename _T%d", ">\n");
indent += 2;
if(i != SIZE)
{
loopprint(i, "class tuple<", "_T%d", ", ");
loopprint_noindent(SIZE-i, "", "_NullClass", ">\n");
}
else
{
line("class tuple");
}
printClass(i);
indent -= 2;
}
}
void
tuple_size() {
int i;
line("// Finds the size of a given tuple type");
line("template<typename _T>");
line(" struct tuple_size;");
line("");
for (i = 0; i <= SIZE; i++)
{
loopprint(i,"template<","typename _T%d",">\n");
indent += 2;
loopprint(i,"struct tuple_size<tuple<","_T%d","");
if(i == 0 || i == SIZE)
loopprint_noindent(SIZE-i, "", "_NullClass", "> >\n");
else
loopprint_noindent(SIZE-i, ", ", "_NullClass", "> >\n");
braceopen();
do_indent();
printf("static const int value = %d;\n", i);
classclose();
indent -= 2;
}
}
void
tuple_element()
{
line("// Gives the type of the ith element of a given tuple type");
int i;
line("template<int __i, typename _T>");
line(" struct tuple_element;");
line("");
for ( i = 0; i < SIZE; i++)
{
loopprint(SIZE, "template<", "typename _T%d", ">\n");
indent += 2;
sprintf(buffer, "struct tuple_element<%d, tuple<", i);
loopprint(SIZE, buffer, "_T%d","> >\n");
braceopen();
do_indent();
printf("typedef _T%d type;\n", i);
classclose();
indent -= 2;
}
}
void
tuple_value()
{
int i;
line("// Class used in the implementation of get");
line("template<int __i,typename _T>");
line("struct __get_helper;\n");
for (i = 0; i < SIZE; i++) {
line("template<typename _T>");
indent += 2;
do_indent();
printf("struct __get_helper<%d,_T>\n", i);
braceopen();
do_indent();
printf("static typename __add_ref<typename tuple_element<%d,_T>::type>::type\n", i);
line("get_value(_T& __in)");
braceopen();
do_indent();
printf("return __in.__t%d;\n", i);
braceclose();
do_indent();
printf("static typename __add_const_ref<typename tuple_element<%d,_T>::type>::type\n", i);
line("get_value(const _T& __in)");
braceopen();
do_indent();
printf("return __in.__t%d;\n", i);
braceclose();
classclose();
indent -= 2;
}
}
void
get()
{
// non-const get
line("/* Returns a reference to the ith element of a tuple.");
line(" * Any const or non-const ref elements are returned with their original type");
line(" */");
loopprint(SIZE, "template<int __i, ", "typename _T%d", ">\n");
loopprint(SIZE, "typename __add_ref<typename tuple_element<__i,tuple<", "_T%d", "> >::type>::type\n");
loopprint(SIZE, "get(tuple<", "_T%d", ">& __t)\n");
braceopen();
loopprint(SIZE, "return __get_helper<__i,tuple<", "_T%d", "> >::get_value(__t);\n");
braceclose();
line("");
// const get
line("/* Returns a const reference to the ith element of a tuple.");
line(" * Any const or non-const ref elements are returned with their original type");
line(" */");
loopprint(SIZE, "template<int __i, ", "typename _T%d", ">\n");
loopprint(SIZE, "typename __add_const_ref<typename tuple_element<__i,tuple<",
"_T%d", "> >::type>::type\n");
loopprint(SIZE, "get(const tuple<", "_T%d", ">& __t)\n");
braceopen();
loopprint(SIZE, "return __get_helper<__i,tuple<", "_T%d", "> >::get_value(__t);\n");
braceclose();
line("");
}
void
make_compare(char* name, char* before_recurse, char* after_recurse)
{
do_indent();
printf("static bool __%s(const _T& __t, const _U& __u)\n", name);
braceopen();
do_indent();
printf("return %s\n", before_recurse);
do_indent();
printf(" __tuple_compare<0, __i+1, __j, _T, _U>"
"::__%s(__t, __u) %s;\n", name, after_recurse);
braceclose();
}
void
end_compare(char* name, int end_val)
{
do_indent();
printf("static bool __%s(const _T&, const _U&)\n", name);
braceopen();
if(end_val)
line("return true;");
else
line("return false;");
braceclose();
}
void
tuple_compare()
{
//comparison helper
line("// This class helps construct the various comparison operations on tuples");
line("template<int __check_equal_size, int __i, int __j, typename _T, typename _U>");
line(" struct __tuple_compare;");
line("");
line("template<int __i, int __j, typename _T, typename _U>");
indent += 2;
line("struct __tuple_compare<0, __i, __j, _T, _U>");
braceopen();
make_compare("eq", "get<__i>(__t) == get<__i>(__u) &&", "");
make_compare("neq", "get<__i>(__t) != get<__i>(__u) ||", "");
make_compare("less", "(get<__i>(__t) < get<__i>(__u)) || !(get<__i>(__u) < get<__i>(__t)) &&", "");
make_compare("greater", "(get<__i>(__t) > get<__i>(__u)) || !(get<__i>(__u) > get<__i>(__t)) &&", "");
make_compare("leq", "(get<__i>(__t) <= get<__i>(__u)) && (!(get<__i>(__u)<=get<__i>(__t)) ||", ")");
make_compare("geq", "(get<__i>(__t) >= get<__i>(__u)) && (!(get<__i>(__u)>=get<__i>(__t)) ||", ")");
classclose();
indent -= 2;
line("template<int __i, typename _T, typename _U>");
line("struct __tuple_compare<0, __i, __i, _T, _U>");
braceopen();
end_compare("eq", 1);
end_compare("neq", 0);
end_compare("leq", 1);
end_compare("geq", 1);
end_compare("less", 0);
end_compare("greater", 0);
classclose();
}
void
operator_definition(char* op, char* text_op_name)
{
loopprint(SIZE, "template<", "typename _T%d", ", ");
loopprint_noindent(SIZE, "", "typename _U%d", ">\n");
line("bool");
sprintf(buffer, "operator%s(const tuple<",op);
loopprint(SIZE,buffer, "_T%d", ">& __t, ");
loopprint_noindent(SIZE, "const tuple<", "_U%d", ">& __u)\n");
line("{");
indent += 2;
loopprint(SIZE, "typedef tuple<", "_T%d", "> __T_tuple;\n");
loopprint(SIZE, "typedef tuple<", "_U%d", "> __U_tuple;\n");
do_indent();
printf("return __tuple_compare<tuple_size<__T_tuple>::value -\n tuple_size<__U_tuple>::value, 0,\n tuple_size<__T_tuple>::value, __T_tuple, __U_tuple>::__%s(__t, __u);\n",text_op_name);
indent -= 2;
line("}");
line("");
}
void
strip_reference_wrapper()
{
line("// Helper which adds a reference to a type when given a reference_wrapper");
line("template<typename _T>");
line("struct __strip_reference_wrapper");
braceopen();
line(" typedef _T __type;");
classclose();
line("template<typename _T>");
line("struct __strip_reference_wrapper<reference_wrapper<_T> >");
braceopen();
line("typedef _T& __type;");
classclose();
line("template<typename _T>");
line("struct __strip_reference_wrapper<const reference_wrapper<_T> >");
braceopen();
line(" typedef _T& __type;");
classclose();
loopprint(SIZE, "template<", "typename _T%d = _NullClass", ">\n");
line("struct __stripped_tuple_type");
braceopen();
loopprint(SIZE, "typedef tuple<",
"typename __strip_reference_wrapper<_T%d>::__type", ">");
line("__type;");
classclose();
}
void
make_tuple()
{
int i;
line("tuple<>");
line("make_tuple()");
braceopen();
line(" return tuple<>();");
classclose();
for (i = 1; i <= SIZE; i++) {
loopprint(i, "template<", "typename _T%d", ">\n");
loopprint(i, "typename __stripped_tuple_type<", "_T%d", ">::__type\n");
loopprint(i, "make_tuple(", "_T%d __t%d", ")\n");
braceopen();
loopprint(i, "return typename __stripped_tuple_type<", "_T%d", ">::");
loopprint(i, "__type(", "__t%d", ");");
classclose();
}
}
void
make_tie()
{
int i;
line("/* A class (and instance) which can be used in 'tie' when a");
line(" * element is not required");
line(" */");
line("");
line("struct swallow_assign");
braceopen();
line("template <class T>");
line("swallow_assign&");
line("operator=(const T&)");
braceopen();
line("return *this;");
braceclose();
classclose();
line("extern swallow_assign ignore;");
line("");
line("// tie allows forms a tuple of references to a list of variables");
for (i = 1; i <= SIZE; i++) {
loopprint(i, "template<", "typename _T%d", ">\n");
loopprint(i, "tuple<", "_T%d&", ">\n");
loopprint(i, "tie(", "_T%d& __t%d", ")\n");
braceopen();
loopprint(i, "return make_tuple(", "ref(__t%d)", ");\n");
classclose();
}
}
void
pair_things(void)
{
line("// Various functions which give std::pair a tuple-like interface");
line("template<class _T1, class _T2>");
line(" struct tuple_size<std::pair<_T1, _T2> >");
line(" {");
line(" static const int value = 2;");
line(" };");
line("");
line("template<class _T1, class _T2>");
line(" struct tuple_element<0, std::pair<_T1, _T2> >");
line(" {");
line(" typedef _T1 type;");
line(" };");
line("");
line("template<class _T1, class _T2>");
line(" struct tuple_element<1, std::pair<_T1, _T2> >");
line(" {");
line(" typedef _T2 type;");
line(" };");
line("");
line("template<int _I,class _T1,class _T2>");
line(" typename tuple_element<_I,tuple<_T1, _T2> >::type");
line(" get(pair<_T1, _T2>& __in)");
line(" {");
line(" return get<_I>(tie(__in.first, __in.second));");
line(" }");
line("");
line("template<int _I,class _T1,class _T2>");
line(" typename tuple_element<_I,tuple<_T1, _T2> >::type");
line(" get(const pair<_T1, _T2>& __in)");
line(" {");
line(" return get<_I>(tie(__in.first, __in.second));");
line(" }");
line("");
}
int
main(void)
{
print_copyright();
line("#include<utility>");
line("namespace std");
line("{");
line("namespace tr1");
line("{");
// This is just a helper object
line("/* An implementation specific class which is used in the tuple");
line(" * class when the tuple is not maximum possible size");
line(" */");
line("struct _NullClass");
line("{ };");
line("");
// Forward definition of tuple class
line("// Foward definition of the tuple class");
loopprint(SIZE, "template<", "typename _T%d=_NullClass", ">\n");
indent += 2;
line("class tuple;");
indent -= 2;
line("");
tuple_element();
tuple_size();
add_reference(); //Note: internal class!
tuple_classes();
tuple_value(); //Note: this is an implemention-specific helper class used in get
get();
tuple_compare(); //Note: this is an implemention-specific helper class
operator_definition("==", "eq");
operator_definition("!=", "neq");
operator_definition("<", "less");
operator_definition(">", "greater");
operator_definition("<=", "leq");
operator_definition(">=", "geq");
reference_wrapper();
strip_reference_wrapper(); //Note: this is a helper class for make_tuple
make_tuple();
make_tie();
pair_things();
line("");
line("// TODO: Put this in some kind of shared file");
line("swallow_assign ignore;");
line("}");
line("}");
return 0;
}
// 2004-09-23 Chris Jefferson <chris@bubblescope.net>
// This header is automatically generated.
// See maketuple.c for details
// Copyright (C) 2004 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.
// This library 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 this library; see the file COPYING. If not, write to the Free
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
// Tuple
#include<utility>
namespace std
{
namespace tr1
{
/* An implementation specific class which is used in the tuple
* class when the tuple is not maximum possible size
*/
struct _NullClass
{ };
// Foward definition of the tuple class
template<typename _T0=_NullClass, typename _T1=_NullClass,
typename _T2=_NullClass, typename _T3=_NullClass,
typename _T4=_NullClass, typename _T5=_NullClass,
typename _T6=_NullClass, typename _T7=_NullClass,
typename _T8=_NullClass, typename _T9=_NullClass>
class tuple;
// Gives the type of the ith element of a given tuple type
template<int __i, typename _T>
struct tuple_element;
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8, typename _T9>
struct tuple_element<0, tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6,
_T7, _T8, _T9> >
{
typedef _T0 type;
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8, typename _T9>
struct tuple_element<1, tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6,
_T7, _T8, _T9> >
{
typedef _T1 type;
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8, typename _T9>
struct tuple_element<2, tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6,
_T7, _T8, _T9> >
{
typedef _T2 type;
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8, typename _T9>
struct tuple_element<3, tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6,
_T7, _T8, _T9> >
{
typedef _T3 type;
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8, typename _T9>
struct tuple_element<4, tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6,
_T7, _T8, _T9> >
{
typedef _T4 type;
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8, typename _T9>
struct tuple_element<5, tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6,
_T7, _T8, _T9> >
{
typedef _T5 type;
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8, typename _T9>
struct tuple_element<6, tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6,
_T7, _T8, _T9> >
{
typedef _T6 type;
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8, typename _T9>
struct tuple_element<7, tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6,
_T7, _T8, _T9> >
{
typedef _T7 type;
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8, typename _T9>
struct tuple_element<8, tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6,
_T7, _T8, _T9> >
{
typedef _T8 type;
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8, typename _T9>
struct tuple_element<9, tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6,
_T7, _T8, _T9> >
{
typedef _T9 type;
};
// Finds the size of a given tuple type
template<typename _T>
struct tuple_size;
template<>
struct tuple_size<tuple<_NullClass, _NullClass, _NullClass, _NullClass,
_NullClass, _NullClass, _NullClass, _NullClass, _NullClass,
_NullClass> >
{
static const int value = 0;
};
template<typename _T0>
struct tuple_size<tuple<_T0, _NullClass, _NullClass, _NullClass,
_NullClass, _NullClass, _NullClass, _NullClass, _NullClass,
_NullClass> >
{
static const int value = 1;
};
template<typename _T0, typename _T1>
struct tuple_size<tuple<_T0, _T1, _NullClass, _NullClass, _NullClass,
_NullClass, _NullClass, _NullClass, _NullClass, _NullClass> >
{
static const int value = 2;
};
template<typename _T0, typename _T1, typename _T2>
struct tuple_size<tuple<_T0, _T1, _T2, _NullClass, _NullClass,
_NullClass, _NullClass, _NullClass, _NullClass, _NullClass> >
{
static const int value = 3;
};
template<typename _T0, typename _T1, typename _T2, typename _T3>
struct tuple_size<tuple<_T0, _T1, _T2, _T3, _NullClass, _NullClass,
_NullClass, _NullClass, _NullClass, _NullClass> >
{
static const int value = 4;
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4>
struct tuple_size<tuple<_T0, _T1, _T2, _T3, _T4, _NullClass,
_NullClass, _NullClass, _NullClass, _NullClass> >
{
static const int value = 5;
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5>
struct tuple_size<tuple<_T0, _T1, _T2, _T3, _T4, _T5, _NullClass,
_NullClass, _NullClass, _NullClass> >
{
static const int value = 6;
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6>
struct tuple_size<tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6,
_NullClass, _NullClass, _NullClass> >
{
static const int value = 7;
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7>
struct tuple_size<tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7,
_NullClass, _NullClass> >
{
static const int value = 8;
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8>
struct tuple_size<tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7,
_T8, _NullClass> >
{
static const int value = 9;
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8, typename _T9>
struct tuple_size<tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7,
_T8, _T9> >
{
static const int value = 10;
};
// Adds a const reference to a non-reference type
template<typename _T>
struct __add_const_ref
{
typedef const _T& type;
};
template<typename _T>
struct __add_const_ref<_T&>
{
typedef _T& type;
};
// adds a reference to a non-reference type
template<typename _T>
struct __add_ref
{
typedef _T& type;
};
template<typename _T>
struct __add_ref<_T&>
{
typedef _T& type;
};
// The empty tuple
template<>
class tuple<_NullClass, _NullClass, _NullClass, _NullClass, _NullClass,
_NullClass, _NullClass, _NullClass, _NullClass, _NullClass>
{
public:
tuple()
{ }
tuple(const tuple& __in)
{ }
tuple& operator=(const tuple& __in)
{
return *this;
}
};
template<typename _T0>
class tuple<_T0, _NullClass, _NullClass, _NullClass, _NullClass,
_NullClass, _NullClass, _NullClass, _NullClass, _NullClass>
{
_T0 __t0;
public:
tuple()
{ }
explicit tuple(typename __add_const_ref<_T0>::type __in0):
__t0(__in0)
{ }
tuple(const tuple& __in):
__t0(__in.__t0)
{ }
template <typename _U0>
tuple(const tuple<_U0>& __in):
__t0(__in.__t0)
{ }
tuple& operator=(const tuple& __in)
{
__t0=__in.__t0;
return *this;
}
template <typename _U0>
tuple&
operator=(const tuple<_U0>& __in)
{
__t0=__in.__t0;
return *this;
}
template<int __i, typename _U>
friend class __get_helper;
template<typename, typename, typename, typename, typename, typename,
typename, typename, typename, typename>
friend class tuple;
};
template<typename _T0, typename _T1>
class tuple<_T0, _T1, _NullClass, _NullClass, _NullClass, _NullClass,
_NullClass, _NullClass, _NullClass, _NullClass>
{
_T0 __t0;
_T1 __t1;
public:
tuple()
{ }
explicit tuple(typename __add_const_ref<_T0>::type __in0,
typename __add_const_ref<_T1>::type __in1):
__t0(__in0), __t1(__in1)
{ }
tuple(const tuple& __in):
__t0(__in.__t0), __t1(__in.__t1)
{ }
template <typename _U0, typename _U1>
tuple(const tuple<_U0, _U1>& __in):
__t0(__in.__t0), __t1(__in.__t1)
{ }
template<class _U1, class _U2>
tuple(const std::pair<_U1, _U2>& __u): __t0(__u.first), __t1(__u.second)
{ }
tuple& operator=(const tuple& __in)
{
__t0=__in.__t0;
__t1=__in.__t1;
return *this;
}
template <typename _U0, typename _U1>
tuple&
operator=(const tuple<_U0, _U1>& __in)
{
__t0=__in.__t0;
__t1=__in.__t1;
return *this;
}
template<int __i, typename _U>
friend class __get_helper;
template<typename, typename, typename, typename, typename, typename,
typename, typename, typename, typename>
friend class tuple;
};
template<typename _T0, typename _T1, typename _T2>
class tuple<_T0, _T1, _T2, _NullClass, _NullClass, _NullClass,
_NullClass, _NullClass, _NullClass, _NullClass>
{
_T0 __t0;
_T1 __t1;
_T2 __t2;
public:
tuple()
{ }
explicit tuple(typename __add_const_ref<_T0>::type __in0,
typename __add_const_ref<_T1>::type __in1,
typename __add_const_ref<_T2>::type __in2):
__t0(__in0), __t1(__in1), __t2(__in2)
{ }
tuple(const tuple& __in):
__t0(__in.__t0), __t1(__in.__t1), __t2(__in.__t2)
{ }
template <typename _U0, typename _U1, typename _U2>
tuple(const tuple<_U0, _U1, _U2>& __in):
__t0(__in.__t0), __t1(__in.__t1), __t2(__in.__t2)
{ }
tuple& operator=(const tuple& __in)
{
__t0=__in.__t0;
__t1=__in.__t1;
__t2=__in.__t2;
return *this;
}
template <typename _U0, typename _U1, typename _U2>
tuple&
operator=(const tuple<_U0, _U1, _U2>& __in)
{
__t0=__in.__t0;
__t1=__in.__t1;
__t2=__in.__t2;
return *this;
}
template<int __i, typename _U>
friend class __get_helper;
template<typename, typename, typename, typename, typename, typename,
typename, typename, typename, typename>
friend class tuple;
};
template<typename _T0, typename _T1, typename _T2, typename _T3>
class tuple<_T0, _T1, _T2, _T3, _NullClass, _NullClass, _NullClass,
_NullClass, _NullClass, _NullClass>
{
_T0 __t0;
_T1 __t1;
_T2 __t2;
_T3 __t3;
public:
tuple()
{ }
explicit tuple(typename __add_const_ref<_T0>::type __in0,
typename __add_const_ref<_T1>::type __in1,
typename __add_const_ref<_T2>::type __in2,
typename __add_const_ref<_T3>::type __in3):
__t0(__in0), __t1(__in1), __t2(__in2), __t3(__in3)
{ }
tuple(const tuple& __in):
__t0(__in.__t0), __t1(__in.__t1), __t2(__in.__t2),
__t3(__in.__t3)
{ }
template <typename _U0, typename _U1, typename _U2, typename _U3>
tuple(const tuple<_U0, _U1, _U2, _U3>& __in):
__t0(__in.__t0), __t1(__in.__t1), __t2(__in.__t2),
__t3(__in.__t3)
{ }
tuple& operator=(const tuple& __in)
{
__t0=__in.__t0;
__t1=__in.__t1;
__t2=__in.__t2;
__t3=__in.__t3;
return *this;
}
template <typename _U0, typename _U1, typename _U2, typename _U3>
tuple&
operator=(const tuple<_U0, _U1, _U2, _U3>& __in)
{
__t0=__in.__t0;
__t1=__in.__t1;
__t2=__in.__t2;
__t3=__in.__t3;
return *this;
}
template<int __i, typename _U>
friend class __get_helper;
template<typename, typename, typename, typename, typename, typename,
typename, typename, typename, typename>
friend class tuple;
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4>
class tuple<_T0, _T1, _T2, _T3, _T4, _NullClass, _NullClass,
_NullClass, _NullClass, _NullClass>
{
_T0 __t0;
_T1 __t1;
_T2 __t2;
_T3 __t3;
_T4 __t4;
public:
tuple()
{ }
explicit tuple(typename __add_const_ref<_T0>::type __in0,
typename __add_const_ref<_T1>::type __in1,
typename __add_const_ref<_T2>::type __in2,
typename __add_const_ref<_T3>::type __in3,
typename __add_const_ref<_T4>::type __in4):
__t0(__in0), __t1(__in1), __t2(__in2), __t3(__in3),
__t4(__in4)
{ }
tuple(const tuple& __in):
__t0(__in.__t0), __t1(__in.__t1), __t2(__in.__t2),
__t3(__in.__t3), __t4(__in.__t4)
{ }
template <typename _U0, typename _U1, typename _U2, typename _U3,
typename _U4>
tuple(const tuple<_U0, _U1, _U2, _U3, _U4>& __in):
__t0(__in.__t0), __t1(__in.__t1), __t2(__in.__t2),
__t3(__in.__t3), __t4(__in.__t4)
{ }
tuple& operator=(const tuple& __in)
{
__t0=__in.__t0;
__t1=__in.__t1;
__t2=__in.__t2;
__t3=__in.__t3;
__t4=__in.__t4;
return *this;
}
template <typename _U0, typename _U1, typename _U2, typename _U3,
typename _U4>
tuple&
operator=(const tuple<_U0, _U1, _U2, _U3, _U4>& __in)
{
__t0=__in.__t0;
__t1=__in.__t1;
__t2=__in.__t2;
__t3=__in.__t3;
__t4=__in.__t4;
return *this;
}
template<int __i, typename _U>
friend class __get_helper;
template<typename, typename, typename, typename, typename, typename,
typename, typename, typename, typename>
friend class tuple;
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5>
class tuple<_T0, _T1, _T2, _T3, _T4, _T5, _NullClass, _NullClass,
_NullClass, _NullClass>
{
_T0 __t0;
_T1 __t1;
_T2 __t2;
_T3 __t3;
_T4 __t4;
_T5 __t5;
public:
tuple()
{ }
explicit tuple(typename __add_const_ref<_T0>::type __in0,
typename __add_const_ref<_T1>::type __in1,
typename __add_const_ref<_T2>::type __in2,
typename __add_const_ref<_T3>::type __in3,
typename __add_const_ref<_T4>::type __in4,
typename __add_const_ref<_T5>::type __in5):
__t0(__in0), __t1(__in1), __t2(__in2), __t3(__in3),
__t4(__in4), __t5(__in5)
{ }
tuple(const tuple& __in):
__t0(__in.__t0), __t1(__in.__t1), __t2(__in.__t2),
__t3(__in.__t3), __t4(__in.__t4), __t5(__in.__t5)
{ }
template <typename _U0, typename _U1, typename _U2, typename _U3,
typename _U4, typename _U5>
tuple(const tuple<_U0, _U1, _U2, _U3, _U4, _U5>& __in):
__t0(__in.__t0), __t1(__in.__t1), __t2(__in.__t2),
__t3(__in.__t3), __t4(__in.__t4), __t5(__in.__t5)
{ }
tuple& operator=(const tuple& __in)
{
__t0=__in.__t0;
__t1=__in.__t1;
__t2=__in.__t2;
__t3=__in.__t3;
__t4=__in.__t4;
__t5=__in.__t5;
return *this;
}
template <typename _U0, typename _U1, typename _U2, typename _U3,
typename _U4, typename _U5>
tuple&
operator=(const tuple<_U0, _U1, _U2, _U3, _U4, _U5>& __in)
{
__t0=__in.__t0;
__t1=__in.__t1;
__t2=__in.__t2;
__t3=__in.__t3;
__t4=__in.__t4;
__t5=__in.__t5;
return *this;
}
template<int __i, typename _U>
friend class __get_helper;
template<typename, typename, typename, typename, typename, typename,
typename, typename, typename, typename>
friend class tuple;
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6>
class tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6, _NullClass,
_NullClass, _NullClass>
{
_T0 __t0;
_T1 __t1;
_T2 __t2;
_T3 __t3;
_T4 __t4;
_T5 __t5;
_T6 __t6;
public:
tuple()
{ }
explicit tuple(typename __add_const_ref<_T0>::type __in0,
typename __add_const_ref<_T1>::type __in1,
typename __add_const_ref<_T2>::type __in2,
typename __add_const_ref<_T3>::type __in3,
typename __add_const_ref<_T4>::type __in4,
typename __add_const_ref<_T5>::type __in5,
typename __add_const_ref<_T6>::type __in6):
__t0(__in0), __t1(__in1), __t2(__in2), __t3(__in3),
__t4(__in4), __t5(__in5), __t6(__in6)
{ }
tuple(const tuple& __in):
__t0(__in.__t0), __t1(__in.__t1), __t2(__in.__t2),
__t3(__in.__t3), __t4(__in.__t4), __t5(__in.__t5),
__t6(__in.__t6)
{ }
template <typename _U0, typename _U1, typename _U2, typename _U3,
typename _U4, typename _U5, typename _U6>
tuple(const tuple<_U0, _U1, _U2, _U3, _U4, _U5, _U6>& __in):
__t0(__in.__t0), __t1(__in.__t1), __t2(__in.__t2),
__t3(__in.__t3), __t4(__in.__t4), __t5(__in.__t5),
__t6(__in.__t6)
{ }
tuple& operator=(const tuple& __in)
{
__t0=__in.__t0;
__t1=__in.__t1;
__t2=__in.__t2;
__t3=__in.__t3;
__t4=__in.__t4;
__t5=__in.__t5;
__t6=__in.__t6;
return *this;
}
template <typename _U0, typename _U1, typename _U2, typename _U3,
typename _U4, typename _U5, typename _U6>
tuple&
operator=(const tuple<_U0, _U1, _U2, _U3, _U4, _U5, _U6>& __in)
{
__t0=__in.__t0;
__t1=__in.__t1;
__t2=__in.__t2;
__t3=__in.__t3;
__t4=__in.__t4;
__t5=__in.__t5;
__t6=__in.__t6;
return *this;
}
template<int __i, typename _U>
friend class __get_helper;
template<typename, typename, typename, typename, typename, typename,
typename, typename, typename, typename>
friend class tuple;
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7>
class tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _NullClass,
_NullClass>
{
_T0 __t0;
_T1 __t1;
_T2 __t2;
_T3 __t3;
_T4 __t4;
_T5 __t5;
_T6 __t6;
_T7 __t7;
public:
tuple()
{ }
explicit tuple(typename __add_const_ref<_T0>::type __in0,
typename __add_const_ref<_T1>::type __in1,
typename __add_const_ref<_T2>::type __in2,
typename __add_const_ref<_T3>::type __in3,
typename __add_const_ref<_T4>::type __in4,
typename __add_const_ref<_T5>::type __in5,
typename __add_const_ref<_T6>::type __in6,
typename __add_const_ref<_T7>::type __in7):
__t0(__in0), __t1(__in1), __t2(__in2), __t3(__in3),
__t4(__in4), __t5(__in5), __t6(__in6), __t7(__in7)
{ }
tuple(const tuple& __in):
__t0(__in.__t0), __t1(__in.__t1), __t2(__in.__t2),
__t3(__in.__t3), __t4(__in.__t4), __t5(__in.__t5),
__t6(__in.__t6), __t7(__in.__t7)
{ }
template <typename _U0, typename _U1, typename _U2, typename _U3,
typename _U4, typename _U5, typename _U6, typename _U7>
tuple(const tuple<_U0, _U1, _U2, _U3, _U4, _U5, _U6, _U7
>& __in):
__t0(__in.__t0), __t1(__in.__t1), __t2(__in.__t2),
__t3(__in.__t3), __t4(__in.__t4), __t5(__in.__t5),
__t6(__in.__t6), __t7(__in.__t7)
{ }
tuple& operator=(const tuple& __in)
{
__t0=__in.__t0;
__t1=__in.__t1;
__t2=__in.__t2;
__t3=__in.__t3;
__t4=__in.__t4;
__t5=__in.__t5;
__t6=__in.__t6;
__t7=__in.__t7;
return *this;
}
template <typename _U0, typename _U1, typename _U2, typename _U3,
typename _U4, typename _U5, typename _U6, typename _U7>
tuple&
operator=(const tuple<_U0, _U1, _U2, _U3, _U4, _U5, _U6, _U7
>& __in)
{
__t0=__in.__t0;
__t1=__in.__t1;
__t2=__in.__t2;
__t3=__in.__t3;
__t4=__in.__t4;
__t5=__in.__t5;
__t6=__in.__t6;
__t7=__in.__t7;
return *this;
}
template<int __i, typename _U>
friend class __get_helper;
template<typename, typename, typename, typename, typename, typename,
typename, typename, typename, typename>
friend class tuple;
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8>
class tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8,
_NullClass>
{
_T0 __t0;
_T1 __t1;
_T2 __t2;
_T3 __t3;
_T4 __t4;
_T5 __t5;
_T6 __t6;
_T7 __t7;
_T8 __t8;
public:
tuple()
{ }
explicit tuple(typename __add_const_ref<_T0>::type __in0,
typename __add_const_ref<_T1>::type __in1,
typename __add_const_ref<_T2>::type __in2,
typename __add_const_ref<_T3>::type __in3,
typename __add_const_ref<_T4>::type __in4,
typename __add_const_ref<_T5>::type __in5,
typename __add_const_ref<_T6>::type __in6,
typename __add_const_ref<_T7>::type __in7,
typename __add_const_ref<_T8>::type __in8):
__t0(__in0), __t1(__in1), __t2(__in2), __t3(__in3),
__t4(__in4), __t5(__in5), __t6(__in6), __t7(__in7),
__t8(__in8)
{ }
tuple(const tuple& __in):
__t0(__in.__t0), __t1(__in.__t1), __t2(__in.__t2),
__t3(__in.__t3), __t4(__in.__t4), __t5(__in.__t5),
__t6(__in.__t6), __t7(__in.__t7), __t8(__in.__t8)
{ }
template <typename _U0, typename _U1, typename _U2, typename _U3,
typename _U4, typename _U5, typename _U6, typename _U7,
typename _U8>
tuple(const tuple<_U0, _U1, _U2, _U3, _U4, _U5, _U6, _U7, _U8
>& __in):
__t0(__in.__t0), __t1(__in.__t1), __t2(__in.__t2),
__t3(__in.__t3), __t4(__in.__t4), __t5(__in.__t5),
__t6(__in.__t6), __t7(__in.__t7), __t8(__in.__t8)
{ }
tuple& operator=(const tuple& __in)
{
__t0=__in.__t0;
__t1=__in.__t1;
__t2=__in.__t2;
__t3=__in.__t3;
__t4=__in.__t4;
__t5=__in.__t5;
__t6=__in.__t6;
__t7=__in.__t7;
__t8=__in.__t8;
return *this;
}
template <typename _U0, typename _U1, typename _U2, typename _U3,
typename _U4, typename _U5, typename _U6, typename _U7,
typename _U8>
tuple&
operator=(const tuple<_U0, _U1, _U2, _U3, _U4, _U5, _U6, _U7,
_U8>& __in)
{
__t0=__in.__t0;
__t1=__in.__t1;
__t2=__in.__t2;
__t3=__in.__t3;
__t4=__in.__t4;
__t5=__in.__t5;
__t6=__in.__t6;
__t7=__in.__t7;
__t8=__in.__t8;
return *this;
}
template<int __i, typename _U>
friend class __get_helper;
template<typename, typename, typename, typename, typename, typename,
typename, typename, typename, typename>
friend class tuple;
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8, typename _T9>
class tuple
{
_T0 __t0;
_T1 __t1;
_T2 __t2;
_T3 __t3;
_T4 __t4;
_T5 __t5;
_T6 __t6;
_T7 __t7;
_T8 __t8;
_T9 __t9;
public:
tuple()
{ }
explicit tuple(typename __add_const_ref<_T0>::type __in0,
typename __add_const_ref<_T1>::type __in1,
typename __add_const_ref<_T2>::type __in2,
typename __add_const_ref<_T3>::type __in3,
typename __add_const_ref<_T4>::type __in4,
typename __add_const_ref<_T5>::type __in5,
typename __add_const_ref<_T6>::type __in6,
typename __add_const_ref<_T7>::type __in7,
typename __add_const_ref<_T8>::type __in8,
typename __add_const_ref<_T9>::type __in9):
__t0(__in0), __t1(__in1), __t2(__in2), __t3(__in3),
__t4(__in4), __t5(__in5), __t6(__in6), __t7(__in7),
__t8(__in8), __t9(__in9)
{ }
tuple(const tuple& __in):
__t0(__in.__t0), __t1(__in.__t1), __t2(__in.__t2),
__t3(__in.__t3), __t4(__in.__t4), __t5(__in.__t5),
__t6(__in.__t6), __t7(__in.__t7), __t8(__in.__t8),
__t9(__in.__t9)
{ }
template <typename _U0, typename _U1, typename _U2, typename _U3,
typename _U4, typename _U5, typename _U6, typename _U7,
typename _U8, typename _U9>
tuple(const tuple<_U0, _U1, _U2, _U3, _U4, _U5, _U6, _U7, _U8,
_U9>& __in):
__t0(__in.__t0), __t1(__in.__t1), __t2(__in.__t2),
__t3(__in.__t3), __t4(__in.__t4), __t5(__in.__t5),
__t6(__in.__t6), __t7(__in.__t7), __t8(__in.__t8),
__t9(__in.__t9)
{ }
tuple& operator=(const tuple& __in)
{
__t0=__in.__t0;
__t1=__in.__t1;
__t2=__in.__t2;
__t3=__in.__t3;
__t4=__in.__t4;
__t5=__in.__t5;
__t6=__in.__t6;
__t7=__in.__t7;
__t8=__in.__t8;
__t9=__in.__t9;
return *this;
}
template <typename _U0, typename _U1, typename _U2, typename _U3,
typename _U4, typename _U5, typename _U6, typename _U7,
typename _U8, typename _U9>
tuple&
operator=(const tuple<_U0, _U1, _U2, _U3, _U4, _U5, _U6, _U7,
_U8, _U9>& __in)
{
__t0=__in.__t0;
__t1=__in.__t1;
__t2=__in.__t2;
__t3=__in.__t3;
__t4=__in.__t4;
__t5=__in.__t5;
__t6=__in.__t6;
__t7=__in.__t7;
__t8=__in.__t8;
__t9=__in.__t9;
return *this;
}
template<int __i, typename _U>
friend class __get_helper;
template<typename, typename, typename, typename, typename, typename,
typename, typename, typename, typename>
friend class tuple;
};
// Class used in the implementation of get
template<int __i,typename _T>
struct __get_helper;
template<typename _T>
struct __get_helper<0,_T>
{
static typename __add_ref<typename tuple_element<0,_T>::type>::type
get_value(_T& __in)
{
return __in.__t0;
}
static typename __add_const_ref<typename tuple_element<0,_T>::type>::type
get_value(const _T& __in)
{
return __in.__t0;
}
};
template<typename _T>
struct __get_helper<1,_T>
{
static typename __add_ref<typename tuple_element<1,_T>::type>::type
get_value(_T& __in)
{
return __in.__t1;
}
static typename __add_const_ref<typename tuple_element<1,_T>::type>::type
get_value(const _T& __in)
{
return __in.__t1;
}
};
template<typename _T>
struct __get_helper<2,_T>
{
static typename __add_ref<typename tuple_element<2,_T>::type>::type
get_value(_T& __in)
{
return __in.__t2;
}
static typename __add_const_ref<typename tuple_element<2,_T>::type>::type
get_value(const _T& __in)
{
return __in.__t2;
}
};
template<typename _T>
struct __get_helper<3,_T>
{
static typename __add_ref<typename tuple_element<3,_T>::type>::type
get_value(_T& __in)
{
return __in.__t3;
}
static typename __add_const_ref<typename tuple_element<3,_T>::type>::type
get_value(const _T& __in)
{
return __in.__t3;
}
};
template<typename _T>
struct __get_helper<4,_T>
{
static typename __add_ref<typename tuple_element<4,_T>::type>::type
get_value(_T& __in)
{
return __in.__t4;
}
static typename __add_const_ref<typename tuple_element<4,_T>::type>::type
get_value(const _T& __in)
{
return __in.__t4;
}
};
template<typename _T>
struct __get_helper<5,_T>
{
static typename __add_ref<typename tuple_element<5,_T>::type>::type
get_value(_T& __in)
{
return __in.__t5;
}
static typename __add_const_ref<typename tuple_element<5,_T>::type>::type
get_value(const _T& __in)
{
return __in.__t5;
}
};
template<typename _T>
struct __get_helper<6,_T>
{
static typename __add_ref<typename tuple_element<6,_T>::type>::type
get_value(_T& __in)
{
return __in.__t6;
}
static typename __add_const_ref<typename tuple_element<6,_T>::type>::type
get_value(const _T& __in)
{
return __in.__t6;
}
};
template<typename _T>
struct __get_helper<7,_T>
{
static typename __add_ref<typename tuple_element<7,_T>::type>::type
get_value(_T& __in)
{
return __in.__t7;
}
static typename __add_const_ref<typename tuple_element<7,_T>::type>::type
get_value(const _T& __in)
{
return __in.__t7;
}
};
template<typename _T>
struct __get_helper<8,_T>
{
static typename __add_ref<typename tuple_element<8,_T>::type>::type
get_value(_T& __in)
{
return __in.__t8;
}
static typename __add_const_ref<typename tuple_element<8,_T>::type>::type
get_value(const _T& __in)
{
return __in.__t8;
}
};
template<typename _T>
struct __get_helper<9,_T>
{
static typename __add_ref<typename tuple_element<9,_T>::type>::type
get_value(_T& __in)
{
return __in.__t9;
}
static typename __add_const_ref<typename tuple_element<9,_T>::type>::type
get_value(const _T& __in)
{
return __in.__t9;
}
};
/* Returns a reference to the ith element of a tuple.
* Any const or non-const ref elements are returned with their original type
*/
template<int __i, typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8, typename _T9>
typename __add_ref<typename tuple_element<__i,tuple<_T0, _T1, _T2, _T3,
_T4, _T5, _T6, _T7, _T8, _T9> >::type>::type
get(tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9>& __t)
{
return __get_helper<__i,tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6,
_T7, _T8, _T9> >::get_value(__t);
}
/* Returns a const reference to the ith element of a tuple.
* Any const or non-const ref elements are returned with their original type
*/
template<int __i, typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8, typename _T9>
typename __add_const_ref<typename tuple_element<__i,tuple<_T0, _T1, _T2,
_T3, _T4, _T5, _T6, _T7, _T8, _T9> >::type>::type
get(const tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9
>& __t)
{
return __get_helper<__i,tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6,
_T7, _T8, _T9> >::get_value(__t);
}
// This class helps construct the various comparison operations on tuples
template<int __check_equal_size, int __i, int __j, typename _T, typename _U>
struct __tuple_compare;
template<int __i, int __j, typename _T, typename _U>
struct __tuple_compare<0, __i, __j, _T, _U>
{
static bool __eq(const _T& __t, const _U& __u)
{
return get<__i>(__t) == get<__i>(__u) &&
__tuple_compare<0, __i+1, __j, _T, _U>::__eq(__t, __u) ;
}
static bool __neq(const _T& __t, const _U& __u)
{
return get<__i>(__t) != get<__i>(__u) ||
__tuple_compare<0, __i+1, __j, _T, _U>::__neq(__t, __u) ;
}
static bool __less(const _T& __t, const _U& __u)
{
return (get<__i>(__t) < get<__i>(__u)) || !(get<__i>(__u) < get<__i>(__t)) &&
__tuple_compare<0, __i+1, __j, _T, _U>::__less(__t, __u) ;
}
static bool __greater(const _T& __t, const _U& __u)
{
return (get<__i>(__t) > get<__i>(__u)) || !(get<__i>(__u) > get<__i>(__t)) &&
__tuple_compare<0, __i+1, __j, _T, _U>::__greater(__t, __u) ;
}
static bool __leq(const _T& __t, const _U& __u)
{
return (get<__i>(__t) <= get<__i>(__u)) && (!(get<__i>(__u)<=get<__i>(__t)) ||
__tuple_compare<0, __i+1, __j, _T, _U>::__leq(__t, __u) );
}
static bool __geq(const _T& __t, const _U& __u)
{
return (get<__i>(__t) >= get<__i>(__u)) && (!(get<__i>(__u)>=get<__i>(__t)) ||
__tuple_compare<0, __i+1, __j, _T, _U>::__geq(__t, __u) );
}
};
template<int __i, typename _T, typename _U>
struct __tuple_compare<0, __i, __i, _T, _U>
{
static bool __eq(const _T&, const _U&)
{
return true;
}
static bool __neq(const _T&, const _U&)
{
return false;
}
static bool __leq(const _T&, const _U&)
{
return true;
}
static bool __geq(const _T&, const _U&)
{
return true;
}
static bool __less(const _T&, const _U&)
{
return false;
}
static bool __greater(const _T&, const _U&)
{
return false;
}
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8, typename _T9, typename _U0, typename _U1,
typename _U2, typename _U3, typename _U4, typename _U5,
typename _U6, typename _U7, typename _U8, typename _U9>
bool
operator==(const tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8,
_T9>& __t, const tuple<_U0, _U1, _U2, _U3, _U4, _U5, _U6,
_U7, _U8, _U9>& __u)
{
typedef tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9
> __T_tuple;
typedef tuple<_U0, _U1, _U2, _U3, _U4, _U5, _U6, _U7, _U8, _U9
> __U_tuple;
return __tuple_compare<tuple_size<__T_tuple>::value -
tuple_size<__U_tuple>::value, 0,
tuple_size<__T_tuple>::value, __T_tuple, __U_tuple>::__eq(__t, __u);
}
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8, typename _T9, typename _U0, typename _U1,
typename _U2, typename _U3, typename _U4, typename _U5,
typename _U6, typename _U7, typename _U8, typename _U9>
bool
operator!=(const tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8,
_T9>& __t, const tuple<_U0, _U1, _U2, _U3, _U4, _U5, _U6,
_U7, _U8, _U9>& __u)
{
typedef tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9
> __T_tuple;
typedef tuple<_U0, _U1, _U2, _U3, _U4, _U5, _U6, _U7, _U8, _U9
> __U_tuple;
return __tuple_compare<tuple_size<__T_tuple>::value -
tuple_size<__U_tuple>::value, 0,
tuple_size<__T_tuple>::value, __T_tuple, __U_tuple>::__neq(__t, __u);
}
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8, typename _T9, typename _U0, typename _U1,
typename _U2, typename _U3, typename _U4, typename _U5,
typename _U6, typename _U7, typename _U8, typename _U9>
bool
operator<(const tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8,
_T9>& __t, const tuple<_U0, _U1, _U2, _U3, _U4, _U5, _U6,
_U7, _U8, _U9>& __u)
{
typedef tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9
> __T_tuple;
typedef tuple<_U0, _U1, _U2, _U3, _U4, _U5, _U6, _U7, _U8, _U9
> __U_tuple;
return __tuple_compare<tuple_size<__T_tuple>::value -
tuple_size<__U_tuple>::value, 0,
tuple_size<__T_tuple>::value, __T_tuple, __U_tuple>::__less(__t, __u);
}
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8, typename _T9, typename _U0, typename _U1,
typename _U2, typename _U3, typename _U4, typename _U5,
typename _U6, typename _U7, typename _U8, typename _U9>
bool
operator>(const tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8,
_T9>& __t, const tuple<_U0, _U1, _U2, _U3, _U4, _U5, _U6,
_U7, _U8, _U9>& __u)
{
typedef tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9
> __T_tuple;
typedef tuple<_U0, _U1, _U2, _U3, _U4, _U5, _U6, _U7, _U8, _U9
> __U_tuple;
return __tuple_compare<tuple_size<__T_tuple>::value -
tuple_size<__U_tuple>::value, 0,
tuple_size<__T_tuple>::value, __T_tuple, __U_tuple>::__greater(__t, __u);
}
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8, typename _T9, typename _U0, typename _U1,
typename _U2, typename _U3, typename _U4, typename _U5,
typename _U6, typename _U7, typename _U8, typename _U9>
bool
operator<=(const tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8,
_T9>& __t, const tuple<_U0, _U1, _U2, _U3, _U4, _U5, _U6,
_U7, _U8, _U9>& __u)
{
typedef tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9
> __T_tuple;
typedef tuple<_U0, _U1, _U2, _U3, _U4, _U5, _U6, _U7, _U8, _U9
> __U_tuple;
return __tuple_compare<tuple_size<__T_tuple>::value -
tuple_size<__U_tuple>::value, 0,
tuple_size<__T_tuple>::value, __T_tuple, __U_tuple>::__leq(__t, __u);
}
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8, typename _T9, typename _U0, typename _U1,
typename _U2, typename _U3, typename _U4, typename _U5,
typename _U6, typename _U7, typename _U8, typename _U9>
bool
operator>=(const tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8,
_T9>& __t, const tuple<_U0, _U1, _U2, _U3, _U4, _U5, _U6,
_U7, _U8, _U9>& __u)
{
typedef tuple<_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9
> __T_tuple;
typedef tuple<_U0, _U1, _U2, _U3, _U4, _U5, _U6, _U7, _U8, _U9
> __U_tuple;
return __tuple_compare<tuple_size<__T_tuple>::value -
tuple_size<__U_tuple>::value, 0,
tuple_size<__T_tuple>::value, __T_tuple, __U_tuple>::__geq(__t, __u);
}
/* reference_wrapper provides a way to annotate that a reference
* to an object should be passed
*/
template<typename _T>
class reference_wrapper
{
_T& __data;
public:
typedef _T type;
explicit reference_wrapper(_T& __indata): __data(__indata)
{ }
operator _T& () const
{
return this->get();
}
_T&
get() const
{
return __data;
}
};
// ref denotes a reference should be taken to a variable
template<typename _T>
reference_wrapper<_T>
ref(_T& __t)
{
return reference_wrapper<_T>(__t);
}
// cref denotes a const reference should be taken to a variable
template<typename _T>
reference_wrapper<_T const>
cref(const _T& __t)
{
return reference_wrapper<_T const>(__t);
}
// Helper which adds a reference to a type when given a reference_wrapper
template<typename _T>
struct __strip_reference_wrapper
{
typedef _T __type;
};
template<typename _T>
struct __strip_reference_wrapper<reference_wrapper<_T> >
{
typedef _T& __type;
};
template<typename _T>
struct __strip_reference_wrapper<const reference_wrapper<_T> >
{
typedef _T& __type;
};
template<typename _T0 = _NullClass, typename _T1 = _NullClass,
typename _T2 = _NullClass, typename _T3 = _NullClass,
typename _T4 = _NullClass, typename _T5 = _NullClass,
typename _T6 = _NullClass, typename _T7 = _NullClass,
typename _T8 = _NullClass, typename _T9 = _NullClass>
struct __stripped_tuple_type
{
typedef tuple<typename __strip_reference_wrapper<_T0>::__type,
typename __strip_reference_wrapper<_T1>::__type,
typename __strip_reference_wrapper<_T2>::__type,
typename __strip_reference_wrapper<_T3>::__type,
typename __strip_reference_wrapper<_T4>::__type,
typename __strip_reference_wrapper<_T5>::__type,
typename __strip_reference_wrapper<_T6>::__type,
typename __strip_reference_wrapper<_T7>::__type,
typename __strip_reference_wrapper<_T8>::__type,
typename __strip_reference_wrapper<_T9>::__type> __type;
};
tuple<>
make_tuple()
{
return tuple<>();
};
template<typename _T0>
typename __stripped_tuple_type<_T0>::__type
make_tuple(_T0 __t0)
{
return typename __stripped_tuple_type<_T0>:: __type(__t0);};
template<typename _T0, typename _T1>
typename __stripped_tuple_type<_T0, _T1>::__type
make_tuple(_T0 __t0, _T1 __t1)
{
return typename __stripped_tuple_type<_T0, _T1>:: __type(__t0, __t1);};
template<typename _T0, typename _T1, typename _T2>
typename __stripped_tuple_type<_T0, _T1, _T2>::__type
make_tuple(_T0 __t0, _T1 __t1, _T2 __t2)
{
return typename __stripped_tuple_type<_T0, _T1, _T2>:: __type(__t0, __t1, __t2);};
template<typename _T0, typename _T1, typename _T2, typename _T3>
typename __stripped_tuple_type<_T0, _T1, _T2, _T3>::__type
make_tuple(_T0 __t0, _T1 __t1, _T2 __t2, _T3 __t3)
{
return typename __stripped_tuple_type<_T0, _T1, _T2, _T3>:: __type(__t0, __t1, __t2, __t3);};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4>
typename __stripped_tuple_type<_T0, _T1, _T2, _T3, _T4>::__type
make_tuple(_T0 __t0, _T1 __t1, _T2 __t2, _T3 __t3, _T4 __t4)
{
return typename __stripped_tuple_type<_T0, _T1, _T2, _T3, _T4>:: __type(__t0, __t1, __t2, __t3, __t4);};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5>
typename __stripped_tuple_type<_T0, _T1, _T2, _T3, _T4, _T5>::__type
make_tuple(_T0 __t0, _T1 __t1, _T2 __t2, _T3 __t3, _T4 __t4,
_T5 __t5)
{
return typename __stripped_tuple_type<_T0, _T1, _T2, _T3, _T4, _T5
>:: __type(__t0, __t1, __t2, __t3, __t4, __t5);};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6>
typename __stripped_tuple_type<_T0, _T1, _T2, _T3, _T4, _T5, _T6
>::__type
make_tuple(_T0 __t0, _T1 __t1, _T2 __t2, _T3 __t3, _T4 __t4,
_T5 __t5, _T6 __t6)
{
return typename __stripped_tuple_type<_T0, _T1, _T2, _T3, _T4, _T5,
_T6>:: __type(__t0, __t1, __t2, __t3, __t4, __t5, __t6);};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7>
typename __stripped_tuple_type<_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7
>::__type
make_tuple(_T0 __t0, _T1 __t1, _T2 __t2, _T3 __t3, _T4 __t4,
_T5 __t5, _T6 __t6, _T7 __t7)
{
return typename __stripped_tuple_type<_T0, _T1, _T2, _T3, _T4, _T5,
_T6, _T7>:: __type(__t0, __t1, __t2, __t3, __t4, __t5, __t6, __t7);};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8>
typename __stripped_tuple_type<_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7,
_T8>::__type
make_tuple(_T0 __t0, _T1 __t1, _T2 __t2, _T3 __t3, _T4 __t4,
_T5 __t5, _T6 __t6, _T7 __t7, _T8 __t8)
{
return typename __stripped_tuple_type<_T0, _T1, _T2, _T3, _T4, _T5,
_T6, _T7, _T8>:: __type(__t0, __t1, __t2, __t3, __t4, __t5, __t6, __t7, __t8);};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8, typename _T9>
typename __stripped_tuple_type<_T0, _T1, _T2, _T3, _T4, _T5, _T6, _T7,
_T8, _T9>::__type
make_tuple(_T0 __t0, _T1 __t1, _T2 __t2, _T3 __t3, _T4 __t4,
_T5 __t5, _T6 __t6, _T7 __t7, _T8 __t8, _T9 __t9)
{
return typename __stripped_tuple_type<_T0, _T1, _T2, _T3, _T4, _T5,
_T6, _T7, _T8, _T9>:: __type(__t0, __t1, __t2, __t3, __t4, __t5, __t6, __t7, __t8, __t9
);};
/* A class (and instance) which can be used in 'tie' when a
* element is not required
*/
struct swallow_assign
{
template <class T>
swallow_assign&
operator=(const T&)
{
return *this;
}
};
extern swallow_assign ignore;
// tie allows forms a tuple of references to a list of variables
template<typename _T0>
tuple<_T0&>
tie(_T0& __t0)
{
return make_tuple(ref(__t0));
};
template<typename _T0, typename _T1>
tuple<_T0&, _T1&>
tie(_T0& __t0, _T1& __t1)
{
return make_tuple(ref(__t0), ref(__t1));
};
template<typename _T0, typename _T1, typename _T2>
tuple<_T0&, _T1&, _T2&>
tie(_T0& __t0, _T1& __t1, _T2& __t2)
{
return make_tuple(ref(__t0), ref(__t1), ref(__t2));
};
template<typename _T0, typename _T1, typename _T2, typename _T3>
tuple<_T0&, _T1&, _T2&, _T3&>
tie(_T0& __t0, _T1& __t1, _T2& __t2, _T3& __t3)
{
return make_tuple(ref(__t0), ref(__t1), ref(__t2), ref(__t3));
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4>
tuple<_T0&, _T1&, _T2&, _T3&, _T4&>
tie(_T0& __t0, _T1& __t1, _T2& __t2, _T3& __t3, _T4& __t4)
{
return make_tuple(ref(__t0), ref(__t1), ref(__t2), ref(__t3),
ref(__t4));
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5>
tuple<_T0&, _T1&, _T2&, _T3&, _T4&, _T5&>
tie(_T0& __t0, _T1& __t1, _T2& __t2, _T3& __t3, _T4& __t4,
_T5& __t5)
{
return make_tuple(ref(__t0), ref(__t1), ref(__t2), ref(__t3),
ref(__t4), ref(__t5));
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6>
tuple<_T0&, _T1&, _T2&, _T3&, _T4&, _T5&, _T6&>
tie(_T0& __t0, _T1& __t1, _T2& __t2, _T3& __t3, _T4& __t4,
_T5& __t5, _T6& __t6)
{
return make_tuple(ref(__t0), ref(__t1), ref(__t2), ref(__t3),
ref(__t4), ref(__t5), ref(__t6));
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7>
tuple<_T0&, _T1&, _T2&, _T3&, _T4&, _T5&, _T6&, _T7&>
tie(_T0& __t0, _T1& __t1, _T2& __t2, _T3& __t3, _T4& __t4,
_T5& __t5, _T6& __t6, _T7& __t7)
{
return make_tuple(ref(__t0), ref(__t1), ref(__t2), ref(__t3),
ref(__t4), ref(__t5), ref(__t6), ref(__t7));
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8>
tuple<_T0&, _T1&, _T2&, _T3&, _T4&, _T5&, _T6&, _T7&, _T8&>
tie(_T0& __t0, _T1& __t1, _T2& __t2, _T3& __t3, _T4& __t4,
_T5& __t5, _T6& __t6, _T7& __t7, _T8& __t8)
{
return make_tuple(ref(__t0), ref(__t1), ref(__t2), ref(__t3),
ref(__t4), ref(__t5), ref(__t6), ref(__t7), ref(__t8));
};
template<typename _T0, typename _T1, typename _T2, typename _T3,
typename _T4, typename _T5, typename _T6, typename _T7,
typename _T8, typename _T9>
tuple<_T0&, _T1&, _T2&, _T3&, _T4&, _T5&, _T6&, _T7&, _T8&, _T9&>
tie(_T0& __t0, _T1& __t1, _T2& __t2, _T3& __t3, _T4& __t4,
_T5& __t5, _T6& __t6, _T7& __t7, _T8& __t8, _T9& __t9)
{
return make_tuple(ref(__t0), ref(__t1), ref(__t2), ref(__t3),
ref(__t4), ref(__t5), ref(__t6), ref(__t7), ref(__t8),
ref(__t9));
};
// Various functions which give std::pair a tuple-like interface
template<class _T1, class _T2>
struct tuple_size<std::pair<_T1, _T2> >
{
static const int value = 2;
};
template<class _T1, class _T2>
struct tuple_element<0, std::pair<_T1, _T2> >
{
typedef _T1 type;
};
template<class _T1, class _T2>
struct tuple_element<1, std::pair<_T1, _T2> >
{
typedef _T2 type;
};
template<int _I,class _T1,class _T2>
typename tuple_element<_I,tuple<_T1, _T2> >::type
get(pair<_T1, _T2>& __in)
{
return get<_I>(tie(__in.first, __in.second));
}
template<int _I,class _T1,class _T2>
typename tuple_element<_I,tuple<_T1, _T2> >::type
get(const pair<_T1, _T2>& __in)
{
return get<_I>(tie(__in.first, __in.second));
}
// TODO: Put this in some kind of shared file
swallow_assign ignore;
}
}