1/*=============================================================================
2 Copyright (c) 2001-2014 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#if !defined(BOOST_SPIRIT_X3_ALTERNATIVE_DETAIL_JAN_07_2013_1245PM)
8#define BOOST_SPIRIT_X3_ALTERNATIVE_DETAIL_JAN_07_2013_1245PM
9
10#include <boost/spirit/home/x3/support/traits/attribute_of.hpp>
11#include <boost/spirit/home/x3/support/traits/pseudo_attribute.hpp>
12#include <boost/spirit/home/x3/support/traits/is_variant.hpp>
13#include <boost/spirit/home/x3/support/traits/tuple_traits.hpp>
14#include <boost/spirit/home/x3/support/traits/move_to.hpp>
15#include <boost/spirit/home/x3/support/traits/variant_has_substitute.hpp>
16#include <boost/spirit/home/x3/support/traits/variant_find_substitute.hpp>
17#include <boost/spirit/home/x3/core/detail/parse_into_container.hpp>
18
19#include <boost/mpl/if.hpp>
20
21#include <boost/fusion/include/front.hpp>
22
23#include <boost/type_traits/is_same.hpp>
24#include <type_traits>
25
26namespace boost { namespace spirit { namespace x3
27{
28 template <typename Left, typename Right>
29 struct alternative;
30}}}
31
32namespace boost { namespace spirit { namespace x3 { namespace detail
33{
34 struct pass_variant_unused
35 {
36 typedef unused_type type;
37
38 template <typename T>
39 static unused_type
40 call(T&)
41 {
42 return unused_type();
43 }
44 };
45
46 template <typename Attribute>
47 struct pass_variant_used
48 {
49 typedef Attribute& type;
50
51 static Attribute&
52 call(Attribute& v)
53 {
54 return v;
55 }
56 };
57
58 template <>
59 struct pass_variant_used<unused_type> : pass_variant_unused {};
60
61 template <typename Parser, typename Attribute, typename Context
62 , typename Enable = void>
63 struct pass_parser_attribute
64 {
65 typedef typename
66 traits::attribute_of<Parser, Context>::type
67 attribute_type;
68 typedef typename
69 traits::variant_find_substitute<Attribute, attribute_type>::type
70 substitute_type;
71
72 typedef typename
73 mpl::if_<
74 is_same<Attribute, substitute_type>
75 , Attribute&
76 , substitute_type
77 >::type
78 type;
79
80 template <typename Attribute_>
81 static Attribute_&
82 call(Attribute_& attribute, mpl::true_)
83 {
84 return attribute;
85 }
86
87 template <typename Attribute_>
88 static type
89 call(Attribute_&, mpl::false_)
90 {
91 return type();
92 }
93
94 template <typename Attribute_>
95 static type
96 call(Attribute_& attribute)
97 {
98 return call(attribute, is_same<Attribute_, typename remove_reference<type>::type>());
99 }
100 };
101
102 // Pass non-variant attributes as-is
103 template <typename Parser, typename Attribute, typename Context
104 , typename Enable = void>
105 struct pass_non_variant_attribute
106 {
107 typedef Attribute& type;
108
109 static Attribute&
110 call(Attribute& attribute)
111 {
112 return attribute;
113 }
114 };
115
116 // Unwrap single element sequences
117 template <typename Parser, typename Attribute, typename Context>
118 struct pass_non_variant_attribute<Parser, Attribute, Context,
119 typename enable_if<traits::is_size_one_sequence<Attribute>>::type>
120 {
121 typedef typename remove_reference<
122 typename fusion::result_of::front<Attribute>::type>::type
123 attr_type;
124
125 typedef pass_parser_attribute<Parser, attr_type, Context> pass;
126 typedef typename pass::type type;
127
128 template <typename Attribute_>
129 static type
130 call(Attribute_& attr)
131 {
132 return pass::call(fusion::front(attr));
133 }
134 };
135
136 template <typename Parser, typename Attribute, typename Context>
137 struct pass_parser_attribute<Parser, Attribute, Context,
138 typename enable_if_c<(!traits::is_variant<Attribute>::value)>::type>
139 : pass_non_variant_attribute<Parser, Attribute, Context>
140 {};
141
142 template <typename Parser, typename Context>
143 struct pass_parser_attribute<Parser, unused_type, Context>
144 : pass_variant_unused {};
145
146 template <typename Parser, typename Attribute, typename Context>
147 struct pass_variant_attribute :
148 mpl::if_c<traits::has_attribute<Parser, Context>::value
149 , pass_parser_attribute<Parser, Attribute, Context>
150 , pass_variant_unused>::type
151 {
152 };
153
154 template <typename L, typename R, typename Attribute, typename Context>
155 struct pass_variant_attribute<alternative<L, R>, Attribute, Context> :
156 mpl::if_c<traits::has_attribute<alternative<L, R>, Context>::value
157 , pass_variant_used<Attribute>
158 , pass_variant_unused>::type
159 {
160 };
161
162 template <bool Condition>
163 struct move_if
164 {
165 template<typename T1, typename T2>
166 static void call(T1& /* attr_ */, T2& /* attr */) {}
167 };
168
169 template <>
170 struct move_if<true>
171 {
172 template<typename T1, typename T2>
173 static void call(T1& attr_, T2& attribute)
174 {
175 traits::move_to(attr_, attribute);
176 }
177 };
178
179 template <typename Parser, typename Iterator, typename Context
180 , typename RContext, typename Attribute>
181 bool parse_alternative(Parser const& p, Iterator& first, Iterator const& last
182 , Context const& context, RContext& rcontext, Attribute& attribute)
183 {
184 using pass = detail::pass_variant_attribute<Parser, Attribute, Context>;
185 using pseudo = traits::pseudo_attribute<Context, typename pass::type, Iterator>;
186
187 typename pseudo::type attr_ = pseudo::call(first, last, pass::call(attribute));
188
189 if (p.parse(first, last, context, rcontext, attr_))
190 {
191 move_if<!std::is_reference<decltype(attr_)>::value>::call(attr_, attribute);
192 return true;
193 }
194 return false;
195 }
196
197 template <typename Subject>
198 struct alternative_helper : unary_parser<Subject, alternative_helper<Subject>>
199 {
200 static bool const is_pass_through_unary = true;
201
202 using unary_parser<Subject, alternative_helper<Subject>>::unary_parser;
203
204 template <typename Iterator, typename Context
205 , typename RContext, typename Attribute>
206 bool parse(Iterator& first, Iterator const& last
207 , Context const& context, RContext& rcontext, Attribute& attr) const
208 {
209 return detail::parse_alternative(this->subject, first, last, context, rcontext, attr);
210 }
211 };
212
213 template <typename Left, typename Right, typename Context, typename RContext>
214 struct parse_into_container_impl<alternative<Left, Right>, Context, RContext>
215 {
216 typedef alternative<Left, Right> parser_type;
217
218 template <typename Iterator, typename Attribute>
219 static bool call(
220 parser_type const& parser
221 , Iterator& first, Iterator const& last
222 , Context const& context, RContext& rcontext, Attribute& attribute, mpl::false_)
223 {
224 return detail::parse_into_container(parser.left, first, last, context, rcontext, attribute)
225 || detail::parse_into_container(parser.right, first, last, context, rcontext, attribute);
226 }
227
228 template <typename Iterator, typename Attribute>
229 static bool call(
230 parser_type const& parser
231 , Iterator& first, Iterator const& last
232 , Context const& context, RContext& rcontext, Attribute& attribute, mpl::true_)
233 {
234 return detail::parse_into_container(alternative_helper<Left>{parser.left}, first, last, context, rcontext, attribute)
235 || detail::parse_into_container(alternative_helper<Right>{parser.right}, first, last, context, rcontext, attribute);
236 }
237
238 template <typename Iterator, typename Attribute>
239 static bool call(
240 parser_type const& parser
241 , Iterator& first, Iterator const& last
242 , Context const& context, RContext& rcontext, Attribute& attribute)
243 {
244 return call(parser, first, last, context, rcontext, attribute,
245 typename traits::is_variant<typename traits::container_value<Attribute>::type>::type{});
246 }
247 };
248
249}}}}
250
251#endif
252

source code of boost/libs/spirit/include/boost/spirit/home/x3/operator/detail/alternative.hpp