Boost_1_39_0/boost/spirit/home/support/detail/values.hpp

   1 /*=============================================================================
   2     Copyright (c) 2001-2007 Joel de Guzman
   3     Copyright (c) 2001-2009 Hartmut Kaiser
   4     http://spirit.sourceforge.net/
   5
   6     Distributed under the Boost Software License, Version 1.0. (See accompanying
   7     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   8 =============================================================================*/
   9 #if !defined(BOOST_SPIRIT_VALUES_JAN_07_2007_0802PM)
  10 #define BOOST_SPIRIT_VALUES_JAN_07_2007_0802PM
  11
  12 #include <boost/fusion/include/is_sequence.hpp>
  13 #include <boost/fusion/include/vector.hpp>
  14 #include <boost/spirit/home/support/unused.hpp>
  15 #include <boost/utility/enable_if.hpp>
  16 #include <boost/mpl/bool.hpp>
  17 #include <boost/mpl/and.hpp>
  18 #include <boost/variant.hpp>
  19
  20 namespace boost { namespace spirit { namespace detail
  21 {
  22     template <typename T>
  23     struct not_is_variant
  24       : mpl::true_ {};
  25
  26     template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
  27     struct not_is_variant<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
  28       : mpl::false_ {};
  29
  30     ///////////////////////////////////////////////////////////////////////////
  31     //  All parsers and generators have specific attribute or parameter types.
  32     //  Spirit parsers are passed an attribute and Spirit generators
  33     //  are passed a parameter; these are either references to the expected
  34     //  type, or an unused_type -- to flag that we do not care about the
  35     //  attribute/parameter. For semantic actions, however, we need to have a
  36     //  real value to pass to the semantic action. If the client did not
  37     //  provide one, we will have to synthesize the value. This class
  38     //  takes care of that.
  39     ///////////////////////////////////////////////////////////////////////////
  40     template <typename ValueType>
  41     struct make_value
  42     {
  43         static ValueType call(unused_type)
  44         {
  45             return ValueType(); // synthesize the attribute/parameter
  46         }
  47
  48         template <typename T>
  49         static T& call(T& value)
  50         {
  51             return value; // just pass the one provided
  52         }
  53
  54         template <typename T>
  55         static T const& call(T const& value)
  56         {
  57             return value; // just pass the one provided
  58         }
  59     };
  60
  61     template <typename ValueType>
  62     struct make_value<ValueType&> : make_value<ValueType>
  63     {
  64     };
  65
  66     template <>
  67     struct make_value<unused_type>
  68     {
  69         static unused_type call(unused_type)
  70         {
  71             return unused;
  72         }
  73     };
  74
  75     ///////////////////////////////////////////////////////////////////////////
  76     //  pass_value determines how we pass attributes and parameters to semantic
  77     //  actions. Basically, all SAs receive the arguments in a tuple. So, if
  78     //  the argument to be passed is not a tuple, wrap it in one.
  79     ///////////////////////////////////////////////////////////////////////////
  80     template <typename ValueType>
  81     struct pass_value
  82     {
  83         typedef
  84             mpl::and_<
  85                 fusion::traits::is_sequence<ValueType>
  86               , detail::not_is_variant<ValueType>
  87             >
  88         is_sequence;
  89
  90         typedef typename
  91             mpl::if_<
  92                 is_sequence
  93               , ValueType&
  94               , fusion::vector<ValueType&> const
  95             >::type
  96         type;
  97
  98         static ValueType&
  99         call(ValueType& arg, mpl::true_)
 100         {
 101             // arg is a fusion sequence (except a variant) return it as-is.
 102             return arg;
 103         }
 104
 105         static fusion::vector<ValueType&> const
 106         call(ValueType& seq, mpl::false_)
 107         {
 108             // arg is a not fusion sequence wrap it in a fusion::vector.
 109             return fusion::vector<ValueType&>(seq);
 110         }
 111
 112         static type
 113         call(ValueType& arg)
 114         {
 115             return call(arg, is_sequence());
 116         }
 117     };
 118 }}}
 119
 120 #endif