boost/fusion/tuple/detail/preprocessed/tuple10.hpp

   1 /*=============================================================================
   2     Copyright (c) 2001-2011 Joel de Guzman
   3
   4     Distributed under the Boost Software License, Version 1.0. (See accompanying
   5     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   6
   7     This is an auto-generated file. Do not edit!
   8 ==============================================================================*/
   9 namespace boost { namespace fusion
  10 {
  11     template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
  12     struct tuple : vector<T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
  13     {
  14         typedef vector<
  15             T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9>
  16         base_type;
  17         tuple()
  18             : base_type() {}
  19         tuple(tuple const& rhs)
  20             : base_type(rhs) {}
  21         template <typename U1, typename U2>
  22         tuple(std::pair<U1, U2> const& rhs)
  23             : base_type(rhs) {}
  24     explicit
  25     tuple(typename detail::call_param<T0 >::type _0)
  26         : base_type(_0) {}
  27     template <typename U0>
  28     tuple(tuple<U0> const& rhs)
  29         : base_type(rhs) {}
  30     template <typename U0>
  31     tuple& operator=(tuple<U0> const& rhs)
  32     {
  33         base_type::operator=(rhs);
  34         return *this;
  35     }
  36     tuple(typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1)
  37         : base_type(_0 , _1) {}
  38     template <typename U0 , typename U1>
  39     tuple(tuple<U0 , U1> const& rhs)
  40         : base_type(rhs) {}
  41     template <typename U0 , typename U1>
  42     tuple& operator=(tuple<U0 , U1> const& rhs)
  43     {
  44         base_type::operator=(rhs);
  45         return *this;
  46     }
  47     tuple(typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2)
  48         : base_type(_0 , _1 , _2) {}
  49     template <typename U0 , typename U1 , typename U2>
  50     tuple(tuple<U0 , U1 , U2> const& rhs)
  51         : base_type(rhs) {}
  52     template <typename U0 , typename U1 , typename U2>
  53     tuple& operator=(tuple<U0 , U1 , U2> const& rhs)
  54     {
  55         base_type::operator=(rhs);
  56         return *this;
  57     }
  58     tuple(typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3)
  59         : base_type(_0 , _1 , _2 , _3) {}
  60     template <typename U0 , typename U1 , typename U2 , typename U3>
  61     tuple(tuple<U0 , U1 , U2 , U3> const& rhs)
  62         : base_type(rhs) {}
  63     template <typename U0 , typename U1 , typename U2 , typename U3>
  64     tuple& operator=(tuple<U0 , U1 , U2 , U3> const& rhs)
  65     {
  66         base_type::operator=(rhs);
  67         return *this;
  68     }
  69     tuple(typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4)
  70         : base_type(_0 , _1 , _2 , _3 , _4) {}
  71     template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4>
  72     tuple(tuple<U0 , U1 , U2 , U3 , U4> const& rhs)
  73         : base_type(rhs) {}
  74     template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4>
  75     tuple& operator=(tuple<U0 , U1 , U2 , U3 , U4> const& rhs)
  76     {
  77         base_type::operator=(rhs);
  78         return *this;
  79     }
  80     tuple(typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4 , typename detail::call_param<T5 >::type _5)
  81         : base_type(_0 , _1 , _2 , _3 , _4 , _5) {}
  82     template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5>
  83     tuple(tuple<U0 , U1 , U2 , U3 , U4 , U5> const& rhs)
  84         : base_type(rhs) {}
  85     template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5>
  86     tuple& operator=(tuple<U0 , U1 , U2 , U3 , U4 , U5> const& rhs)
  87     {
  88         base_type::operator=(rhs);
  89         return *this;
  90     }
  91     tuple(typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4 , typename detail::call_param<T5 >::type _5 , typename detail::call_param<T6 >::type _6)
  92         : base_type(_0 , _1 , _2 , _3 , _4 , _5 , _6) {}
  93     template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6>
  94     tuple(tuple<U0 , U1 , U2 , U3 , U4 , U5 , U6> const& rhs)
  95         : base_type(rhs) {}
  96     template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6>
  97     tuple& operator=(tuple<U0 , U1 , U2 , U3 , U4 , U5 , U6> const& rhs)
  98     {
  99         base_type::operator=(rhs);
 100         return *this;
 101     }
 102     tuple(typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4 , typename detail::call_param<T5 >::type _5 , typename detail::call_param<T6 >::type _6 , typename detail::call_param<T7 >::type _7)
 103         : base_type(_0 , _1 , _2 , _3 , _4 , _5 , _6 , _7) {}
 104     template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7>
 105     tuple(tuple<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7> const& rhs)
 106         : base_type(rhs) {}
 107     template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7>
 108     tuple& operator=(tuple<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7> const& rhs)
 109     {
 110         base_type::operator=(rhs);
 111         return *this;
 112     }
 113     tuple(typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4 , typename detail::call_param<T5 >::type _5 , typename detail::call_param<T6 >::type _6 , typename detail::call_param<T7 >::type _7 , typename detail::call_param<T8 >::type _8)
 114         : base_type(_0 , _1 , _2 , _3 , _4 , _5 , _6 , _7 , _8) {}
 115     template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8>
 116     tuple(tuple<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8> const& rhs)
 117         : base_type(rhs) {}
 118     template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8>
 119     tuple& operator=(tuple<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8> const& rhs)
 120     {
 121         base_type::operator=(rhs);
 122         return *this;
 123     }
 124     tuple(typename detail::call_param<T0 >::type _0 , typename detail::call_param<T1 >::type _1 , typename detail::call_param<T2 >::type _2 , typename detail::call_param<T3 >::type _3 , typename detail::call_param<T4 >::type _4 , typename detail::call_param<T5 >::type _5 , typename detail::call_param<T6 >::type _6 , typename detail::call_param<T7 >::type _7 , typename detail::call_param<T8 >::type _8 , typename detail::call_param<T9 >::type _9)
 125         : base_type(_0 , _1 , _2 , _3 , _4 , _5 , _6 , _7 , _8 , _9) {}
 126     template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9>
 127     tuple(tuple<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9> const& rhs)
 128         : base_type(rhs) {}
 129     template <typename U0 , typename U1 , typename U2 , typename U3 , typename U4 , typename U5 , typename U6 , typename U7 , typename U8 , typename U9>
 130     tuple& operator=(tuple<U0 , U1 , U2 , U3 , U4 , U5 , U6 , U7 , U8 , U9> const& rhs)
 131     {
 132         base_type::operator=(rhs);
 133         return *this;
 134     }
 135         template <typename T>
 136         tuple& operator=(T const& rhs)
 137         {
 138             base_type::operator=(rhs);
 139             return *this;
 140         }
 141         tuple& operator=(tuple const& rhs)
 142         {
 143             base_type::operator=(rhs);
 144             return *this;
 145         }
 146         template <typename U1, typename U2>
 147         tuple& operator=(std::pair<U1, U2> const& rhs)
 148         {
 149             base_type::operator=(rhs);
 150             return *this;
 151         }
 152     };
 153     template <typename Tuple>
 154     struct tuple_size : result_of::size<Tuple> {};
 155     template <int N, typename Tuple>
 156     struct tuple_element : result_of::value_at_c<Tuple, N> {};
 157     template <int N, typename Tuple>
 158     inline typename
 159         lazy_disable_if<
 160             is_const<Tuple>
 161           , result_of::at_c<Tuple, N>
 162         >::type
 163     get(Tuple& tup)
 164     {
 165         return at_c<N>(tup);
 166     }
 167     template <int N, typename Tuple>
 168     inline typename result_of::at_c<Tuple const, N>::type
 169     get(Tuple const& tup)
 170     {
 171         return at_c<N>(tup);
 172     }
 173 }}