text: /*=============================================================================
      Copyright (c) 2001-2011 Joel de Guzman
  
      Distributed under the Boost Software License, Version 1.0. (See accompanying
      file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  ==============================================================================*/
  // No include guard. This file is meant to be included many times
  
  #if !defined(FUSION_MACRO_05042005)
  #define FUSION_MACRO_05042005
  
  #define FUSION_VECTOR_CTOR_DEFAULT_INIT(z, n, _)                                \
      m##n()
  
  #define FUSION_VECTOR_CTOR_INIT(z, n, _)                                        \
      m##n(_##n)
  
  #define FUSION_VECTOR_MEMBER_CTOR_INIT(z, n, _)                                 \
      m##n(other.m##n)
  
  #define FUSION_VECTOR_CTOR_FORWARD(z, n, _)                                     \
     m##n(BOOST_FUSION_FWD_ELEM(T##n, other.m##n))
  
  #define FUSION_VECTOR_CTOR_ARG_FWD(z, n, _)                                     \
     m##n(BOOST_FUSION_FWD_ELEM(U##n, _##n))
  
  #define FUSION_VECTOR_MEMBER_DECL(z, n, _)                                      \
      T##n m##n;
  
  #define FUSION_VECTOR_MEMBER_FORWARD(z, n, _)                                   \
     BOOST_FUSION_FWD_ELEM(U##n, _##n)
  
  #define FUSION_VECTOR_MEMBER_ASSIGN(z, n, _)                                    \
      this->BOOST_PP_CAT(m, n) = vec.BOOST_PP_CAT(m, n);
  
  #define FUSION_VECTOR_MEMBER_DEREF_ASSIGN(z, n, _)                              \
      this->BOOST_PP_CAT(m, n) = *BOOST_PP_CAT(i, n);
  
  #define FUSION_VECTOR_MEMBER_MOVE(z, n, _)                                      \
      this->BOOST_PP_CAT(m, n) = std::forward<                                    \
          BOOST_PP_CAT(T, n)>(vec.BOOST_PP_CAT(m, n));
  
  #define FUSION_VECTOR_MEMBER_AT_IMPL(z, n, _)                                   \
      BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED                              \
          typename add_reference<T##n>::type                                      \
          at_impl(mpl::int_<n>) { return this->m##n; }                            \
      BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED                                    \
          typename add_reference<typename add_const<T##n>::type>::type            \
          at_impl(mpl::int_<n>) const { return this->m##n; }
  
  #define FUSION_VECTOR_MEMBER_ITER_DECL_VAR(z, n, _)                             \
      typedef typename result_of::next<                                           \
          BOOST_PP_CAT(I, BOOST_PP_DEC(n))>::type BOOST_PP_CAT(I, n);             \
      BOOST_PP_CAT(I, n) BOOST_PP_CAT(i, n)                                       \
          = fusion::next(BOOST_PP_CAT(i, BOOST_PP_DEC(n)));
  
  #endif
  
  #define N BOOST_PP_ITERATION()
  
      template <BOOST_PP_ENUM_PARAMS(N, typename T)>
      struct BOOST_PP_CAT(vector_data, N)
      {
          BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
          BOOST_PP_CAT(vector_data, N)()
              : BOOST_PP_ENUM(N, FUSION_VECTOR_CTOR_DEFAULT_INIT, _) {}
  
  #if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
  FUSION_HASH if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
  #endif
  #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || \
      (defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES))
          template <BOOST_PP_ENUM_PARAMS(N, typename U)>
  #if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
  FUSION_HASH if !defined(BOOST_CLANG)
          BOOST_CXX14_CONSTEXPR
  FUSION_HASH endif
  #else
  #if !defined(BOOST_CLANG)
          BOOST_CXX14_CONSTEXPR
  #endif
  #endif
          BOOST_FUSION_GPU_ENABLED
          BOOST_PP_CAT(vector_data, N)(BOOST_PP_ENUM_BINARY_PARAMS(N, U, && arg)
            , typename boost::enable_if<is_convertible<U0, T0> >::type* /*dummy*/ = 0
          )
              : BOOST_PP_ENUM(N, FUSION_VECTOR_CTOR_ARG_FWD, arg) {}
  
          BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
          BOOST_PP_CAT(vector_data, N)(
              BOOST_PP_CAT(vector_data, N)&& other)
              : BOOST_PP_ENUM(N, FUSION_VECTOR_CTOR_FORWARD, arg) {}
  #endif
  #if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
  FUSION_HASH endif
  #endif
  
  #if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
  FUSION_HASH if !defined(BOOST_CLANG)
      BOOST_CONSTEXPR
  FUSION_HASH endif
  #else
  #if !defined(BOOST_CLANG)
      BOOST_CONSTEXPR
  #endif
  #endif
          BOOST_FUSION_GPU_ENABLED
          BOOST_PP_CAT(vector_data, N)(
              BOOST_PP_ENUM_BINARY_PARAMS(
                  N, typename detail::call_param<T, >::type arg))
              : BOOST_PP_ENUM(N, FUSION_VECTOR_CTOR_INIT, arg) {}
  
          BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
          BOOST_PP_CAT(vector_data, N)(
              BOOST_PP_CAT(vector_data, N) const& other)
              : BOOST_PP_ENUM(N, FUSION_VECTOR_MEMBER_CTOR_INIT, _) {}
  
          BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
          BOOST_PP_CAT(vector_data, N)&
          operator=(BOOST_PP_CAT(vector_data, N) const& vec)
          {
              BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_ASSIGN, _)
              return *this;
          }
  
          template <typename Sequence>
  #if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
  FUSION_HASH if !defined(BOOST_CLANG)
      BOOST_CXX14_CONSTEXPR
  FUSION_HASH endif
  #else
  #if !defined(BOOST_CLANG)
      BOOST_CXX14_CONSTEXPR
  #endif
  #endif
          BOOST_FUSION_GPU_ENABLED
          static BOOST_PP_CAT(vector_data, N)
          init_from_sequence(Sequence const& seq)
          {
              typedef typename result_of::begin<Sequence const>::type I0;
              I0 i0 = fusion::begin(seq);
              BOOST_PP_REPEAT_FROM_TO(1, N, FUSION_VECTOR_MEMBER_ITER_DECL_VAR, _)
              return BOOST_PP_CAT(vector_data, N)(BOOST_PP_ENUM_PARAMS(N, *i));
          }
  
          template <typename Sequence>
  #if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
  FUSION_HASH if !defined(BOOST_CLANG)
      BOOST_CXX14_CONSTEXPR
  FUSION_HASH endif
  #else
  #if !defined(BOOST_CLANG)
      BOOST_CXX14_CONSTEXPR
  #endif
  #endif
          BOOST_FUSION_GPU_ENABLED
          static BOOST_PP_CAT(vector_data, N)
          init_from_sequence(Sequence& seq)
          {
              typedef typename result_of::begin<Sequence>::type I0;
              I0 i0 = fusion::begin(seq);
              BOOST_PP_REPEAT_FROM_TO(1, N, FUSION_VECTOR_MEMBER_ITER_DECL_VAR, _)
              return BOOST_PP_CAT(vector_data, N)(BOOST_PP_ENUM_PARAMS(N, *i));
          }
  
          BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_DECL, _)
      };
  
      template <BOOST_PP_ENUM_PARAMS(N, typename T)>
      struct BOOST_PP_CAT(vector, N)
        : BOOST_PP_CAT(vector_data, N)<BOOST_PP_ENUM_PARAMS(N, T)>
        , sequence_base<BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, T)> >
      {
          typedef BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, T)> this_type;
          typedef BOOST_PP_CAT(vector_data, N)<BOOST_PP_ENUM_PARAMS(N, T)> base_type;
          typedef mpl::BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, T)> types;
          typedef vector_tag fusion_tag;
          typedef fusion_sequence_tag tag; // this gets picked up by MPL
          typedef mpl::false_ is_view;
          typedef random_access_traversal_tag category;
          typedef mpl::int_<N> size;
  
          BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
          BOOST_PP_CAT(vector, N)() {}
  
  #if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
  FUSION_HASH if !defined(BOOST_CLANG)
      BOOST_CONSTEXPR
  FUSION_HASH endif
  #else
  #if !defined(BOOST_CLANG)
      BOOST_CONSTEXPR
  #endif
  #endif
          BOOST_FUSION_GPU_ENABLED
  #if (N == 1)
          explicit
  #endif
          BOOST_PP_CAT(vector, N)(
              BOOST_PP_ENUM_BINARY_PARAMS(
                  N, typename detail::call_param<T, >::type arg))
              : base_type(BOOST_PP_ENUM_PARAMS(N, arg)) {}
  
  #if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
  FUSION_HASH if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
  #endif
  #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || \
      (defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES))
          template <BOOST_PP_ENUM_PARAMS(N, typename U)>
  #if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
  FUSION_HASH if !defined(BOOST_CLANG)
          BOOST_CXX14_CONSTEXPR
  FUSION_HASH endif
  #else
  #if !defined(BOOST_CLANG)
          BOOST_CXX14_CONSTEXPR
  #endif
  #endif
          BOOST_FUSION_GPU_ENABLED
  #if (N == 1)
          explicit
          BOOST_PP_CAT(vector, N)(U0&& _0
            , typename boost::enable_if<is_convertible<U0, T0> >::type* /*dummy*/ = 0
            )
           : base_type(BOOST_FUSION_FWD_ELEM(U0, _0)) {}
  #else
          BOOST_PP_CAT(vector, N)(BOOST_PP_ENUM_BINARY_PARAMS(N, U, && arg))
              : base_type(BOOST_PP_ENUM(N, FUSION_VECTOR_MEMBER_FORWARD, arg)) {}
  #endif
  
          BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
          BOOST_PP_CAT(vector, N)(BOOST_PP_CAT(vector, N)&& rhs)
              : base_type(std::forward<base_type>(rhs)) {}
  
          BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
          BOOST_PP_CAT(vector, N)(BOOST_PP_CAT(vector, N) const& rhs)
              : base_type(static_cast<base_type const&>(rhs)) {}
  
          BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
          BOOST_PP_CAT(vector, N)&
          operator=(BOOST_PP_CAT(vector, N) const& vec)
          {
              base_type::operator=(vec);
              return *this;
          }
  
          BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
          BOOST_PP_CAT(vector, N)&
          operator=(BOOST_PP_CAT(vector, N)&& vec)
          {
              BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_MOVE, _)
              return *this;
          }
  #endif
  #if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
  FUSION_HASH endif
  #endif
  
          template <BOOST_PP_ENUM_PARAMS(N, typename U)>
  #if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
  FUSION_HASH if !defined(BOOST_CLANG)
      BOOST_CXX14_CONSTEXPR
  FUSION_HASH endif
  #else
  #if !defined(BOOST_CLANG)
      BOOST_CXX14_CONSTEXPR
  #endif
  #endif
          BOOST_FUSION_GPU_ENABLED
          BOOST_PP_CAT(vector, N)(
              BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, U)> const& vec)
              : base_type(BOOST_PP_ENUM_PARAMS(N, vec.m)) {}
  
          template <typename Sequence>
  #if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
  FUSION_HASH if !defined(BOOST_CLANG)
          BOOST_CXX14_CONSTEXPR
  FUSION_HASH endif
  #else
  #if !defined(BOOST_CLANG)
          BOOST_CXX14_CONSTEXPR
  #endif
  #endif
          BOOST_FUSION_GPU_ENABLED
          BOOST_PP_CAT(vector, N)(
              Sequence const& seq
            , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
  #if (N == 1)
            , typename boost::disable_if<is_convertible<Sequence, T0> >::type* /*dummy*/ = 0
  #endif
              )
              : base_type(base_type::init_from_sequence(seq)) {}
  
          template <typename Sequence>
  #if defined(__WAVE__) && defined(BOOST_FUSION_CREATE_PREPROCESSED_FILES)
  FUSION_HASH if !defined(BOOST_CLANG)
          BOOST_CXX14_CONSTEXPR
  FUSION_HASH endif
  #else
  #if !defined(BOOST_CLANG)
          BOOST_CXX14_CONSTEXPR
  #endif
  #endif
          BOOST_FUSION_GPU_ENABLED
          BOOST_PP_CAT(vector, N)(
              Sequence& seq
            , typename boost::enable_if<traits::is_sequence<Sequence> >::type* = 0
  #if (N == 1)
            , typename boost::disable_if<is_convertible<Sequence, T0> >::type* /*dummy*/ = 0
  #endif
              )
              : base_type(base_type::init_from_sequence(seq)) {}
  
          template <BOOST_PP_ENUM_PARAMS(N, typename U)>
          BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
          BOOST_PP_CAT(vector, N)&
          operator=(BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM_PARAMS(N, U)> const& vec)
          {
              BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_ASSIGN, _)
              return *this;
          }
  
          template <typename Sequence>
          BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
          typename boost::disable_if<is_convertible<Sequence, T0>, this_type&>::type
          operator=(Sequence const& seq)
          {
              typedef typename result_of::begin<Sequence const>::type I0;
              I0 i0 = fusion::begin(seq);
              BOOST_PP_REPEAT_FROM_TO(1, N, FUSION_VECTOR_MEMBER_ITER_DECL_VAR, _)
              BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_DEREF_ASSIGN, _)
              return *this;
          }
  
          BOOST_PP_REPEAT(N, FUSION_VECTOR_MEMBER_AT_IMPL, _)
  
          template<typename I>
          BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
          typename add_reference<typename mpl::at<types, I>::type>::type
          at_impl(I)
          {
              return this->at_impl(mpl::int_<I::value>());
          }
  
          template<typename I>
          BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
          typename add_reference<typename add_const<typename mpl::at<types, I>::type>::type>::type
          at_impl(I) const
          {
              return this->at_impl(mpl::int_<I::value>());
          }
      };
  
  #undef N
  