PageRenderTime 28ms CodeModel.GetById 13ms app.highlight 12ms RepoModel.GetById 1ms app.codeStats 0ms

/Src/Dependencies/Boost/boost/spirit/home/classic/meta/parser_traits.hpp

http://hadesmem.googlecode.com/
C++ Header | 320 lines | 144 code | 52 blank | 124 comment | 0 complexity | ad6aa384031ee378ed02dfb1259ccb6b MD5 | raw file
  1/*=============================================================================
  2    Copyright (c) 2002-2003 Joel de Guzman
  3    Copyright (c) 2002-2003 Hartmut Kaiser
  4    Copyright (c) 2003 Martin Wille
  5    http://spirit.sourceforge.net/
  6
  7  Distributed under the Boost Software License, Version 1.0. (See accompanying
  8  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  9=============================================================================*/
 10#if !defined(BOOST_SPIRIT_PARSER_TRAITS_HPP)
 11#define BOOST_SPIRIT_PARSER_TRAITS_HPP
 12
 13#include <boost/type_traits/is_base_and_derived.hpp>
 14#include <boost/static_assert.hpp>
 15
 16#include <boost/spirit/home/classic/namespace.hpp>
 17#include <boost/spirit/home/classic/core/parser.hpp>
 18#include <boost/spirit/home/classic/meta/impl/parser_traits.ipp>
 19
 20///////////////////////////////////////////////////////////////////////////////
 21namespace boost { namespace spirit {
 22
 23BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
 24
 25///////////////////////////////////////////////////////////////////////////////
 26//
 27//  Parser traits templates
 28//
 29//      Used to determine the type and several other characteristics of a given
 30//      parser type.
 31//
 32///////////////////////////////////////////////////////////////////////////////
 33
 34///////////////////////////////////////////////////////////////////////////////
 35//
 36// The is_parser traits template can be used to tell wether a given
 37// class is a parser.
 38//
 39///////////////////////////////////////////////////////////////////////////////
 40template <typename T>
 41struct is_parser
 42{
 43    BOOST_STATIC_CONSTANT(bool, value =
 44        (::boost::is_base_and_derived<parser<T>, T>::value));
 45
 46//  [JDG 2/3/03] simplified implementation by
 47//  using boost::is_base_and_derived
 48};
 49
 50///////////////////////////////////////////////////////////////////////////////
 51//
 52//  The is_unary_composite traits template can be used to tell if a given
 53//  parser is a unary parser as for instance kleene_star or optional.
 54//
 55///////////////////////////////////////////////////////////////////////////////
 56template <typename UnaryT>
 57struct is_unary_composite {
 58
 59    BOOST_STATIC_CONSTANT(bool, value = (::boost::is_convertible<
 60        typename UnaryT::parser_category_t, unary_parser_category>::value));
 61};
 62
 63///////////////////////////////////////////////////////////////////////////////
 64//
 65//  The is_acction_parser traits template can be used to tell if a given
 66//  parser is a action parser, i.e. it is a composite consisting of a
 67//  auxilliary parser and an attached semantic action.
 68//
 69///////////////////////////////////////////////////////////////////////////////
 70template <typename ActionT>
 71struct is_action_parser {
 72
 73    BOOST_STATIC_CONSTANT(bool, value = (::boost::is_convertible<
 74        typename ActionT::parser_category_t, action_parser_category>::value));
 75};
 76
 77///////////////////////////////////////////////////////////////////////////////
 78//
 79//  The is_binary_composite traits template can be used to tell if a given
 80//  parser is a binary parser as for instance sequence or difference.
 81//
 82///////////////////////////////////////////////////////////////////////////////
 83template <typename BinaryT>
 84struct is_binary_composite {
 85
 86    BOOST_STATIC_CONSTANT(bool, value = (::boost::is_convertible<
 87        typename BinaryT::parser_category_t, binary_parser_category>::value));
 88};
 89
 90///////////////////////////////////////////////////////////////////////////////
 91//
 92//  The is_composite_parser traits template can be used to tell if a given
 93//  parser is a unary or a binary parser composite type.
 94//
 95///////////////////////////////////////////////////////////////////////////////
 96template <typename CompositeT>
 97struct is_composite_parser {
 98
 99    BOOST_STATIC_CONSTANT(bool, value = (
100        ::BOOST_SPIRIT_CLASSIC_NS::is_unary_composite<CompositeT>::value ||
101        ::BOOST_SPIRIT_CLASSIC_NS::is_binary_composite<CompositeT>::value));
102};
103
104///////////////////////////////////////////////////////////////////////////////
105template <typename ParserT>
106struct is_alternative {
107
108    BOOST_STATIC_CONSTANT(bool, value = (
109        ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_alternative));
110};
111
112template <typename ParserT>
113struct is_sequence {
114
115    BOOST_STATIC_CONSTANT(bool, value = (
116        ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_sequence));
117};
118
119template <typename ParserT>
120struct is_sequential_or {
121
122    BOOST_STATIC_CONSTANT(bool, value = (
123        ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_sequential_or));
124};
125
126template <typename ParserT>
127struct is_intersection {
128
129    BOOST_STATIC_CONSTANT(bool, value = (
130        ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_intersection));
131};
132
133template <typename ParserT>
134struct is_difference {
135
136    BOOST_STATIC_CONSTANT(bool, value = (
137        ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_difference));
138};
139
140template <typename ParserT>
141struct is_exclusive_or {
142
143    BOOST_STATIC_CONSTANT(bool, value = (
144        ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_exclusive_or));
145};
146
147template <typename ParserT>
148struct is_optional {
149
150    BOOST_STATIC_CONSTANT(bool, value = (
151        ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_optional));
152};
153
154template <typename ParserT>
155struct is_kleene_star {
156
157    BOOST_STATIC_CONSTANT(bool, value = (
158        ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_kleene_star));
159};
160
161template <typename ParserT>
162struct is_positive {
163
164    BOOST_STATIC_CONSTANT(bool, value = (
165        ::BOOST_SPIRIT_CLASSIC_NS::impl::parser_type_traits<ParserT>::is_positive));
166};
167
168///////////////////////////////////////////////////////////////////////////////
169//
170//  Parser extraction templates
171//
172///////////////////////////////////////////////////////////////////////////////
173
174///////////////////////////////////////////////////////////////////////////////
175//
176//  The unary_subject template can be used to return the type of the
177//  parser used as the subject of an unary parser.
178//  If the parser under inspection is not an unary type parser the compilation
179//  will fail.
180//
181///////////////////////////////////////////////////////////////////////////////
182template <typename UnaryT>
183struct unary_subject {
184
185    BOOST_STATIC_ASSERT(BOOST_SPIRIT_CLASSIC_NS::is_unary_composite<UnaryT>::value);
186    typedef typename UnaryT::subject_t type;
187};
188
189///////////////////////////////////////////////////////////////////////////////
190//
191//  The get_unary_subject template function returns the parser object, which
192//  is used as the subject of an unary parser.
193//  If the parser under inspection is not an unary type parser the compilation
194//  will fail.
195//
196///////////////////////////////////////////////////////////////////////////////
197template <typename UnaryT>
198inline typename unary_subject<UnaryT>::type const &
199get_unary_subject(UnaryT const &unary_)
200{
201    BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_unary_composite<UnaryT>::value);
202    return unary_.subject();
203}
204
205///////////////////////////////////////////////////////////////////////////////
206//
207//  The binary_left_subject and binary_right_subject templates can be used to
208//  return the types of the parsers used as the left and right subject of an
209//  binary parser.
210//  If the parser under inspection is not a binary type parser the compilation
211//  will fail.
212//
213///////////////////////////////////////////////////////////////////////////////
214template <typename BinaryT>
215struct binary_left_subject {
216
217    BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_binary_composite<BinaryT>::value);
218    typedef typename BinaryT::left_t type;
219};
220
221template <typename BinaryT>
222struct binary_right_subject {
223
224    BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_binary_composite<BinaryT>::value);
225    typedef typename BinaryT::right_t type;
226};
227
228///////////////////////////////////////////////////////////////////////////////
229//
230//  The get_binary_left_subject and get_binary_right_subject template functions
231//  return the parser object, which is used as the left or right subject of a
232//  binary parser.
233//  If the parser under inspection is not a binary type parser the compilation
234//  will fail.
235//
236///////////////////////////////////////////////////////////////////////////////
237template <typename BinaryT>
238inline typename binary_left_subject<BinaryT>::type const &
239get_binary_left_subject(BinaryT const &binary_)
240{
241    BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_binary_composite<BinaryT>::value);
242    return binary_.left();
243}
244
245template <typename BinaryT>
246inline typename binary_right_subject<BinaryT>::type const &
247get_binary_right_subject(BinaryT const &binary_)
248{
249    BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_binary_composite<BinaryT>::value);
250    return binary_.right();
251}
252
253///////////////////////////////////////////////////////////////////////////////
254//
255//  The action_subject template can be used to return the type of the
256//  parser used as the subject of an action parser.
257//  If the parser under inspection is not an action type parser the compilation
258//  will fail.
259//
260///////////////////////////////////////////////////////////////////////////////
261template <typename ActionT>
262struct action_subject {
263
264    BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_action_parser<ActionT>::value);
265    typedef typename ActionT::subject_t type;
266};
267
268///////////////////////////////////////////////////////////////////////////////
269//
270//  The get_action_subject template function returns the parser object, which
271//  is used as the subject of an action parser.
272//  If the parser under inspection is not an action type parser the compilation
273//  will fail.
274//
275///////////////////////////////////////////////////////////////////////////////
276template <typename ActionT>
277inline typename action_subject<ActionT>::type const &
278get_action_subject(ActionT const &action_)
279{
280    BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_action_parser<ActionT>::value);
281    return action_.subject();
282}
283
284///////////////////////////////////////////////////////////////////////////////
285//
286//  The semantic_action template can be used to return the type of the
287//  attached semantic action of an action parser.
288//  If the parser under inspection is not an action type parser the compilation
289//  will fail.
290//
291///////////////////////////////////////////////////////////////////////////////
292template <typename ActionT>
293struct semantic_action {
294
295    BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_action_parser<ActionT>::value);
296    typedef typename ActionT::predicate_t type;
297};
298
299///////////////////////////////////////////////////////////////////////////////
300//
301//  The get_semantic_action template function returns the attached semantic
302//  action of an action parser.
303//  If the parser under inspection is not an action type parser the compilation
304//  will fail.
305//
306///////////////////////////////////////////////////////////////////////////////
307template <typename ActionT>
308inline typename semantic_action<ActionT>::type const &
309get_semantic_action(ActionT const &action_)
310{
311    BOOST_STATIC_ASSERT(::BOOST_SPIRIT_CLASSIC_NS::is_action_parser<ActionT>::value);
312    return action_.predicate();
313}
314
315///////////////////////////////////////////////////////////////////////////////
316BOOST_SPIRIT_CLASSIC_NAMESPACE_END
317
318}} // namespace BOOST_SPIRIT_CLASSIC_NS
319
320#endif // !defined(BOOST_SPIRIT_PARSER_TRAITS_HPP)