diff options
Diffstat (limited to '3rdParty/Boost/src/boost/proto/transform/arg.hpp')
-rw-r--r-- | 3rdParty/Boost/src/boost/proto/transform/arg.hpp | 359 |
1 files changed, 359 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/proto/transform/arg.hpp b/3rdParty/Boost/src/boost/proto/transform/arg.hpp new file mode 100644 index 0000000..9fdf80e --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/transform/arg.hpp @@ -0,0 +1,359 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \file arg.hpp +/// Contains definition of the argN transforms. +// +// Copyright 2008 Eric Niebler. Distributed under the Boost +// Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_PROTO_TRANSFORM_ARG_HPP_EAN_11_01_2007 +#define BOOST_PROTO_TRANSFORM_ARG_HPP_EAN_11_01_2007 + +#include <boost/mpl/if.hpp> +#include <boost/proto/proto_fwd.hpp> +#include <boost/proto/traits.hpp> +#include <boost/proto/transform/impl.hpp> +#include <boost/type_traits/is_array.hpp> +#include <boost/proto/transform/env.hpp> + +namespace boost { namespace proto +{ + + /// \brief A PrimitiveTransform that returns the current expression + /// unmodified + /// + /// Example: + /// + /// \code + /// proto::terminal<int>::type i = {42}; + /// proto::terminal<int>::type & j = proto::_expr()(i); + /// assert( boost::addressof(i) == boost::addressof(j) ); + /// \endcode + struct _expr : transform<_expr> + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef Expr result_type; + + /// Returns the current expression. + /// \param e The current expression. + /// \return \c e + /// \throw nothrow + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::expr_param) + operator()( + typename impl::expr_param e + , typename impl::state_param + , typename impl::data_param + ) const + { + return e; + } + }; + }; + + /// \brief A PrimitiveTransform that returns the current state + /// unmodified + /// + /// Example: + /// + /// \code + /// proto::terminal<int>::type i = {42}; + /// char ch = proto::_state()(i, 'a'); + /// assert( ch == 'a' ); + /// \endcode + struct _state : transform<_state> + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef State result_type; + + /// Returns the current state. + /// \param s The current state. + /// \return \c s + /// \throw nothrow + BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename impl::state_param) + operator ()( + typename impl::expr_param + , typename impl::state_param s + , typename impl::data_param + ) const + { + return s; + } + }; + }; + + /// \brief A PrimitiveTransform that returns the current data + /// unmodified + /// + /// Example: + /// + /// \code + /// proto::terminal<int>::type i = {42}; + /// std::string str("hello"); + /// std::string & data = proto::_data()(i, 'a', str); + /// assert( &str == &data ); + /// \endcode + struct _data : transform<_data> + { + template<typename Expr, typename State, typename Data> + struct impl + : mpl::if_c< + is_env<Data>::value + , _env_var<data_type> + , _env + >::type::template impl<Expr, State, Data> + {}; + }; + + /// \brief A PrimitiveTransform that returns N-th child of the current + /// expression. + /// + /// Example: + /// + /// \code + /// proto::terminal<int>::type i = {42}; + /// proto::terminal<int>::type & j = proto::_child_c<0>()(-i); + /// assert( boost::addressof(i) == boost::addressof(j) ); + /// \endcode + template<int N> + struct _child_c : transform<_child_c<N> > + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef + typename result_of::child_c<Expr, N>::type + result_type; + + /// Returns the N-th child of \c e + /// \pre <tt>arity_of\<Expr\>::value \> N</tt> + /// \param e The current expression. + /// \return <tt>proto::child_c\<N\>(e)</tt> + /// \throw nothrow + #ifdef BOOST_PROTO_STRICT_RESULT_OF + result_type + #else + typename result_of::child_c<typename impl::expr_param, N>::type + #endif + operator ()( + typename impl::expr_param e + , typename impl::state_param + , typename impl::data_param + ) const + { + return proto::child_c<N>(e); + } + }; + }; + + /// \brief A PrimitiveTransform that returns the value of the + /// current terminal expression. + /// + /// Example: + /// + /// \code + /// proto::terminal<int>::type i = {42}; + /// int j = proto::_value()(i); + /// assert( 42 == j ); + /// \endcode + struct _value : transform<_value> + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef + typename result_of::value<Expr>::type + result_type; + + /// Returns the value of the specified terminal expression. + /// \pre <tt>arity_of\<Expr\>::value == 0</tt>. + /// \param e The current expression. + /// \return <tt>proto::value(e)</tt> + /// \throw nothrow + #ifdef BOOST_PROTO_STRICT_RESULT_OF + typename mpl::if_c<is_array<result_type>::value, result_type &, result_type>::type + #else + typename result_of::value<typename impl::expr_param>::type + #endif + operator ()( + typename impl::expr_param e + , typename impl::state_param + , typename impl::data_param + ) const + { + return proto::value(e); + } + }; + }; + + /// \brief A PrimitiveTransform that does nothing + /// and returns void. + struct _void : transform<_void> + { + template<typename Expr, typename State, typename Data> + struct impl : transform_impl<Expr, State, Data> + { + typedef void result_type; + + /// Does nothing and returns void + void operator ()( + typename impl::expr_param + , typename impl::state_param + , typename impl::data_param + ) const + {} + }; + }; + + /// \brief A unary CallableTransform that wraps its argument + /// in a \c boost::reference_wrapper\<\>. + /// + /// Example: + /// + /// \code + /// proto::terminal<int>::type i = {42}; + /// boost::reference_wrapper<proto::terminal<int>::type> j + /// = proto::when<_, proto::_byref(_)>()(i); + /// assert( boost::addressof(i) == boost::addressof(j.get()) ); + /// \endcode + struct _byref : callable + { + template<typename Sig> + struct result; + + template<typename This, typename T> + struct result<This(T)> + { + typedef boost::reference_wrapper<T const> const type; + }; + + template<typename This, typename T> + struct result<This(T &)> + { + typedef boost::reference_wrapper<T> const type; + }; + + /// Wrap the parameter \c t in a \c boost::reference_wrapper\<\> + /// \param t The object to wrap + /// \return <tt>boost::ref(t)</tt> + /// \throw nothrow + template<typename T> + boost::reference_wrapper<T> const operator ()(T &t) const + { + return boost::reference_wrapper<T>(t); + } + + /// \overload + /// + template<typename T> + boost::reference_wrapper<T const> const operator ()(T const &t) const + { + return boost::reference_wrapper<T const>(t); + } + }; + + /// \brief A unary CallableTransform that strips references + /// and \c boost::reference_wrapper\<\> from its argument. + /// + /// Example: + /// + /// \code + /// proto::terminal<int>::type i = {42}; + /// int j = 67; + /// int k = proto::when<_, proto::_byval(proto::_state)>()(i, boost::ref(j)); + /// assert( 67 == k ); + /// \endcode + struct _byval : callable + { + template<typename Sig> + struct result; + + template<typename This, typename T> + struct result<This(T)> + { + typedef T type; + }; + + template<typename This, typename T> + struct result<This(T &)> + : result<This(T)> + {}; + + template<typename This, typename T> + struct result<This(boost::reference_wrapper<T>)> + : result<This(T)> + {}; + + /// \param t The object to unref + /// \return <tt>t</tt> + /// \throw nothrow + template<typename T> + T operator ()(T const &t) const + { + return t; + } + + /// \overload + /// + template<typename T> + T operator ()(boost::reference_wrapper<T> const &t) const + { + return t; + } + }; + + /// INTERNAL ONLY + /// + template<> + struct is_callable<_expr> + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<> + struct is_callable<_state> + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<> + struct is_callable<_data> + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<int N> + struct is_callable<_child_c<N> > + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<> + struct is_callable<_value> + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<> + struct is_callable<_byref> + : mpl::true_ + {}; + + /// INTERNAL ONLY + /// + template<> + struct is_callable<_byval> + : mpl::true_ + {}; + +}} + +#endif |