/usr/include/boost/proto/transform
Edit: /usr/include/boost/proto/transform/pass_through.hpp (5067B)
///////////////////////////////////////////////////////////////////////////////
/// \file pass_through.hpp
///
/// Definition of the pass_through transform, which is the default transform
/// of all of the expression generator metafunctions such as unary_plus<>, plus<>
/// and nary_expr<>.
//
// 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_PASS_THROUGH_HPP_EAN_12_26_2006
#define BOOST_PROTO_TRANSFORM_PASS_THROUGH_HPP_EAN_12_26_2006
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#if defined(_MSC_VER)
# pragma warning(push)
# pragma warning(disable : 4714) // function 'xxx' marked as __forceinline not inlined
#endif
namespace boost { namespace proto
{
namespace detail
{
template<
typename Grammar
, typename Domain
, typename Expr
, typename State
, typename Data
, long Arity = arity_of::value
>
struct pass_through_impl
{};
#include
template
struct pass_through_impl
: transform_impl
{
typedef Expr result_type;
/// \param e An expression
/// \return \c e
/// \throw nothrow
BOOST_FORCEINLINE
BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, typename pass_through_impl::expr_param)
operator()(
typename pass_through_impl::expr_param e
, typename pass_through_impl::state_param
, typename pass_through_impl::data_param
) const
{
return e;
}
};
} // namespace detail
/// \brief A PrimitiveTransform that transforms the child expressions
/// of an expression node according to the corresponding children of
/// a Grammar.
///
/// Given a Grammar such as plus\, an expression type
/// that matches the grammar such as plus\::type, a
/// state \c S and a data \c V, the result of applying the
/// pass_through\ \> transform is:
///
/// \code
/// plus<
/// T0::result::type
/// , T1::result::type
/// >::type
/// \endcode
///
/// The above demonstrates how child transforms and child expressions
/// are applied pairwise, and how the results are reassembled into a new
/// expression node with the same tag type as the original.
///
/// The explicit use of pass_through\<\> is not usually needed,
/// since the expression generator metafunctions such as
/// plus\<\> have pass_through\<\> as their default
/// transform. So, for instance, these are equivalent:
///
/// \code
/// // Within a grammar definition, these are equivalent:
/// when< plus, pass_through< plus > >
/// when< plus, plus >
/// when< plus > // because of when
/// plus // because plus<> is both a
/// // grammar and a transform
/// \endcode
///
/// For example, consider the following transform that promotes all
/// \c float terminals in an expression to \c double.
///
/// \code
/// // This transform finds all float terminals in an expression and promotes
/// // them to doubles.
/// struct Promote
/// : or_<
/// when, terminal::type(_value) >
/// // terminal<>'s default transform is a no-op:
/// , terminal<_>
/// // nary_expr<> has a pass_through<> transform:
/// , nary_expr<_, vararg >
/// >
/// {};
/// \endcode
template
struct pass_through
: transform >
{
template
struct impl
: detail::pass_through_impl
{};
};
/// INTERNAL ONLY
///
template
struct is_callable >
: mpl::true_
{};
}} // namespace boost::proto
#if defined(_MSC_VER)
# pragma warning(pop)
#endif
#endif