/////////////////////////////////////////////////////////////////////////////// | |
/// \file impl.hpp | |
/// Contains definition of transform<> and transform_impl<> helpers. | |
// | |
// 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_IMPL_HPP_EAN_04_03_2008 | |
#define BOOST_PROTO_TRANSFORM_IMPL_HPP_EAN_04_03_2008 | |
#include <boost/proto/proto_fwd.hpp> | |
namespace boost { namespace proto | |
{ | |
/// INTERNAL ONLY | |
/// | |
#define BOOST_PROTO_TRANSFORM_(PrimitiveTransform, X) \ | |
BOOST_PROTO_CALLABLE() \ | |
typedef X proto_is_transform_; \ | |
typedef PrimitiveTransform transform_type; \ | |
\ | |
template<typename Sig> \ | |
struct result \ | |
{ \ | |
typedef typename boost::proto::detail::apply_transform<Sig>::result_type type; \ | |
}; \ | |
\ | |
template<typename Expr> \ | |
typename boost::proto::detail::apply_transform<transform_type(Expr &)>::result_type \ | |
operator ()(Expr &e) const \ | |
{ \ | |
int i = 0; \ | |
return boost::proto::detail::apply_transform<transform_type(Expr &)>()(e, i, i); \ | |
} \ | |
\ | |
template<typename Expr, typename State> \ | |
typename boost::proto::detail::apply_transform<transform_type(Expr &, State &)>::result_type \ | |
operator ()(Expr &e, State &s) const \ | |
{ \ | |
int i = 0; \ | |
return boost::proto::detail::apply_transform<transform_type(Expr &, State &)>()(e, s, i); \ | |
} \ | |
\ | |
template<typename Expr, typename State> \ | |
typename boost::proto::detail::apply_transform<transform_type(Expr &, State const &)>::result_type \ | |
operator ()(Expr &e, State const &s) const \ | |
{ \ | |
int i = 0; \ | |
return boost::proto::detail::apply_transform<transform_type(Expr &, State const &)>()(e, s, i); \ | |
} \ | |
\ | |
template<typename Expr, typename State, typename Data> \ | |
typename boost::proto::detail::apply_transform<transform_type(Expr &, State &, Data &)>::result_type \ | |
operator ()(Expr &e, State &s, Data &d) const \ | |
{ \ | |
return boost::proto::detail::apply_transform<transform_type(Expr &, State &, Data &)>()(e, s, d); \ | |
} \ | |
\ | |
template<typename Expr, typename State, typename Data> \ | |
typename boost::proto::detail::apply_transform<transform_type(Expr &, State const &, Data &)>::result_type \ | |
operator ()(Expr &e, State const &s, Data &d) const \ | |
{ \ | |
return boost::proto::detail::apply_transform<transform_type(Expr &, State const &, Data &)>()(e, s, d); \ | |
} \ | |
/**/ | |
#define BOOST_PROTO_TRANSFORM(PrimitiveTransform) \ | |
BOOST_PROTO_TRANSFORM_(PrimitiveTransform, void) \ | |
/**/ | |
namespace detail | |
{ | |
template<typename Sig> | |
struct apply_transform; | |
template<typename PrimitiveTransform, typename Expr> | |
struct apply_transform<PrimitiveTransform(Expr)> | |
: PrimitiveTransform::template impl<Expr, int, int> | |
{}; | |
template<typename PrimitiveTransform, typename Expr, typename State> | |
struct apply_transform<PrimitiveTransform(Expr, State)> | |
: PrimitiveTransform::template impl<Expr, State, int> | |
{}; | |
template<typename PrimitiveTransform, typename Expr, typename State, typename Data> | |
struct apply_transform<PrimitiveTransform(Expr, State, Data)> | |
: PrimitiveTransform::template impl<Expr, State, Data> | |
{}; | |
} | |
template<typename PrimitiveTransform, typename X> | |
struct transform | |
{ | |
BOOST_PROTO_TRANSFORM_(PrimitiveTransform, X) | |
}; | |
template<typename Expr, typename State, typename Data> | |
struct transform_impl | |
{ | |
typedef Expr const expr; | |
typedef Expr const &expr_param; | |
typedef State const state; | |
typedef State const &state_param; | |
typedef Data const data; | |
typedef Data const &data_param; | |
}; | |
template<typename Expr, typename State, typename Data> | |
struct transform_impl<Expr &, State, Data> | |
{ | |
typedef Expr expr; | |
typedef Expr &expr_param; | |
typedef State const state; | |
typedef State const &state_param; | |
typedef Data const data; | |
typedef Data const &data_param; | |
}; | |
template<typename Expr, typename State, typename Data> | |
struct transform_impl<Expr, State &, Data> | |
{ | |
typedef Expr const expr; | |
typedef Expr const &expr_param; | |
typedef State state; | |
typedef State &state_param; | |
typedef Data const data; | |
typedef Data const &data_param; | |
}; | |
template<typename Expr, typename State, typename Data> | |
struct transform_impl<Expr, State, Data &> | |
{ | |
typedef Expr const expr; | |
typedef Expr const &expr_param; | |
typedef State const state; | |
typedef State const &state_param; | |
typedef Data data; | |
typedef Data &data_param; | |
}; | |
template<typename Expr, typename State, typename Data> | |
struct transform_impl<Expr &, State &, Data> | |
{ | |
typedef Expr expr; | |
typedef Expr &expr_param; | |
typedef State state; | |
typedef State &state_param; | |
typedef Data const data; | |
typedef Data const &data_param; | |
}; | |
template<typename Expr, typename State, typename Data> | |
struct transform_impl<Expr &, State, Data &> | |
{ | |
typedef Expr expr; | |
typedef Expr &expr_param; | |
typedef State const state; | |
typedef State const &state_param; | |
typedef Data data; | |
typedef Data &data_param; | |
}; | |
template<typename Expr, typename State, typename Data> | |
struct transform_impl<Expr, State &, Data &> | |
{ | |
typedef Expr const expr; | |
typedef Expr const &expr_param; | |
typedef State state; | |
typedef State &state_param; | |
typedef Data data; | |
typedef Data &data_param; | |
}; | |
template<typename Expr, typename State, typename Data> | |
struct transform_impl<Expr &, State &, Data &> | |
{ | |
typedef Expr expr; | |
typedef Expr &expr_param; | |
typedef State state; | |
typedef State &state_param; | |
typedef Data data; | |
typedef Data &data_param; | |
}; | |
}} // namespace boost::proto | |
#endif |