]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Copyright (c) 2001-2011 Hartmut Kaiser |
2 | // | |
3 | // Distributed under the Boost Software License, Version 1.0. (See accompanying | |
4 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
5 | ||
6 | #if !defined(BOOST_SPIRIT_QI_META_CREATE_NOV_21_2009_0432PM) | |
7 | #define BOOST_SPIRIT_QI_META_CREATE_NOV_21_2009_0432PM | |
8 | ||
9 | #if defined(_MSC_VER) | |
10 | #pragma once | |
11 | #endif | |
12 | ||
13 | #include <boost/spirit/home/qi/domain.hpp> | |
14 | #include <boost/spirit/home/support/common_terminals.hpp> | |
15 | #include <boost/spirit/home/support/auto/meta_create.hpp> | |
16 | ||
17 | #include <boost/utility/enable_if.hpp> | |
18 | #include <boost/variant.hpp> | |
19 | #include <boost/optional.hpp> | |
20 | #include <boost/config.hpp> | |
21 | #include <boost/mpl/and.hpp> | |
22 | #include <boost/mpl/not.hpp> | |
23 | #include <boost/mpl/fold.hpp> | |
24 | #include <boost/mpl/vector.hpp> | |
25 | #include <boost/mpl/push_back.hpp> | |
26 | #include <boost/type_traits/is_same.hpp> | |
27 | #include <boost/fusion/include/as_vector.hpp> | |
28 | ||
29 | /////////////////////////////////////////////////////////////////////////////// | |
30 | namespace boost { namespace spirit { namespace qi | |
31 | { | |
32 | /////////////////////////////////////////////////////////////////////////// | |
33 | // compatible STL containers | |
34 | template <typename Container> | |
35 | struct meta_create_container | |
36 | { | |
37 | typedef make_unary_proto_expr< | |
38 | typename Container::value_type | |
39 | , proto::tag::dereference, qi::domain | |
40 | > make_proto_expr; | |
41 | ||
42 | typedef typename make_proto_expr::type type; | |
43 | ||
44 | static type call() | |
45 | { | |
46 | return make_proto_expr::call(); | |
47 | } | |
48 | }; | |
49 | ||
50 | /////////////////////////////////////////////////////////////////////////// | |
51 | // Fusion sequences | |
52 | template <typename Sequence> | |
53 | struct meta_create_sequence | |
54 | { | |
55 | // create a mpl sequence from the given fusion sequence | |
56 | typedef typename mpl::fold< | |
57 | typename fusion::result_of::as_vector<Sequence>::type | |
58 | , mpl::vector<>, mpl::push_back<mpl::_, mpl::_> | |
59 | >::type sequence_type; | |
60 | ||
61 | typedef make_nary_proto_expr< | |
62 | sequence_type, proto::tag::shift_right, qi::domain | |
63 | > make_proto_expr; | |
64 | ||
65 | typedef typename make_proto_expr::type type; | |
66 | ||
67 | static type call() | |
68 | { | |
69 | return make_proto_expr::call(); | |
70 | } | |
71 | }; | |
72 | ||
73 | /////////////////////////////////////////////////////////////////////////// | |
74 | // the default is to use the standard streaming operator unless it's a | |
75 | // STL container or a fusion sequence | |
76 | ||
77 | // The default implementation will be chosen if no predefined mapping of | |
78 | // the data type T to a Qi component is defined. | |
79 | struct no_auto_mapping_exists {}; | |
80 | ||
81 | template <typename T, typename Enable = void> | |
82 | struct meta_create_impl : mpl::identity<no_auto_mapping_exists> {}; | |
83 | ||
84 | template <typename T> | |
85 | struct meta_create_impl<T | |
86 | , typename enable_if<mpl::and_< | |
87 | traits::is_container<T>, mpl::not_<traits::is_string<T> > > | |
88 | >::type> | |
89 | : meta_create_container<T> {}; | |
90 | ||
91 | template <typename T> | |
92 | struct meta_create_impl<T, typename enable_if< | |
93 | spirit::detail::is_fusion_sequence_but_not_proto_expr<T> | |
94 | >::type> | |
95 | : meta_create_sequence<T> {}; | |
96 | ||
97 | template <typename T, typename Enable = void> | |
98 | struct meta_create : meta_create_impl<T> {}; | |
99 | ||
100 | /////////////////////////////////////////////////////////////////////////// | |
101 | // optional | |
102 | template <typename T> | |
103 | struct meta_create<boost::optional<T> > | |
104 | { | |
105 | typedef make_unary_proto_expr< | |
106 | T, proto::tag::negate, qi::domain | |
107 | > make_proto_expr; | |
108 | ||
109 | typedef typename make_proto_expr::type type; | |
110 | ||
111 | static type call() | |
112 | { | |
113 | return make_proto_expr::call(); | |
114 | } | |
115 | }; | |
116 | ||
117 | /////////////////////////////////////////////////////////////////////////// | |
118 | // alternatives | |
119 | template <BOOST_VARIANT_ENUM_PARAMS(typename T)> | |
120 | struct meta_create<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> > | |
121 | { | |
122 | typedef make_nary_proto_expr< | |
123 | typename boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>::types | |
124 | , proto::tag::bitwise_or, qi::domain | |
125 | > make_proto_expr; | |
126 | ||
127 | typedef typename make_proto_expr::type type; | |
128 | ||
129 | static type call() | |
130 | { | |
131 | return make_proto_expr::call(); | |
132 | } | |
133 | }; | |
134 | ||
135 | /////////////////////////////////////////////////////////////////////////// | |
136 | // predefined specializations for primitive components | |
137 | ||
138 | // character generator | |
139 | template <> | |
140 | struct meta_create<char> | |
141 | { | |
142 | typedef spirit::standard::char_type type; | |
143 | static type call() { return type(); } | |
144 | }; | |
145 | template <> | |
146 | struct meta_create<signed char> | |
147 | { | |
148 | typedef spirit::standard::char_type type; | |
149 | static type call() { return type(); } | |
150 | }; | |
151 | template <> | |
152 | struct meta_create<wchar_t> | |
153 | { | |
154 | typedef spirit::standard_wide::char_type type; | |
155 | static type call() { return type(); } | |
156 | }; | |
157 | ||
158 | template <> | |
159 | struct meta_create<unsigned char> | |
160 | { | |
161 | typedef spirit::standard::char_type type; | |
162 | static type call() { return type(); } | |
163 | }; | |
164 | ||
165 | // boolean generator | |
166 | template <> | |
167 | struct meta_create<bool> | |
168 | { | |
169 | typedef spirit::bool_type type; | |
170 | static type call() { return type(); } | |
171 | }; | |
172 | ||
173 | // integral generators | |
174 | template <> | |
175 | struct meta_create<int> | |
176 | { | |
177 | typedef spirit::int_type type; | |
178 | static type call() { return type(); } | |
179 | }; | |
180 | template <> | |
181 | struct meta_create<short> | |
182 | { | |
183 | typedef spirit::short_type type; | |
184 | static type call() { return type(); } | |
185 | }; | |
186 | template <> | |
187 | struct meta_create<long> | |
188 | { | |
189 | typedef spirit::long_type type; | |
190 | static type call() { return type(); } | |
191 | }; | |
192 | template <> | |
193 | struct meta_create<unsigned int> | |
194 | { | |
195 | typedef spirit::uint_type type; | |
196 | static type call() { return type(); } | |
197 | }; | |
198 | #if !defined(BOOST_NO_INTRINSIC_WCHAR_T) | |
199 | template <> | |
200 | struct meta_create<unsigned short> | |
201 | { | |
202 | typedef spirit::ushort_type type; | |
203 | static type call() { return type(); } | |
204 | }; | |
205 | #endif | |
206 | template <> | |
207 | struct meta_create<unsigned long> | |
208 | { | |
209 | typedef spirit::ulong_type type; | |
210 | static type call() { return type(); } | |
211 | }; | |
212 | ||
213 | #ifdef BOOST_HAS_LONG_LONG | |
214 | template <> | |
215 | struct meta_create<boost::long_long_type> | |
216 | { | |
217 | typedef spirit::long_long_type type; | |
218 | static type call() { return type(); } | |
219 | }; | |
220 | template <> | |
221 | struct meta_create<boost::ulong_long_type> | |
222 | { | |
223 | typedef spirit::ulong_long_type type; | |
224 | static type call() { return type(); } | |
225 | }; | |
226 | #endif | |
227 | ||
228 | // floating point generators | |
229 | template <> | |
230 | struct meta_create<float> | |
231 | { | |
232 | typedef spirit::float_type type; | |
233 | static type call() { return type(); } | |
234 | }; | |
235 | template <> | |
236 | struct meta_create<double> | |
237 | { | |
238 | typedef spirit::double_type type; | |
239 | static type call() { return type(); } | |
240 | }; | |
241 | template <> | |
242 | struct meta_create<long double> | |
243 | { | |
244 | typedef spirit::long_double_type type; | |
245 | static type call() { return type(); } | |
246 | }; | |
247 | }}} | |
248 | ||
249 | /////////////////////////////////////////////////////////////////////////////// | |
250 | namespace boost { namespace spirit { namespace traits | |
251 | { | |
252 | /////////////////////////////////////////////////////////////////////////// | |
253 | // main customization point for create_parser | |
254 | template <typename T, typename Enable = void> | |
255 | struct create_parser : qi::meta_create<T> {}; | |
256 | ||
257 | /////////////////////////////////////////////////////////////////////////// | |
258 | // dispatch this to the Qi related specializations | |
259 | template <typename T> | |
260 | struct meta_create<qi::domain, T> | |
261 | : create_parser<typename spirit::detail::remove_const_ref<T>::type> {}; | |
262 | ||
263 | /////////////////////////////////////////////////////////////////////////// | |
264 | // Check whether a valid mapping exits for the given data type to a Qi | |
265 | // component | |
266 | template <typename T> | |
267 | struct meta_create_exists<qi::domain, T> | |
268 | : mpl::not_<is_same< | |
269 | qi::no_auto_mapping_exists | |
270 | , typename meta_create<qi::domain, T>::type | |
271 | > > {}; | |
272 | }}} | |
273 | ||
274 | #endif |