1 // Copyright (c) 2001-2011 Hartmut Kaiser 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_KARMA_ALTERNATIVE_MAR_01_2007_1117AM) 8 #define SPIRIT_KARMA_ALTERNATIVE_MAR_01_2007_1117AM 9 10 #if defined(_MSC_VER) 11 #pragma once 12 #endif 13 14 #include <boost/spirit/home/karma/detail/alternative_function.hpp> 15 #include <boost/spirit/home/karma/detail/get_stricttag.hpp> 16 #include <boost/spirit/home/karma/domain.hpp> 17 #include <boost/spirit/home/karma/generator.hpp> 18 #include <boost/spirit/home/karma/meta_compiler.hpp> 19 #include <boost/spirit/home/support/info.hpp> 20 #include <boost/spirit/home/support/unused.hpp> 21 #include <boost/spirit/home/support/has_semantic_action.hpp> 22 #include <boost/spirit/home/support/handles_container.hpp> 23 #include <boost/spirit/home/support/detail/what_function.hpp> 24 #include <boost/fusion/include/any.hpp> 25 #include <boost/fusion/include/mpl.hpp> 26 #include <boost/fusion/include/for_each.hpp> 27 #include <boost/mpl/accumulate.hpp> 28 #include <boost/mpl/bitor.hpp> 29 #include <boost/config.hpp> 30 31 namespace boost { namespace spirit 32 { 33 /////////////////////////////////////////////////////////////////////////// 34 // Enablers 35 /////////////////////////////////////////////////////////////////////////// 36 template <> 37 struct use_operator<karma::domain, proto::tag::bitwise_or> // enables | 38 : mpl::true_ {}; 39 40 template <> 41 struct flatten_tree<karma::domain, proto::tag::bitwise_or> // flattens | 42 : mpl::true_ {}; 43 44 }} 45 46 /////////////////////////////////////////////////////////////////////////////// 47 namespace boost { namespace spirit { namespace traits 48 { 49 // specialization for sequences 50 template <typename Elements> 51 struct alternative_properties 52 { 53 struct element_properties 54 { 55 template <typename T> 56 struct result; 57 58 template <typename F, typename Element> 59 struct result<F(Element)> 60 { 61 typedef properties_of<Element> type; 62 }; 63 64 // never called, but needed for decltype-based result_of (C++0x) 65 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES 66 template <typename Element> 67 typename result<element_properties(Element)>::type 68 operator()(Element&&) const; 69 #endif 70 }; 71 72 typedef typename mpl::accumulate< 73 typename fusion::result_of::transform< 74 Elements, element_properties>::type 75 , mpl::int_<karma::generator_properties::countingbuffer> 76 , mpl::bitor_<mpl::_2, mpl::_1> 77 >::type type; 78 }; 79 80 }}} 81 82 namespace boost { namespace spirit { namespace karma 83 { 84 template <typename Elements, typename Strict, typename Derived> 85 struct base_alternative : nary_generator<Derived> 86 { 87 typedef typename traits::alternative_properties<Elements>::type 88 properties; 89 90 template <typename Context, typename Iterator = unused_type> 91 struct attribute 92 { 93 // Put all the element attributes in a tuple 94 typedef typename traits::build_attribute_sequence< 95 Elements, Context, traits::alternative_attribute_transform 96 , Iterator, karma::domain 97 >::type all_attributes; 98 99 // Ok, now make a variant over the attribute sequence. Note that 100 // build_variant makes sure that 1) all attributes in the variant 101 // are unique 2) puts the unused attribute, if there is any, to 102 // the front and 3) collapses single element variants, variant<T> 103 // to T. 104 typedef typename traits::build_variant<all_attributes>::type type; 105 }; 106 base_alternativeboost::spirit::karma::base_alternative107 base_alternative(Elements const& elements) 108 : elements(elements) {} 109 110 template < 111 typename OutputIterator, typename Context, typename Delimiter 112 , typename Attribute> generateboost::spirit::karma::base_alternative113 bool generate(OutputIterator& sink, Context& ctx 114 , Delimiter const& d, Attribute const& attr) const 115 { 116 typedef detail::alternative_generate_function< 117 OutputIterator, Context, Delimiter, Attribute, Strict 118 > functor; 119 120 // f return true if *any* of the parser succeeds 121 functor f (sink, ctx, d, attr); 122 return fusion::any(elements, f); 123 } 124 125 template <typename Context> whatboost::spirit::karma::base_alternative126 info what(Context& context) const 127 { 128 info result("alternative"); 129 fusion::for_each(elements, 130 spirit::detail::what_function<Context>(result, context)); 131 return result; 132 } 133 134 Elements elements; 135 }; 136 137 template <typename Elements> 138 struct alternative 139 : base_alternative<Elements, mpl::false_, alternative<Elements> > 140 { 141 typedef base_alternative<Elements, mpl::false_, alternative> 142 base_alternative_; 143 alternativeboost::spirit::karma::alternative144 alternative(Elements const& elements) 145 : base_alternative_(elements) {} 146 }; 147 148 template <typename Elements> 149 struct strict_alternative 150 : base_alternative<Elements, mpl::true_, strict_alternative<Elements> > 151 { 152 typedef base_alternative<Elements, mpl::true_, strict_alternative> 153 base_alternative_; 154 strict_alternativeboost::spirit::karma::strict_alternative155 strict_alternative(Elements const& elements) 156 : base_alternative_(elements) {} 157 }; 158 159 /////////////////////////////////////////////////////////////////////////// 160 // Generator generators: make_xxx function (objects) 161 /////////////////////////////////////////////////////////////////////////// 162 namespace detail 163 { 164 template <typename Elements, bool strict_mode = false> 165 struct make_alternative 166 : make_nary_composite<Elements, alternative> 167 {}; 168 169 template <typename Elements> 170 struct make_alternative<Elements, true> 171 : make_nary_composite<Elements, strict_alternative> 172 {}; 173 } 174 175 template <typename Elements, typename Modifiers> 176 struct make_composite<proto::tag::bitwise_or, Elements, Modifiers> 177 : detail::make_alternative<Elements 178 , detail::get_stricttag<Modifiers>::value> 179 {}; 180 181 }}} 182 183 namespace boost { namespace spirit { namespace traits 184 { 185 /////////////////////////////////////////////////////////////////////////// 186 template <typename Elements> 187 struct has_semantic_action<karma::alternative<Elements> > 188 : nary_has_semantic_action<Elements> {}; 189 190 template <typename Elements> 191 struct has_semantic_action<karma::strict_alternative<Elements> > 192 : nary_has_semantic_action<Elements> {}; 193 194 /////////////////////////////////////////////////////////////////////////// 195 template <typename Elements, typename Attribute, typename Context 196 , typename Iterator> 197 struct handles_container<karma::alternative<Elements> 198 , Attribute, Context, Iterator> 199 : nary_handles_container<Elements, Attribute, Context, Iterator> {}; 200 201 template <typename Elements, typename Attribute, typename Context 202 , typename Iterator> 203 struct handles_container<karma::strict_alternative<Elements> 204 , Attribute, Context, Iterator> 205 : nary_handles_container<Elements, Attribute, Context, Iterator> {}; 206 }}} 207 208 #endif 209