boost/fusion/container/vector/detail/vector_n.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 // No include guard. This file is meant to be included many times
   8
   9 #if !defined(FUSION_MACRO_05042005)
  10 #define FUSION_MACRO_05042005
  11
  12 #define FUSION_VECTOR_CTOR_DEFAULT_INIT(z, n, _)                                \
  13     m##n()
  14
  15 #define FUSION_VECTOR_CTOR_INIT(z, n, _)                                        \
  16     m##n(_##n)
  17
  18 #define FUSION_VECTOR_MEMBER_CTOR_INIT(z, n, _)                                 \
  19     m##n(other.m##n)
  20
  21 #define FUSION_VECTOR_CTOR_FORWARD(z, n, _)                                     \
  22    m##n(std::forward<T##n>(other.m##n))
  23
  24 #define FUSION_VECTOR_CTOR_ARG_FWD(z, n, _)                                     \
  25    m##n(std::forward<U##n>(_##n))
  26
  27 #define FUSION_VECTOR_MEMBER_DECL(z, n, _)                                      \
  28     T##n m##n;
  29
  30 #define FUSION_VECTOR_MEMBER_FORWARD(z, n, _)                                   \
  31    std::forward<U##n>(_##n)
  32
  33 #define FUSION_VECTOR_MEMBER_ASSIGN(z, n, _)                                    \
  34     this->BOOST_PP_CAT(m, n) = vec.BOOST_PP_CAT(m, n);
  35
  36 #define FUSION_VECTOR_MEMBER_DEREF_ASSIGN(z, n, _)                              \
  37     this->BOOST_PP_CAT(m, n) = *BOOST_PP_CAT(i, n);
  38
  39 #define FUSION_VECTOR_MEMBER_MOVE(z, n, _)                                      \
  40     this->BOOST_PP_CAT(m, n) = std::forward<                                    \
  41         BOOST_PP_CAT(T, n)>(vec.BOOST_PP_CAT(m, n));
  42
  43 #define FUSION_VECTOR_MEMBER_AT_IMPL(z, n, _)                                   \
  44     typename add_reference<T##n>::type                                          \
  45         at_impl(mpl::int_<n>) { return this->m##n; }                            \
  46     typename add_reference<typename add_const<T##n>::type>::type                \
  47         at_impl(mpl::int_<n>) const { return this->m##n; }
  48
  49 #define FUSION_VECTOR_MEMBER_ITER_DECL_VAR(z, n, _)                             \
  50     typedef typename result_of::next<                                           \
  51         BOOST_PP_CAT(I, BOOST_PP_DEC(n))>::type BOOST_PP_CAT(I, n);             \
  52     BOOST_PP_CAT(I, n) BOOST_PP_CAT(i, n)                                       \
  53         = fusion::next(BOOST_PP_CAT(i, BOOST_PP_DEC(n)));
  54
  55 #endif
  56
  57 #define N BOOST_PP_ITERATION()
  58
  59     template <BOOST_PP_ENUM_PARAMS(N, typename T)>
  60     struct BOOST_PP_CAT(vector_data, N)
  61     {
  62         BOOST_PP_CAT(vector_data, N)()
  63             : BOOST_PP_ENUM(N, FUSION_VECTOR_CTOR_DEFAULT_INIT, _) {}
  64
  65 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
  66         template <BOOST_PP_ENUM_PARAMS(N, typename U)>
  67         BOOST_PP_CAT(vector_data, N)(BOOST_PP_ENUM_BINARY_PARAMS(N, U, && _)
  68           , typename boost::enable_if<is_convertible<U0, T0> >::type* /*dummy*/ = 0
  69         )
  70             : BOOST_PP_ENUM(N, FUSION_VECTOR_CTOR_ARG_FWD, _) {}
  71 #endif
  72
  73         BOOST_PP_CAT(vector_data, N)(
  74             BOOST_PP_ENUM_BINARY_PARAMS(
  75                 N, typename detail::call_param<T, >::type _))
  76             : BOOST_PP_ENUM(N, FUSION_VECTOR_CTOR_INIT, _) {}
  77
  78         BOOST_PP_CAT(vector_data, N)(
  79             BOOST_PP_CAT(vector_data, N) const& other)
  80             : BOOST_PP_ENUM(N, FUSION_VECTOR_MEMBER_CTOR_INIT, _) {}
  81
  82 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
  83         BOOST_PP_CAT(vector_data, N)(
  84             BOOST_PP_CAT(vector_data, N)&& other)
  85             : BOOST_PP_ENUM(N, FUSION_VECTOR_CTOR_FORWARD, _) {}
  86 #endif
  87
  88         BOOST_PP_CAT(vector_data, N)&
  89         operator=(BOOST_PP_CAT(vector_data, N) const& vec)
  90         {
  91             BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_ASSIGN, _)
  92             return *this;
  93         }
  94
  95         template <typename Sequence>
  96         static BOOST_PP_CAT(vector_data, N)
  97         init_from_sequence(Sequence const& seq)
  98         {
  99             typedef typename result_of::begin<Sequence const>::type I0;
 100             I0 i0 = fusion::begin(seq);
 101             BOOST_PP_REPEAT_FROM_TO(1, N, FUSION_VECTOR_MEMBER_ITER_DECL_VAR, _)
 102             return BOOST_PP_CAT(vector_data, N)(BOOST_PP_ENUM_PARAMS(N, *i));
 103         }
 104
 105         template <typename Sequence>
 106         static BOOST_PP_CAT(vector_data, N)
 107         init_from_sequence(Sequence& seq)
 108         {
 109             typedef typename result_of::begin<Sequence>::type I0;
 110             I0 i0 = fusion::begin(seq);
 111             BOOST_PP_REPEAT_FROM_TO(1, N, FUSION_VECTOR_MEMBER_ITER_DECL_VAR, _)
 112             return BOOST_PP_CAT(vector_data, N)(BOOST_PP_ENUM_PARAMS(N, *i));
 113         }
 114
 115         BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_DECL, _)
 116     };
 117
 118     template <BOOST_PP_ENUM_PARAMS(N, typename T)>
 119     struct BOOST_PP_CAT(vector, N)
 120       : BOOST_PP_CAT(vector_data, N)<BOOST_PP_ENUM_PARAMS(N, T)>
 121       , sequence_base<BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, T)> >
 122     {
 123         typedef BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, T)> this_type;
 124         typedef BOOST_PP_CAT(vector_data, N)<BOOST_PP_ENUM_PARAMS(N, T)> base_type;
 125         typedef mpl::BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, T)> types;
 126         typedef vector_tag fusion_tag;
 127         typedef fusion_sequence_tag tag; // this gets picked up by MPL
 128         typedef mpl::false_ is_view;
 129         typedef random_access_traversal_tag category;
 130         typedef mpl::int_<N> size;
 131
 132         BOOST_PP_CAT(vector, N)() {}
 133
 134 #if (N == 1)
 135         explicit
 136 #endif
 137         BOOST_PP_CAT(vector, N)(
 138             BOOST_PP_ENUM_BINARY_PARAMS(
 139                 N, typename detail::call_param<T, >::type _))
 140             : base_type(BOOST_PP_ENUM_PARAMS(N, _)) {}
 141
 142 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 143     template <BOOST_PP_ENUM_PARAMS(N, typename U)>
 144 #if (N == 1)
 145         explicit
 146         BOOST_PP_CAT(vector, N)(U0&& _0
 147           , typename boost::enable_if<is_convertible<U0, T0> >::type* /*dummy*/ = 0
 148           )
 149          : base_type(std::forward<U0>(_0)) {}
 150 #else
 151         BOOST_PP_CAT(vector, N)(BOOST_PP_ENUM_BINARY_PARAMS(N, U, && _))
 152             : base_type(BOOST_PP_ENUM(N, FUSION_VECTOR_MEMBER_FORWARD, _)) {}
 153 #endif
 154
 155         BOOST_PP_CAT(vector, N)(BOOST_PP_CAT(vector, N)&& rhs)
 156             : base_type(std::forward<base_type>(rhs)) {}
 157
 158         BOOST_PP_CAT(vector, N)(BOOST_PP_CAT(vector, N) const& rhs)
 159             : base_type(rhs) {}
 160
 161 #endif
 162
 163         template <BOOST_PP_ENUM_PARAMS(N, typename U)>
 164         BOOST_PP_CAT(vector, N)(
 165             BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, U)> const& vec)
 166             : base_type(BOOST_PP_ENUM_PARAMS(N, vec.m)) {}
 167
 168         template <typename Sequence>
 169         BOOST_PP_CAT(vector, N)(
 170             Sequence const& seq
 171 #if (N == 1)
 172           , typename boost::disable_if<is_convertible<Sequence, T0> >::type* /*dummy*/ = 0
 173 #endif
 174             )
 175             : base_type(base_type::init_from_sequence(seq)) {}
 176
 177         template <typename Sequence>
 178         BOOST_PP_CAT(vector, N)(
 179             Sequence& seq
 180 #if (N == 1)
 181           , typename boost::disable_if<is_convertible<Sequence, T0> >::type* /*dummy*/ = 0
 182 #endif
 183             )
 184             : base_type(base_type::init_from_sequence(seq)) {}
 185
 186         template <BOOST_PP_ENUM_PARAMS(N, typename U)>
 187         BOOST_PP_CAT(vector, N)&
 188         operator=(BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, U)> const& vec)
 189         {
 190             BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_ASSIGN, _)
 191             return *this;
 192         }
 193
 194         template <typename Sequence>
 195         typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
 196         operator=(Sequence const& seq)
 197         {
 198             typedef typename result_of::begin<Sequence const>::type I0;
 199             I0 i0 = fusion::begin(seq);
 200             BOOST_PP_REPEAT_FROM_TO(1, N, FUSION_VECTOR_MEMBER_ITER_DECL_VAR, _)
 201             BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_DEREF_ASSIGN, _)
 202             return *this;
 203         }
 204
 205 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
 206         BOOST_PP_CAT(vector, N)&
 207         operator=(BOOST_PP_CAT(vector, N) const& vec)
 208         {
 209             base_type::operator=(vec);
 210             return *this;
 211         }
 212
 213         BOOST_PP_CAT(vector, N)&
 214         operator=(BOOST_PP_CAT(vector, N)&& vec)
 215         {
 216             BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_MOVE, _)
 217             return *this;
 218         }
 219 #endif
 220
 221         BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_AT_IMPL, _)
 222
 223         template<typename I>
 224         typename add_reference<typename mpl::at<types, I>::type>::type
 225         at_impl(I)
 226         {
 227             return this->at_impl(mpl::int_<I::value>());
 228         }
 229
 230         template<typename I>
 231         typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
 232         at_impl(I) const
 233         {
 234             return this->at_impl(mpl::int_<I::value>());
 235         }
 236     };
 237
 238 #undef N
 239
 240