ceph/src/boost/boost/spirit/home/support/attributes.hpp

   1 /*=============================================================================
   2     Copyright (c) 2001-2011 Joel de Guzman
   3     Copyright (c) 2001-2012 Hartmut Kaiser
   4
   5     Distributed under the Boost Software License, Version 1.0. (See accompanying
   6     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   7 ==============================================================================*/
   8 #if !defined(BOOST_SPIRIT_ATTRIBUTES_JANUARY_29_2007_0954AM)
   9 #define BOOST_SPIRIT_ATTRIBUTES_JANUARY_29_2007_0954AM
  10
  11 #if defined(_MSC_VER)
  12 #pragma once
  13 #endif
  14
  15 #include <boost/spirit/home/support/unused.hpp>
  16 #include <boost/spirit/home/support/has_semantic_action.hpp>
  17 #include <boost/spirit/home/support/attributes_fwd.hpp>
  18 #include <boost/spirit/home/support/container.hpp>
  19 #include <boost/spirit/home/support/detail/hold_any.hpp>
  20 #include <boost/spirit/home/support/detail/as_variant.hpp>
  21 #include <boost/optional/optional.hpp>
  22 #include <boost/fusion/include/transform.hpp>
  23 #include <boost/fusion/include/filter_if.hpp>
  24 #include <boost/fusion/include/as_vector.hpp>
  25 #include <boost/fusion/include/push_front.hpp>
  26 #include <boost/fusion/include/pop_front.hpp>
  27 #include <boost/fusion/include/is_sequence.hpp>
  28 #include <boost/fusion/include/for_each.hpp>
  29 #include <boost/fusion/include/is_view.hpp>
  30 #include <boost/fusion/include/mpl.hpp>
  31 #include <boost/type_traits/is_same.hpp>
  32 #include <boost/type_traits/is_convertible.hpp>
  33 #include <boost/type_traits/is_reference.hpp>
  34 #include <boost/mpl/eval_if.hpp>
  35 #include <boost/mpl/end.hpp>
  36 #include <boost/mpl/find_if.hpp>
  37 #include <boost/mpl/identity.hpp>
  38 #include <boost/mpl/deref.hpp>
  39 #include <boost/mpl/distance.hpp>
  40 #include <boost/mpl/or.hpp>
  41 #include <boost/mpl/has_xxx.hpp>
  42 #include <boost/mpl/equal.hpp>
  43 #include <boost/proto/proto_fwd.hpp>
  44 #include <boost/utility/enable_if.hpp>
  45 #include <boost/variant.hpp>
  46 #include <boost/range/iterator_range.hpp>
  47 #include <boost/config.hpp>
  48 #include <iterator> // for std::iterator_traits, std::distance
  49 #include <vector>
  50 #include <utility>
  51 #include <ios>
  52
  53 ///////////////////////////////////////////////////////////////////////////////
  54 namespace boost { namespace spirit { namespace traits
  55 {
  56     ///////////////////////////////////////////////////////////////////////////
  57     // This file deals with attribute related functions and meta-functions
  58     // including generalized attribute transformation utilities for Spirit
  59     // components.
  60     ///////////////////////////////////////////////////////////////////////////
  61
  62     ///////////////////////////////////////////////////////////////////////////
  63     // Find out if T can be a (strong) substitute for Expected attribute
  64     namespace detail
  65     {
  66         template <typename T, typename Expected>
  67         struct value_type_is_substitute
  68           : is_substitute<
  69                 typename container_value<T>::type
  70               , typename container_value<Expected>::type>
  71         {};
  72
  73         template <typename T, typename Expected, typename Enable = void>
  74         struct is_substitute_impl : is_same<T, Expected> {};
  75
  76         template <typename T, typename Expected>
  77         struct is_substitute_impl<T, Expected,
  78             typename enable_if<
  79                 mpl::and_<
  80                     fusion::traits::is_sequence<T>,
  81                     fusion::traits::is_sequence<Expected>,
  82                     mpl::equal<T, Expected, is_substitute<mpl::_1, mpl::_2> >
  83                 >
  84             >::type>
  85           : mpl::true_ {};
  86
  87         template <typename T, typename Expected>
  88         struct is_substitute_impl<T, Expected,
  89             typename enable_if<
  90                 mpl::and_<
  91                     is_container<T>,
  92                     is_container<Expected>,
  93                     detail::value_type_is_substitute<T, Expected>
  94                 >
  95             >::type>
  96           : mpl::true_ {};
  97     }
  98
  99     template <typename T, typename Expected, typename Enable /*= void*/>
 100     struct is_substitute
 101       : detail::is_substitute_impl<T, Expected> {};
 102
 103     template <typename T, typename Expected>
 104     struct is_substitute<optional<T>, optional<Expected> >
 105       : is_substitute<T, Expected> {};
 106
 107     template <typename T>
 108     struct is_substitute<T, T
 109           , typename enable_if<not_is_optional<T> >::type>
 110       : mpl::true_ {};
 111
 112     ///////////////////////////////////////////////////////////////////////////
 113     // Find out if T can be a weak substitute for Expected attribute
 114     namespace detail
 115     {
 116         // A type, which is convertible to the attribute is at the same time
 117         // usable as its weak substitute.
 118         template <typename T, typename Expected, typename Enable = void>
 119         struct is_weak_substitute_impl : is_convertible<T, Expected> {};
 120
 121 //        // An exposed attribute is a weak substitute for a supplied container
 122 //        // attribute if it is a weak substitute for its value_type. This is
 123 //        // true as all character parsers are compatible with a container
 124 //        // attribute having the corresponding character type as its value_type.
 125 //        template <typename T, typename Expected>
 126 //        struct is_weak_substitute_for_value_type
 127 //          : is_weak_substitute<T, typename container_value<Expected>::type>
 128 //        {};
 129 //
 130 //        template <typename T, typename Expected>
 131 //        struct is_weak_substitute_impl<T, Expected,
 132 //            typename enable_if<
 133 //                mpl::and_<
 134 //                    mpl::not_<is_string<T> >
 135 //                  , is_string<Expected>
 136 //                  , is_weak_substitute_for_value_type<T, Expected> >
 137 //            >::type>
 138 //          : mpl::true_
 139 //        {};
 140
 141         // An exposed container attribute is a weak substitute for a supplied
 142         // container attribute if and only if their value_types are weak
 143         // substitutes.
 144         template <typename T, typename Expected>
 145         struct value_type_is_weak_substitute
 146           : is_weak_substitute<
 147                 typename container_value<T>::type
 148               , typename container_value<Expected>::type>
 149         {};
 150
 151         template <typename T, typename Expected>
 152         struct is_weak_substitute_impl<T, Expected,
 153             typename enable_if<
 154                 mpl::and_<
 155                     is_container<T>
 156                   , is_container<Expected>
 157                   , value_type_is_weak_substitute<T, Expected> >
 158             >::type>
 159           : mpl::true_ {};
 160
 161         // Two fusion sequences are weak substitutes if and only if their
 162         // elements are pairwise weak substitutes.
 163         template <typename T, typename Expected>
 164         struct is_weak_substitute_impl<T, Expected,
 165             typename enable_if<
 166                 mpl::and_<
 167                     fusion::traits::is_sequence<T>
 168                   , fusion::traits::is_sequence<Expected>
 169                   , mpl::equal<T, Expected, is_weak_substitute<mpl::_1, mpl::_2> > >
 170             >::type>
 171           : mpl::true_ {};
 172
 173         // If this is not defined, the main template definition above will return
 174         // true if T is convertible to the first type in a fusion::vector. We
 175         // globally declare any non-Fusion sequence T as not compatible with any
 176         // Fusion sequence 'Expected'.
 177         template <typename T, typename Expected>
 178         struct is_weak_substitute_impl<T, Expected,
 179             typename enable_if<
 180                 mpl::and_<
 181                     mpl::not_<fusion::traits::is_sequence<T> >
 182                   , fusion::traits::is_sequence<Expected> >
 183             >::type>
 184           : mpl::false_ {};
 185     }
 186
 187     // main template forwards to detail namespace, this helps older compilers
 188     // to disambiguate things
 189     template <typename T, typename Expected, typename Enable /*= void*/>
 190     struct is_weak_substitute
 191       : detail::is_weak_substitute_impl<T, Expected> {};
 192
 193     template <typename T, typename Expected>
 194     struct is_weak_substitute<optional<T>, optional<Expected> >
 195       : is_weak_substitute<T, Expected> {};
 196
 197     template <typename T, typename Expected>
 198     struct is_weak_substitute<optional<T>, Expected>
 199       : is_weak_substitute<T, Expected> {};
 200
 201     template <typename T, typename Expected>
 202     struct is_weak_substitute<T, optional<Expected> >
 203       : is_weak_substitute<T, Expected> {};
 204
 205 #if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
 206     template <typename T, typename Expected>
 207     struct is_weak_substitute<boost::variant<T>, Expected>
 208       : is_weak_substitute<T, Expected>
 209     {};
 210
 211     template <typename T0, typename T1, typename ...TN, typename Expected>
 212     struct is_weak_substitute<boost::variant<T0, T1, TN...>,
 213             Expected>
 214       : mpl::bool_<is_weak_substitute<T0, Expected>::type::value &&
 215             is_weak_substitute<boost::variant<T1, TN...>, Expected>::type::value>
 216     {};
 217 #else
 218 #define BOOST_SPIRIT_IS_WEAK_SUBSTITUTE(z, N, _)                              \
 219     is_weak_substitute<BOOST_PP_CAT(T, N), Expected>::type::value &&          \
 220     /***/
 221
 222     // make sure unused variant parameters do not affect the outcome
 223     template <typename Expected>
 224     struct is_weak_substitute<boost::detail::variant::void_, Expected>
 225       : mpl::true_
 226     {};
 227
 228     template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Expected>
 229     struct is_weak_substitute<
 230             boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Expected>
 231       : mpl::bool_<BOOST_PP_REPEAT(BOOST_VARIANT_LIMIT_TYPES
 232           , BOOST_SPIRIT_IS_WEAK_SUBSTITUTE, _) true>
 233     {};
 234
 235 #undef BOOST_SPIRIT_IS_WEAK_SUBSTITUTE
 236 #endif
 237
 238     template <typename T>
 239     struct is_weak_substitute<T, T
 240           , typename enable_if<
 241                 mpl::and_<not_is_optional<T>, not_is_variant<T> >
 242             >::type>
 243       : mpl::true_ {};
 244
 245     ///////////////////////////////////////////////////////////////////////////
 246     template <typename T, typename Enable/* = void*/>
 247     struct is_proxy : mpl::false_ {};
 248
 249     template <typename T>
 250     struct is_proxy<T,
 251         typename enable_if<
 252             mpl::and_<
 253                 fusion::traits::is_sequence<T>,
 254                 fusion::traits::is_view<T>
 255             >
 256         >::type>
 257       : mpl::true_ {};
 258
 259     namespace detail
 260     {
 261         // By declaring a nested struct in your class/struct, you tell
 262         // spirit that it is regarded as a variant type. The minimum
 263         // required interface for such a variant is that it has constructors
 264         // for various types supported by your variant and a typedef 'types'
 265         // which is an mpl sequence of the contained types.
 266         //
 267         // This is an intrusive interface. For a non-intrusive interface,
 268         // use the not_is_variant trait.
 269         BOOST_MPL_HAS_XXX_TRAIT_DEF(adapted_variant_tag)
 270     }
 271
 272     template <typename T, typename Domain, typename Enable/* = void*/>
 273     struct not_is_variant
 274       : mpl::not_<detail::has_adapted_variant_tag<T> >
 275     {};
 276
 277     template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Domain>
 278     struct not_is_variant<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Domain>
 279       : mpl::false_
 280     {};
 281
 282     // we treat every type as if it where the variant (as this meta function is
 283     // invoked for variant types only)
 284     template <typename T>
 285     struct variant_type
 286       : mpl::identity<T>
 287     {};
 288
 289     template <typename T>
 290     struct variant_type<boost::optional<T> >
 291       : variant_type<T>
 292     {};
 293
 294     template <typename T, typename Domain>
 295     struct not_is_variant_or_variant_in_optional
 296       : not_is_variant<typename variant_type<T>::type, Domain>
 297     {};
 298
 299     ///////////////////////////////////////////////////////////////////////////
 300     // The compute_compatible_component_variant
 301     ///////////////////////////////////////////////////////////////////////////
 302     namespace detail
 303     {
 304         //  A component is compatible to a given Attribute type if the
 305         //  Attribute is the same as the expected type of the component or if
 306         //  it is convertible to the expected type.
 307         template <typename Expected, typename Attribute>
 308         struct attribute_is_compatible
 309           : is_convertible<Attribute, Expected>
 310         {};
 311
 312         template <typename Expected, typename Attribute>
 313         struct attribute_is_compatible<Expected, boost::optional<Attribute> >
 314           : is_convertible<Attribute, Expected>
 315         {};
 316
 317         template <typename Container>
 318         struct is_hold_any_container
 319           : traits::is_hold_any<typename traits::container_value<Container>::type>
 320         {};
 321     }
 322
 323     template <typename Attribute, typename Expected
 324       , typename IsNotVariant = mpl::false_, typename Enable = void>
 325     struct compute_compatible_component_variant
 326       : mpl::or_<
 327             traits::detail::attribute_is_compatible<Expected, Attribute>
 328           , traits::is_hold_any<Expected>
 329           , mpl::eval_if<
 330                 is_container<Expected>
 331               , traits::detail::is_hold_any_container<Expected>
 332               , mpl::false_> >
 333     {};
 334
 335     namespace detail
 336     {
 337         BOOST_MPL_HAS_XXX_TRAIT_DEF(types)
 338     }
 339
 340     template <typename Variant, typename Expected>
 341     struct compute_compatible_component_variant<Variant, Expected, mpl::false_
 342       , typename enable_if<detail::has_types<typename variant_type<Variant>::type> >::type>
 343     {
 344         typedef typename traits::variant_type<Variant>::type variant_type;
 345         typedef typename variant_type::types types;
 346         typedef typename mpl::end<types>::type end;
 347
 348         typedef typename
 349             mpl::find_if<types, is_same<Expected, mpl::_1> >::type
 350         iter;
 351
 352         typedef typename mpl::distance<
 353             typename mpl::begin<types>::type, iter
 354         >::type distance;
 355
 356         // true_ if the attribute matches one of the types in the variant
 357         typedef typename mpl::not_<is_same<iter, end> >::type type;
 358         enum { value = type::value };
 359
 360         // return the type in the variant the attribute is compatible with
 361         typedef typename
 362             mpl::eval_if<type, mpl::deref<iter>, mpl::identity<unused_type> >::type
 363         compatible_type;
 364
 365         // return whether the given type is compatible with the Expected type
 366         static bool is_compatible(int which)
 367         {
 368             return which == distance::value;
 369         }
 370     };
 371
 372     template <typename Expected, typename Attribute, typename Domain>
 373     struct compute_compatible_component
 374       : compute_compatible_component_variant<Attribute, Expected
 375           , typename not_is_variant_or_variant_in_optional<Attribute, Domain>::type> {};
 376
 377     template <typename Expected, typename Domain>
 378     struct compute_compatible_component<Expected, unused_type, Domain>
 379       : mpl::false_ {};
 380
 381     template <typename Attribute, typename Domain>
 382     struct compute_compatible_component<unused_type, Attribute, Domain>
 383       : mpl::false_ {};
 384
 385     template <typename Domain>
 386     struct compute_compatible_component<unused_type, unused_type, Domain>
 387       : mpl::false_ {};
 388
 389     ///////////////////////////////////////////////////////////////////////////
 390     // return the type currently stored in the given variant
 391     template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
 392     struct variant_which<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
 393     {
 394         static int call(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& v)
 395         {
 396             return v.which();
 397         }
 398     };
 399
 400     template <typename T>
 401     int which(T const& v)
 402     {
 403         return variant_which<T>::call(v);
 404     }
 405
 406     ///////////////////////////////////////////////////////////////////////////
 407     template <typename T, typename Domain, typename Enable/* = void*/>
 408     struct not_is_optional
 409       : mpl::true_
 410     {};
 411
 412     template <typename T, typename Domain>
 413     struct not_is_optional<boost::optional<T>, Domain>
 414       : mpl::false_
 415     {};
 416
 417     ///////////////////////////////////////////////////////////////////////////
 418     // attribute_of
 419     //
 420     // Get the component's attribute
 421     ///////////////////////////////////////////////////////////////////////////
 422     template <typename Component
 423       , typename Context = unused_type, typename Iterator = unused_type>
 424     struct attribute_of
 425     {
 426         typedef typename Component::template
 427             attribute<Context, Iterator>::type type;
 428     };
 429
 430     ///////////////////////////////////////////////////////////////////////////
 431     // attribute_not_unused
 432     //
 433     // An mpl meta-function class that determines whether a component's
 434     // attribute is not unused.
 435     ///////////////////////////////////////////////////////////////////////////
 436     template <typename Context, typename Iterator = unused_type>
 437     struct attribute_not_unused
 438     {
 439         template <typename Component>
 440         struct apply
 441           : not_is_unused<typename
 442                 attribute_of<Component, Context, Iterator>::type>
 443         {};
 444     };
 445
 446     ///////////////////////////////////////////////////////////////////////////
 447     // Retrieve the attribute type to use from the given type
 448     //
 449     // This is needed to extract the correct attribute type from proxy classes
 450     // as utilized in FUSION_ADAPT_ADT et. al.
 451     ///////////////////////////////////////////////////////////////////////////
 452     template <typename Attribute, typename Enable/* = void*/>
 453     struct attribute_type : mpl::identity<Attribute> {};
 454
 455     ///////////////////////////////////////////////////////////////////////////
 456     // Retrieve the size of a fusion sequence (compile time)
 457     ///////////////////////////////////////////////////////////////////////////
 458     template <typename T>
 459     struct sequence_size
 460       : fusion::result_of::size<T>
 461     {};
 462
 463     template <>
 464     struct sequence_size<unused_type>
 465       : mpl::int_<0>
 466     {};
 467
 468     ///////////////////////////////////////////////////////////////////////////
 469     // Retrieve the size of an attribute (runtime)
 470     ///////////////////////////////////////////////////////////////////////////
 471     namespace detail
 472     {
 473         template <typename Attribute, typename Enable = void>
 474         struct attribute_size_impl
 475         {
 476             typedef std::size_t type;
 477
 478             static type call(Attribute const&)
 479             {
 480                 return 1;
 481             }
 482         };
 483
 484         template <typename Attribute>
 485         struct attribute_size_impl<Attribute
 486           , typename enable_if<
 487                 mpl::and_<
 488                     fusion::traits::is_sequence<Attribute>
 489                   , mpl::not_<traits::is_container<Attribute> >
 490                 >
 491             >::type>
 492         {
 493             typedef typename fusion::result_of::size<Attribute>::value_type type;
 494
 495             static type call(Attribute const& attr)
 496             {
 497                 return fusion::size(attr);
 498             }
 499         };
 500
 501         template <typename Attribute>
 502         struct attribute_size_impl<Attribute
 503           , typename enable_if<
 504                 mpl::and_<
 505                     traits::is_container<Attribute>
 506                   , mpl::not_<traits::is_iterator_range<Attribute> >
 507                 >
 508             >::type>
 509         {
 510             typedef typename Attribute::size_type type;
 511
 512             static type call(Attribute const& attr)
 513             {
 514                 return attr.size();
 515             }
 516         };
 517     }
 518
 519     template <typename Attribute, typename Enable/* = void*/>
 520     struct attribute_size
 521       : detail::attribute_size_impl<Attribute>
 522     {};
 523
 524     template <typename Attribute>
 525     struct attribute_size<optional<Attribute> >
 526     {
 527         typedef typename attribute_size<Attribute>::type type;
 528
 529         static type call(optional<Attribute> const& val)
 530         {
 531             if (!val)
 532                 return 0;
 533             return traits::size(val.get());
 534         }
 535     };
 536
 537     namespace detail
 538     {
 539         struct attribute_size_visitor : static_visitor<std::size_t>
 540         {
 541             template <typename T>
 542             std::size_t operator()(T const& val) const
 543             {
 544                 return spirit::traits::size(val);
 545             }
 546         };
 547     }
 548
 549     template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
 550     struct attribute_size<variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
 551     {
 552         typedef std::size_t type;
 553
 554         static type call(variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& val)
 555         {
 556             return apply_visitor(detail::attribute_size_visitor(), val);
 557         }
 558     };
 559
 560     template <typename Iterator>
 561     struct attribute_size<iterator_range<Iterator> >
 562     {
 563         typedef typename std::iterator_traits<Iterator>::
 564             difference_type type;
 565
 566         static type call(iterator_range<Iterator> const& r)
 567         {
 568             return std::distance(r.begin(), r.end());
 569         }
 570     };
 571
 572     template <>
 573     struct attribute_size<unused_type>
 574     {
 575         typedef std::size_t type;
 576
 577         static type call(unused_type)
 578         {
 579             return 0;
 580         }
 581     };
 582
 583     template <typename Attribute>
 584     typename attribute_size<Attribute>::type
 585     size (Attribute const& attr)
 586     {
 587         return attribute_size<Attribute>::call(attr);
 588     }
 589
 590     ///////////////////////////////////////////////////////////////////////////
 591     // pass_attribute
 592     //
 593     // Determines how we pass attributes to semantic actions. This
 594     // may be specialized. By default, all attributes are wrapped in
 595     // a fusion sequence, because the attribute has to be treated as being
 596     // a single value in any case (even if it actually already is a fusion
 597     // sequence in its own).
 598     ///////////////////////////////////////////////////////////////////////////
 599     template <typename Component, typename Attribute, typename Enable/* = void*/>
 600     struct pass_attribute
 601     {
 602         typedef fusion::vector1<Attribute&> type;
 603     };
 604
 605     ///////////////////////////////////////////////////////////////////////////
 606     // Subclass a pass_attribute specialization from this to wrap
 607     // the attribute in a tuple only IFF it is not already a fusion tuple.
 608     ///////////////////////////////////////////////////////////////////////////
 609     template <typename Attribute, typename Force = mpl::false_>
 610     struct wrap_if_not_tuple
 611       : mpl::if_<
 612             fusion::traits::is_sequence<Attribute>
 613           , Attribute&, fusion::vector1<Attribute&> >
 614     {};
 615
 616     template <typename Attribute>
 617     struct wrap_if_not_tuple<Attribute, mpl::true_>
 618     {
 619         typedef fusion::vector1<Attribute&> type;
 620     };
 621
 622     template <>
 623     struct wrap_if_not_tuple<unused_type, mpl::false_>
 624     {
 625         typedef unused_type type;
 626     };
 627
 628     template <>
 629     struct wrap_if_not_tuple<unused_type const, mpl::false_>
 630     {
 631         typedef unused_type type;
 632     };
 633
 634     ///////////////////////////////////////////////////////////////////////////
 635     // build_optional
 636     //
 637     // Build a boost::optional from T. Return unused_type if T is unused_type.
 638     ///////////////////////////////////////////////////////////////////////////
 639     template <typename T>
 640     struct build_optional
 641     {
 642         typedef boost::optional<T> type;
 643     };
 644
 645     template <typename T>
 646     struct build_optional<boost::optional<T> >
 647     {
 648         typedef boost::optional<T> type;
 649     };
 650
 651     template <>
 652     struct build_optional<unused_type>
 653     {
 654         typedef unused_type type;
 655     };
 656
 657     ///////////////////////////////////////////////////////////////////////////
 658     // build_std_vector
 659     //
 660     // Build a std::vector from T. Return unused_type if T is unused_type.
 661     ///////////////////////////////////////////////////////////////////////////
 662     template <typename T>
 663     struct build_std_vector
 664     {
 665         typedef std::vector<T> type;
 666     };
 667
 668     template <>
 669     struct build_std_vector<unused_type>
 670     {
 671         typedef unused_type type;
 672     };
 673
 674     ///////////////////////////////////////////////////////////////////////////
 675     // filter_unused_attributes
 676     //
 677     // Remove unused_types from a sequence
 678     ///////////////////////////////////////////////////////////////////////////
 679
 680     // Compute the list of all *used* attributes of sub-components
 681     // (filter all unused attributes from the list)
 682     template <typename Sequence>
 683     struct filter_unused_attributes
 684       : fusion::result_of::filter_if<Sequence, not_is_unused<mpl::_> >
 685     {};
 686
 687     ///////////////////////////////////////////////////////////////////////////
 688     // sequence_attribute_transform
 689     //
 690     // This transform is invoked for every attribute in a sequence allowing
 691     // to modify the attribute type exposed by a component to the enclosing
 692     // sequence component. By default no transformation is performed.
 693     ///////////////////////////////////////////////////////////////////////////
 694     template <typename Attribute, typename Domain>
 695     struct sequence_attribute_transform
 696       : mpl::identity<Attribute>
 697     {};
 698
 699     ///////////////////////////////////////////////////////////////////////////
 700     // permutation_attribute_transform
 701     //
 702     // This transform is invoked for every attribute in a sequence allowing
 703     // to modify the attribute type exposed by a component to the enclosing
 704     // permutation component. By default a build_optional transformation is
 705     // performed.
 706     ///////////////////////////////////////////////////////////////////////////
 707     template <typename Attribute, typename Domain>
 708     struct permutation_attribute_transform
 709       : traits::build_optional<Attribute>
 710     {};
 711
 712     ///////////////////////////////////////////////////////////////////////////
 713     // sequential_or_attribute_transform
 714     //
 715     // This transform is invoked for every attribute in a sequential_or allowing
 716     // to modify the attribute type exposed by a component to the enclosing
 717     // sequential_or component. By default a build_optional transformation is
 718     // performed.
 719     ///////////////////////////////////////////////////////////////////////////
 720     template <typename Attribute, typename Domain>
 721     struct sequential_or_attribute_transform
 722       : traits::build_optional<Attribute>
 723     {};
 724
 725     ///////////////////////////////////////////////////////////////////////////
 726     // build_fusion_vector
 727     //
 728     // Build a fusion vector from a fusion sequence. All unused attributes
 729     // are filtered out. If the result is empty after the removal of unused
 730     // types, return unused_type. If the input sequence is an unused_type,
 731     // also return unused_type.
 732     ///////////////////////////////////////////////////////////////////////////
 733     template <typename Sequence>
 734     struct build_fusion_vector
 735     {
 736         // Remove all unused attributes
 737         typedef typename
 738             filter_unused_attributes<Sequence>::type
 739         filtered_attributes;
 740
 741         // Build a fusion vector from a fusion sequence (Sequence),
 742         // But *only if* the sequence is not empty. i.e. if the
 743         // sequence is empty, our result will be unused_type.
 744
 745         typedef typename
 746             mpl::eval_if<
 747                 fusion::result_of::empty<filtered_attributes>
 748               , mpl::identity<unused_type>
 749               , fusion::result_of::as_vector<filtered_attributes>
 750             >::type
 751         type;
 752     };
 753
 754     template <>
 755     struct build_fusion_vector<unused_type>
 756     {
 757         typedef unused_type type;
 758     };
 759
 760     ///////////////////////////////////////////////////////////////////////////
 761     // build_attribute_sequence
 762     //
 763     // Build a fusion sequence attribute sequence from a sequence of
 764     // components. Transform<T>::type is called on each element.
 765     ///////////////////////////////////////////////////////////////////////////
 766     template <typename Sequence, typename Context
 767       , template <typename T, typename D> class Transform
 768       , typename Iterator = unused_type, typename Domain = unused_type>
 769     struct build_attribute_sequence
 770     {
 771         struct element_attribute
 772         {
 773             template <typename T>
 774             struct result;
 775
 776             template <typename F, typename Element>
 777             struct result<F(Element)>
 778             {
 779                 typedef typename
 780                     Transform<
 781                         typename attribute_of<Element, Context, Iterator>::type
 782                       , Domain
 783                     >::type
 784                 type;
 785             };
 786
 787             // never called, but needed for decltype-based result_of (C++0x)
 788 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
 789             template <typename Element>
 790             typename result<element_attribute(Element)>::type
 791             operator()(Element&&) const;
 792 #endif
 793         };
 794
 795         // Compute the list of attributes of all sub-components
 796         typedef typename
 797             fusion::result_of::transform<Sequence, element_attribute>::type
 798         type;
 799     };
 800
 801     ///////////////////////////////////////////////////////////////////////////
 802     // has_no_unused
 803     //
 804     // Test if there are no unused attributes in Sequence
 805     ///////////////////////////////////////////////////////////////////////////
 806     template <typename Sequence>
 807     struct has_no_unused
 808       : is_same<
 809             typename mpl::find_if<Sequence, is_same<mpl::_, unused_type> >::type
 810           , typename mpl::end<Sequence>::type>
 811     {};
 812
 813     namespace detail
 814     {
 815         template <typename Sequence, bool no_unused
 816             , int size = mpl::size<Sequence>::value>
 817         struct build_collapsed_variant;
 818
 819         // N element case, no unused
 820         template <typename Sequence, int size>
 821         struct build_collapsed_variant<Sequence, true, size>
 822             : spirit::detail::as_variant<Sequence> {};
 823
 824         // N element case with unused
 825         template <typename Sequence, int size>
 826         struct build_collapsed_variant<Sequence, false, size>
 827         {
 828             typedef boost::optional<
 829                 typename spirit::detail::as_variant<
 830                     typename fusion::result_of::pop_front<Sequence>::type
 831                 >::type
 832             > type;
 833         };
 834
 835         // 1 element case, no unused
 836         template <typename Sequence>
 837         struct build_collapsed_variant<Sequence, true, 1>
 838             : mpl::front<Sequence> {};
 839
 840         // 1 element case, with unused
 841         template <typename Sequence>
 842         struct build_collapsed_variant<Sequence, false, 1>
 843             : mpl::front<Sequence> {};
 844
 845         // 2 element case, no unused
 846         template <typename Sequence>
 847         struct build_collapsed_variant<Sequence, true, 2>
 848             : spirit::detail::as_variant<Sequence> {};
 849
 850         // 2 element case, with unused
 851         template <typename Sequence>
 852         struct build_collapsed_variant<Sequence, false, 2>
 853         {
 854             typedef boost::optional<
 855                 typename mpl::deref<
 856                     typename mpl::next<
 857                         typename mpl::begin<Sequence>::type
 858                     >::type
 859                 >::type
 860             >
 861             type;
 862         };
 863     }
 864
 865     ///////////////////////////////////////////////////////////////////////////
 866     // alternative_attribute_transform
 867     //
 868     // This transform is invoked for every attribute in an alternative allowing
 869     // to modify the attribute type exposed by a component to the enclosing
 870     // alternative component. By default no transformation is performed.
 871     ///////////////////////////////////////////////////////////////////////////
 872     template <typename Attribute, typename Domain>
 873     struct alternative_attribute_transform
 874       : mpl::identity<Attribute>
 875     {};
 876
 877     ///////////////////////////////////////////////////////////////////////////
 878     // build_variant
 879     //
 880     // Build a boost::variant from a fusion sequence. build_variant makes sure
 881     // that 1) all attributes in the variant are unique 2) puts the unused
 882     // attribute, if there is any, to the front and 3) collapses single element
 883     // variants, variant<T> to T.
 884     ///////////////////////////////////////////////////////////////////////////
 885     template <typename Sequence>
 886     struct build_variant
 887     {
 888         // Remove all unused attributes.
 889         typedef typename
 890             filter_unused_attributes<Sequence>::type
 891         filtered_attributes;
 892
 893         typedef has_no_unused<Sequence> no_unused;
 894
 895         // If the original attribute list does not contain any unused
 896         // attributes, it is used, otherwise a single unused_type is
 897         // pushed to the front of the list. This is to make sure that if
 898         // there is an unused_type in the list, it is the first one.
 899         typedef typename
 900             mpl::eval_if<
 901                 no_unused,
 902                 mpl::identity<Sequence>,
 903                 fusion::result_of::push_front<filtered_attributes, unused_type>
 904             >::type
 905         attribute_sequence;
 906
 907         // Make sure each of the types occur only once in the type list
 908         typedef typename
 909             mpl::fold<
 910                 attribute_sequence, mpl::vector<>,
 911                 mpl::if_<
 912                     mpl::contains<mpl::_1, mpl::_2>,
 913                     mpl::_1, mpl::push_back<mpl::_1, mpl::_2>
 914                 >
 915             >::type
 916         no_duplicates;
 917
 918         // If there is only one type in the list of types we strip off the
 919         // variant. IOTW, collapse single element variants, variant<T> to T.
 920         // Take note that this also collapses variant<unused_type, T> to T.
 921         typedef typename
 922             traits::detail::build_collapsed_variant<
 923                 no_duplicates, no_unused::value>::type
 924         type;
 925     };
 926
 927     namespace detail {
 928         // Domain-agnostic class template partial specializations and
 929         // type agnostic domain partial specializations are ambious.
 930         // To resolve the ambiguity type agnostic domain partial
 931         // specializations are dispatched via intermediate type.
 932         template <typename Exposed, typename Transformed, typename Domain>
 933         struct transform_attribute_base;
 934
 935         template <typename Attribute>
 936         struct synthesize_attribute
 937         {
 938             typedef Attribute type;
 939             static Attribute pre(unused_type) { return Attribute(); }
 940             static void post(unused_type, Attribute const&) {}
 941             static void fail(unused_type) {}
 942         };
 943     }
 944     ///////////////////////////////////////////////////////////////////////////
 945     //  transform_attribute
 946     //
 947     //  Sometimes the user needs to transform the attribute types for certain
 948     //  attributes. This template can be used as a customization point, where
 949     //  the user is able specify specific transformation rules for any attribute
 950     //  type.
 951     //
 952     //  Note: the transformations involving unused_type are internal details
 953     //  and may be subject to change at any time.
 954     //
 955     ///////////////////////////////////////////////////////////////////////////
 956     template <typename Exposed, typename Transformed, typename Domain
 957       , typename Enable/* = void*/>
 958     struct transform_attribute
 959       : detail::transform_attribute_base<Exposed, Transformed, Domain>
 960     {
 961         BOOST_STATIC_ASSERT_MSG(!is_reference<Exposed>::value,
 962             "Exposed cannot be a reference type");
 963         BOOST_STATIC_ASSERT_MSG(!is_reference<Transformed>::value,
 964             "Transformed cannot be a reference type");
 965     };
 966
 967     template <typename Transformed, typename Domain>
 968     struct transform_attribute<unused_type, Transformed, Domain>
 969       : detail::synthesize_attribute<Transformed>
 970     {};
 971
 972     template <typename Transformed, typename Domain>
 973     struct transform_attribute<unused_type const, Transformed, Domain>
 974       : detail::synthesize_attribute<Transformed>
 975     {};
 976
 977     ///////////////////////////////////////////////////////////////////////////
 978     // swap_impl
 979     //
 980     // Swap (with proper handling of unused_types)
 981     ///////////////////////////////////////////////////////////////////////////
 982     template <typename A, typename B>
 983     void swap_impl(A& a, B& b)
 984     {
 985         A temp = a;
 986         a = b;
 987         b = temp;
 988     }
 989
 990     template <typename T>
 991     void swap_impl(T& a, T& b)
 992     {
 993         boost::swap(a, b);
 994     }
 995
 996     template <typename A>
 997     void swap_impl(A&, unused_type)
 998     {
 999     }
1000
1001     template <typename A>
1002     void swap_impl(unused_type, A&)
1003     {
1004     }
1005
1006     inline void swap_impl(unused_type, unused_type)
1007     {
1008     }
1009
1010     ///////////////////////////////////////////////////////////////////////////
1011     //  Strips single element fusion vectors into its 'naked'
1012     //  form: vector<T> --> T
1013     ///////////////////////////////////////////////////////////////////////////
1014     template <typename T>
1015     struct strip_single_element_vector
1016     {
1017         typedef T type;
1018     };
1019
1020 #if !defined(BOOST_FUSION_HAS_VARIADIC_VECTOR)
1021     template <typename T>
1022     struct strip_single_element_vector<fusion::vector1<T> >
1023     {
1024         typedef T type;
1025     };
1026 #endif
1027     template <typename T>
1028     struct strip_single_element_vector<fusion::vector<T> >
1029     {
1030         typedef T type;
1031     };
1032
1033     ///////////////////////////////////////////////////////////////////////////
1034     // meta function to return whether the argument is a one element fusion
1035     // sequence
1036     ///////////////////////////////////////////////////////////////////////////
1037     template <typename T
1038       , bool IsFusionSeq = fusion::traits::is_sequence<T>::value
1039       , bool IsProtoExpr = proto::is_expr<T>::value>
1040     struct one_element_sequence
1041       : mpl::false_
1042     {};
1043
1044     template <typename T>
1045     struct one_element_sequence<T, true, false>
1046       : mpl::bool_<mpl::size<T>::value == 1>
1047     {};
1048
1049     ///////////////////////////////////////////////////////////////////////////
1050     // clear
1051     //
1052     // Clear data efficiently
1053     ///////////////////////////////////////////////////////////////////////////
1054     template <typename T>
1055     void clear(T& val);
1056
1057     namespace detail
1058     {
1059         // this is used by the variant and fusion sequence dispatch
1060         struct clear_visitor : static_visitor<>
1061         {
1062             template <typename T>
1063             void operator()(T& val) const
1064             {
1065                 spirit::traits::clear(val);
1066             }
1067         };
1068
1069         // default
1070         template <typename T>
1071         void clear_impl2(T& val, mpl::false_)
1072         {
1073             val = T();
1074         }
1075
1076         // for fusion sequences
1077         template <typename T>
1078         void clear_impl2(T& val, mpl::true_)
1079         {
1080             fusion::for_each(val, clear_visitor());
1081         }
1082
1083         // dispatch default or fusion sequence
1084         template <typename T>
1085         void clear_impl(T& val, mpl::false_)
1086         {
1087             clear_impl2(val, fusion::traits::is_sequence<T>());
1088         }
1089
1090         // STL containers
1091         template <typename T>
1092         void clear_impl(T& val, mpl::true_)
1093         {
1094             val.clear();
1095         }
1096     }
1097
1098     template <typename T, typename Enable/* = void*/>
1099     struct clear_value
1100     {
1101         static void call(T& val)
1102         {
1103             detail::clear_impl(val, typename is_container<T>::type());
1104         }
1105     };
1106
1107     // optionals
1108     template <typename T>
1109     struct clear_value<boost::optional<T> >
1110     {
1111         static void call(boost::optional<T>& val)
1112         {
1113             if (val)
1114                 val = none;   // leave optional uninitialized
1115         }
1116     };
1117
1118     // variants
1119     template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
1120     struct clear_value<variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
1121     {
1122         static void call(variant<BOOST_VARIANT_ENUM_PARAMS(T)>& val)
1123         {
1124             apply_visitor(detail::clear_visitor(), val);
1125         }
1126     };
1127
1128     // iterator range
1129     template <typename T>
1130     struct clear_value<iterator_range<T> >
1131     {
1132         static void call(iterator_range<T>& val)
1133         {
1134             val = iterator_range<T>(val.end(), val.end());
1135         }
1136     };
1137
1138     // main dispatch
1139     template <typename T>
1140     void clear(T& val)
1141     {
1142         clear_value<T>::call(val);
1143     }
1144
1145     // for unused
1146     inline void clear(unused_type)
1147     {
1148     }
1149
1150     ///////////////////////////////////////////////////////////////////////////
1151     namespace detail
1152     {
1153         template <typename Out>
1154         struct print_fusion_sequence
1155         {
1156             print_fusion_sequence(Out& out_)
1157               : out(out_), is_first(true) {}
1158
1159             typedef void result_type;
1160
1161             template <typename T>
1162             void operator()(T const& val) const
1163             {
1164                 if (is_first)
1165                     is_first = false;
1166                 else
1167                     out << ", ";
1168                 spirit::traits::print_attribute(out, val);
1169             }
1170
1171             Out& out;
1172             mutable bool is_first;
1173         };
1174
1175         // print elements in a variant
1176         template <typename Out>
1177         struct print_visitor : static_visitor<>
1178         {
1179             print_visitor(Out& out_) : out(out_) {}
1180
1181             template <typename T>
1182             void operator()(T const& val) const
1183             {
1184                 spirit::traits::print_attribute(out, val);
1185             }
1186
1187             Out& out;
1188         };
1189     }
1190
1191     template <typename Out, typename T, typename Enable>
1192     struct print_attribute_debug
1193     {
1194         // for plain data types
1195         template <typename T_>
1196         static void call_impl3(Out& out, T_ const& val, mpl::false_)
1197         {
1198             out << val;
1199         }
1200
1201         // for fusion data types
1202         template <typename T_>
1203         static void call_impl3(Out& out, T_ const& val, mpl::true_)
1204         {
1205             out << '[';
1206             fusion::for_each(val, detail::print_fusion_sequence<Out>(out));
1207             out << ']';
1208         }
1209
1210         // non-stl container
1211         template <typename T_>
1212         static void call_impl2(Out& out, T_ const& val, mpl::false_)
1213         {
1214             call_impl3(out, val, fusion::traits::is_sequence<T_>());
1215         }
1216
1217         // stl container
1218         template <typename T_>
1219         static void call_impl2(Out& out, T_ const& val, mpl::true_)
1220         {
1221             out << '[';
1222             if (!traits::is_empty(val))
1223             {
1224                 bool first = true;
1225                 typename container_iterator<T_ const>::type iend = traits::end(val);
1226                 for (typename container_iterator<T_ const>::type i = traits::begin(val);
1227                      !traits::compare(i, iend); traits::next(i))
1228                 {
1229                     if (!first)
1230                         out << ", ";
1231                     first = false;
1232                     spirit::traits::print_attribute(out, traits::deref(i));
1233                 }
1234             }
1235             out << ']';
1236         }
1237
1238         // for variant types
1239         template <typename T_>
1240         static void call_impl(Out& out, T_ const& val, mpl::false_)
1241         {
1242             apply_visitor(detail::print_visitor<Out>(out), val);
1243         }
1244
1245         // for non-variant types
1246         template <typename T_>
1247         static void call_impl(Out& out, T_ const& val, mpl::true_)
1248         {
1249             call_impl2(out, val, is_container<T_>());
1250         }
1251
1252         // main entry point
1253         static void call(Out& out, T const& val)
1254         {
1255             call_impl(out, val, not_is_variant<T>());
1256         }
1257     };
1258
1259     template <typename Out, typename T>
1260     struct print_attribute_debug<Out, boost::optional<T> >
1261     {
1262         static void call(Out& out, boost::optional<T> const& val)
1263         {
1264             if (val)
1265                 spirit::traits::print_attribute(out, *val);
1266             else
1267                 out << "[empty]";
1268         }
1269     };
1270
1271     ///////////////////////////////////////////////////////////////////////////
1272     template <typename Out, typename T>
1273     inline void print_attribute(Out& out, T const& val)
1274     {
1275         print_attribute_debug<Out, T>::call(out, val);
1276     }
1277
1278     template <typename Out>
1279     inline void print_attribute(Out&, unused_type)
1280     {
1281     }
1282
1283     ///////////////////////////////////////////////////////////////////////////
1284     // generate debug output for lookahead token (character) stream
1285     namespace detail
1286     {
1287         struct token_printer_debug_for_chars
1288         {
1289             template<typename Out, typename Char>
1290             static void print(Out& o, Char c)
1291             {
1292                 using namespace std;    // allow for ADL to find the proper iscntrl
1293
1294                 if (c == static_cast<Char>('\a'))
1295                     o << "\\a";
1296                 else if (c == static_cast<Char>('\b'))
1297                     o << "\\b";
1298                 else if (c == static_cast<Char>('\f'))
1299                     o << "\\f";
1300                 else if (c == static_cast<Char>('\n'))
1301                     o << "\\n";
1302                 else if (c == static_cast<Char>('\r'))
1303                     o << "\\r";
1304                 else if (c == static_cast<Char>('\t'))
1305                     o << "\\t";
1306                 else if (c == static_cast<Char>('\v'))
1307                     o << "\\v";
1308                 else if (c >= 0 && c < 127 && iscntrl(c))
1309                     o << "\\" << std::oct << static_cast<int>(c);
1310                 else
1311                     o << static_cast<char>(c);
1312             }
1313         };
1314
1315         // for token types where the comparison with char constants wouldn't work
1316         struct token_printer_debug
1317         {
1318             template<typename Out, typename T>
1319             static void print(Out& o, T const& val)
1320             {
1321                 o << val;
1322             }
1323         };
1324     }
1325
1326     template <typename T, typename Enable>
1327     struct token_printer_debug
1328       : mpl::if_<
1329             mpl::and_<
1330                 is_convertible<T, char>, is_convertible<char, T> >
1331           , detail::token_printer_debug_for_chars
1332           , detail::token_printer_debug>::type
1333     {};
1334
1335     template <typename Out, typename T>
1336     inline void print_token(Out& out, T const& val)
1337     {
1338         // allow to customize the token printer routine
1339         token_printer_debug<T>::print(out, val);
1340     }
1341 }}}
1342
1343 #endif