PageRenderTime 57ms CodeModel.GetById 47ms app.highlight 7ms RepoModel.GetById 0ms app.codeStats 1ms

/Src/Dependencies/Boost/boost/spirit/home/qi/operator/permutation.hpp

http://hadesmem.googlecode.com/
C++ Header | 146 lines | 98 code | 19 blank | 29 comment | 1 complexity | c5b125cf6c2da4114748816af164b2b9 MD5 | raw file
  1/*=============================================================================
  2    Copyright (c) 2001-2011 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(SPIRIT_PERMUTATION_OR_MARCH_13_2007_1145PM)
  8#define SPIRIT_PERMUTATION_OR_MARCH_13_2007_1145PM
  9
 10#if defined(_MSC_VER)
 11#pragma once
 12#endif
 13
 14#include <boost/spirit/home/qi/meta_compiler.hpp>
 15#include <boost/spirit/home/qi/detail/permute_function.hpp>
 16#include <boost/spirit/home/qi/detail/attributes.hpp>
 17#include <boost/spirit/home/support/algorithm/any_if_ns.hpp>
 18#include <boost/spirit/home/support/detail/what_function.hpp>
 19#include <boost/spirit/home/support/has_semantic_action.hpp>
 20#include <boost/spirit/home/support/handles_container.hpp>
 21#include <boost/spirit/home/support/info.hpp>
 22#include <boost/fusion/include/size.hpp>
 23#include <boost/optional.hpp>
 24#include <boost/foreach.hpp>
 25#include <boost/array.hpp>
 26
 27namespace boost { namespace spirit
 28{
 29    ///////////////////////////////////////////////////////////////////////////
 30    // Enablers
 31    ///////////////////////////////////////////////////////////////////////////
 32    template <>
 33    struct use_operator<qi::domain, proto::tag::bitwise_xor> // enables ^
 34      : mpl::true_ {};
 35
 36    template <>
 37    struct flatten_tree<qi::domain, proto::tag::bitwise_xor> // flattens ^
 38      : mpl::true_ {};
 39}}
 40
 41namespace boost { namespace spirit { namespace qi
 42{
 43    template <typename Elements>
 44    struct permutation : nary_parser<permutation<Elements> >
 45    {
 46        template <typename Context, typename Iterator>
 47        struct attribute
 48        {
 49            // Put all the element attributes in a tuple,
 50            // wrapping each element in a boost::optional
 51            typedef typename traits::build_attribute_sequence<
 52                Elements, Context, traits::permutation_attribute_transform
 53              , Iterator, qi::domain
 54            >::type all_attributes;
 55
 56            // Now, build a fusion vector over the attributes. Note
 57            // that build_fusion_vector 1) removes all unused attributes
 58            // and 2) may return unused_type if all elements have
 59            // unused_type(s).
 60            typedef typename
 61                traits::build_fusion_vector<all_attributes>::type
 62            type;
 63        };
 64
 65        permutation(Elements const& elements)
 66          : elements(elements) {}
 67
 68        template <typename Iterator, typename Context
 69          , typename Skipper, typename Attribute>
 70        bool parse(Iterator& first, Iterator const& last
 71          , Context& context, Skipper const& skipper
 72          , Attribute& attr_) const
 73        {
 74            typedef traits::attribute_not_unused<Context, Iterator> predicate;
 75            detail::permute_function<Iterator, Context, Skipper>
 76                f(first, last, context, skipper);
 77
 78            boost::array<bool, fusion::result_of::size<Elements>::value> flags;
 79            BOOST_FOREACH(bool& taken, flags)
 80            {
 81                taken = false;
 82            }
 83
 84            // wrap the attribute in a tuple if it is not a tuple
 85            typename traits::wrap_if_not_tuple<Attribute>::type attr(attr_);
 86
 87            // We have a bool array 'flags' with one flag for each parser.
 88            // permute_function sets the slot to true when the corresponding
 89            // parser successful matches. We loop until there are no more
 90            // successful parsers.
 91
 92            bool result = false;
 93            f.taken = flags.begin();
 94            while (spirit::any_if_ns(elements, attr, f, predicate()))
 95            {
 96                f.taken = flags.begin();
 97                result = true;
 98            }
 99            return result;
100        }
101
102        template <typename Context>
103        info what(Context& context) const
104        {
105            info result("permutation");
106            fusion::for_each(elements,
107                spirit::detail::what_function<Context>(result, context));
108            return result;
109        }
110
111        Elements elements;
112    };
113
114    ///////////////////////////////////////////////////////////////////////////
115    // Parser generators: make_xxx function (objects)
116    ///////////////////////////////////////////////////////////////////////////
117    template <typename Elements, typename Modifiers>
118    struct make_composite<proto::tag::bitwise_xor, Elements, Modifiers>
119      : make_nary_composite<Elements, permutation>
120    {};
121}}}
122
123namespace boost { namespace spirit { namespace traits
124{
125    ///////////////////////////////////////////////////////////////////////////
126    // We specialize this for permutation (see support/attributes.hpp).
127    // For permutation, we only wrap the attribute in a tuple IFF
128    // it is not already a fusion tuple.
129    template <typename Elements, typename Attribute>
130    struct pass_attribute<qi::permutation<Elements>, Attribute>
131      : wrap_if_not_tuple<Attribute> {};
132
133    ///////////////////////////////////////////////////////////////////////////
134    template <typename Elements>
135    struct has_semantic_action<qi::permutation<Elements> >
136      : nary_has_semantic_action<Elements> {};
137
138    ///////////////////////////////////////////////////////////////////////////
139    template <typename Elements, typename Attribute, typename Context
140      , typename Iterator>
141    struct handles_container<qi::permutation<Elements>, Attribute, Context
142      , Iterator>
143      : nary_handles_container<Elements, Attribute, Context, Iterator> {};
144}}}
145
146#endif