1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
/*=============================================================================
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)
==============================================================================*/
#if !defined(FUSION_AT_05042005_0722)
#define FUSION_AT_05042005_0722
#include <boost/fusion/support/config.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/or.hpp>
#include <boost/mpl/less.hpp>
#include <boost/mpl/empty_base.hpp>
#include <boost/type_traits/is_const.hpp>
#include <boost/fusion/sequence/intrinsic_fwd.hpp>
#include <boost/fusion/support/tag_of.hpp>
#include <boost/fusion/support/category_of.hpp>
namespace boost { namespace fusion
{
// Special tags:
struct sequence_facade_tag;
struct boost_tuple_tag; // boost::tuples::tuple tag
struct boost_array_tag; // boost::array tag
struct mpl_sequence_tag; // mpl sequence tag
struct std_pair_tag; // std::pair tag
struct std_tuple_tag; // std::tuple tag
namespace extension
{
template <typename Tag>
struct at_impl
{
template <typename Sequence, typename N>
struct apply;
};
template <>
struct at_impl<sequence_facade_tag>
{
template <typename Sequence, typename N>
struct apply : Sequence::template at<Sequence, N> {};
};
template <>
struct at_impl<boost_tuple_tag>;
template <>
struct at_impl<boost_array_tag>;
template <>
struct at_impl<mpl_sequence_tag>;
template <>
struct at_impl<std_pair_tag>;
template <>
struct at_impl<std_tuple_tag>;
}
namespace detail
{
template <typename Sequence, typename N, typename Tag>
struct at_impl
: mpl::if_<
mpl::or_<
mpl::less<N, typename extension::size_impl<Tag>::template apply<Sequence>::type>
, traits::is_unbounded<Sequence>
>
, typename extension::at_impl<Tag>::template apply<Sequence, N>
, mpl::empty_base
>::type
{};
}
namespace result_of
{
template <typename Sequence, typename N>
struct at
: detail::at_impl<Sequence, N, typename detail::tag_of<Sequence>::type>
{};
template <typename Sequence, int N>
struct at_c
: at<Sequence, mpl::int_<N> >
{};
}
template <typename N, typename Sequence>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename
lazy_disable_if<
is_const<Sequence>
, result_of::at<Sequence, N>
>::type
at(Sequence& seq)
{
return result_of::at<Sequence, N>::call(seq);
}
template <typename N, typename Sequence>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::at<Sequence const, N>::type
at(Sequence const& seq)
{
return result_of::at<Sequence const, N>::call(seq);
}
template <int N, typename Sequence>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename
lazy_disable_if<
is_const<Sequence>
, result_of::at_c<Sequence, N>
>::type
at_c(Sequence& seq)
{
return fusion::at<mpl::int_<N> >(seq);
}
template <int N, typename Sequence>
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
inline typename result_of::at_c<Sequence const, N>::type
at_c(Sequence const& seq)
{
return fusion::at<mpl::int_<N> >(seq);
}
}}
#endif
|
