Added boost header
This commit is contained in:
Christophe Riccio
626
test/external/boost/proto/extends.hpp
vendored
Normal file
626
test/external/boost/proto/extends.hpp
vendored
Normal file
@@ -0,0 +1,626 @@
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
/// \file extends.hpp
|
||||
/// Macros and a base class for defining end-user expression types
|
||||
//
|
||||
// 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_EXTENDS_HPP_EAN_11_1_2006
|
||||
#define BOOST_PROTO_EXTENDS_HPP_EAN_11_1_2006
|
||||
|
||||
#include <cstddef> // for offsetof
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/preprocessor/facilities/empty.hpp>
|
||||
#include <boost/preprocessor/tuple/elem.hpp>
|
||||
#include <boost/preprocessor/control/if.hpp>
|
||||
#include <boost/preprocessor/arithmetic/inc.hpp>
|
||||
#include <boost/preprocessor/arithmetic/dec.hpp>
|
||||
#include <boost/preprocessor/iteration/local.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_params.hpp>
|
||||
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
|
||||
#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
|
||||
#include <boost/preprocessor/seq/for_each.hpp>
|
||||
#include <boost/utility/addressof.hpp>
|
||||
#include <boost/utility/result_of.hpp>
|
||||
#include <boost/proto/proto_fwd.hpp>
|
||||
#include <boost/proto/traits.hpp>
|
||||
#include <boost/proto/expr.hpp>
|
||||
#include <boost/proto/args.hpp>
|
||||
#include <boost/proto/traits.hpp>
|
||||
#include <boost/proto/generate.hpp>
|
||||
#include <boost/proto/detail/remove_typename.hpp>
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#define BOOST_PROTO_DISABLE_MSVC_C4522 __pragma(warning(disable: 4522))
|
||||
#else
|
||||
#define BOOST_PROTO_DISABLE_MSVC_C4522
|
||||
#endif
|
||||
|
||||
namespace boost { namespace proto
|
||||
{
|
||||
#ifdef __GNUC__
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
# define BOOST_PROTO_ADDROF(x) ((char const volatile*)boost::addressof(x))
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
# define BOOST_PROTO_OFFSETOF(s,m) (BOOST_PROTO_ADDROF((((s *)this)->m)) - BOOST_PROTO_ADDROF(*((s *)this)))
|
||||
#else
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
# define BOOST_PROTO_OFFSETOF offsetof
|
||||
#endif
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_CONST() const
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_TYPENAME() typename
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_TEMPLATE_YES_(Z, N) template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename A)>
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_TEMPLATE_NO_(Z, N)
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, DATA, Const) \
|
||||
BOOST_PP_IF(N, BOOST_PROTO_TEMPLATE_YES_, BOOST_PROTO_TEMPLATE_NO_)(Z, N) \
|
||||
typename BOOST_PROTO_RESULT_OF< \
|
||||
proto_generator( \
|
||||
typename boost::proto::result_of::BOOST_PP_CAT(funop, N)< \
|
||||
proto_derived_expr Const() \
|
||||
, proto_domain \
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, const A) \
|
||||
>::type \
|
||||
) \
|
||||
>::type const \
|
||||
operator ()(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, const &a)) Const() \
|
||||
{ \
|
||||
typedef boost::proto::result_of::BOOST_PP_CAT(funop, N)< \
|
||||
proto_derived_expr Const() \
|
||||
, proto_domain \
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, const A) \
|
||||
> funop; \
|
||||
return proto_generator()( \
|
||||
funop::call( \
|
||||
*static_cast<proto_derived_expr Const() *>(this) \
|
||||
BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, a) \
|
||||
) \
|
||||
); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(Const) \
|
||||
template<typename... A> \
|
||||
typename BOOST_PROTO_RESULT_OF< \
|
||||
proto_generator( \
|
||||
typename boost::proto::result_of::funop< \
|
||||
proto_derived_expr Const()(A const &...) \
|
||||
, proto_derived_expr \
|
||||
, proto_domain \
|
||||
>::type \
|
||||
) \
|
||||
>::type const \
|
||||
operator ()(A const &...a) Const() \
|
||||
{ \
|
||||
typedef boost::proto::result_of::funop< \
|
||||
proto_derived_expr Const()(A const &...) \
|
||||
, proto_derived_expr \
|
||||
, proto_domain \
|
||||
> funop; \
|
||||
return proto_generator()( \
|
||||
funop::call( \
|
||||
*static_cast<proto_derived_expr Const() *>(this) \
|
||||
, a... \
|
||||
) \
|
||||
); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_DEFINE_FUN_OP_CONST(Z, N, DATA) \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, DATA, BOOST_PROTO_CONST) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_DEFINE_FUN_OP_NON_CONST(Z, N, DATA) \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, DATA, BOOST_PP_EMPTY) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_DEFINE_FUN_OP(Z, N, DATA) \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_CONST(Z, N, DATA) \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_NON_CONST(Z, N, DATA) \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_EXTENDS_CHILD(Z, N, DATA) \
|
||||
typedef \
|
||||
typename proto_base_expr::BOOST_PP_CAT(proto_child, N) \
|
||||
BOOST_PP_CAT(proto_child, N); \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, Domain) \
|
||||
Expr proto_expr_; \
|
||||
\
|
||||
typedef Expr proto_base_expr_; /**< INTERNAL ONLY */ \
|
||||
typedef typename proto_base_expr_::proto_base_expr proto_base_expr; \
|
||||
typedef BOOST_PROTO_REMOVE_TYPENAME(Domain) proto_domain; \
|
||||
typedef Derived proto_derived_expr; \
|
||||
typedef Domain::proto_generator proto_generator; \
|
||||
typedef typename proto_base_expr::proto_tag proto_tag; \
|
||||
typedef typename proto_base_expr::proto_args proto_args; \
|
||||
typedef typename proto_base_expr::proto_arity proto_arity; \
|
||||
typedef typename proto_base_expr::proto_grammar proto_grammar; \
|
||||
typedef typename proto_base_expr::address_of_hack_type_ proto_address_of_hack_type_; \
|
||||
typedef void proto_is_expr_; /**< INTERNAL ONLY */ \
|
||||
static const long proto_arity_c = proto_base_expr::proto_arity_c; \
|
||||
typedef boost::proto::tag::proto_expr fusion_tag; \
|
||||
BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_EXTENDS_CHILD, ~) \
|
||||
\
|
||||
static proto_derived_expr const make(Expr const &e) \
|
||||
{ \
|
||||
proto_derived_expr that = {e}; \
|
||||
return that; \
|
||||
} \
|
||||
\
|
||||
proto_base_expr &proto_base() \
|
||||
{ \
|
||||
return this->proto_expr_.proto_base(); \
|
||||
} \
|
||||
\
|
||||
proto_base_expr const &proto_base() const \
|
||||
{ \
|
||||
return this->proto_expr_.proto_base(); \
|
||||
} \
|
||||
\
|
||||
operator proto_address_of_hack_type_() const \
|
||||
{ \
|
||||
return boost::addressof(this->proto_base().child0); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_BASIC_EXTENDS(Expr, Derived, Domain) \
|
||||
BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, Domain) \
|
||||
typedef void proto_is_aggregate_; \
|
||||
/**< INTERNAL ONLY */
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, Const, Typename) \
|
||||
BOOST_PROTO_DISABLE_MSVC_C4522 \
|
||||
Typename() BOOST_PROTO_RESULT_OF< \
|
||||
Typename() This::proto_generator( \
|
||||
Typename() boost::proto::base_expr< \
|
||||
Typename() This::proto_domain \
|
||||
, boost::proto::tag::assign \
|
||||
, boost::proto::list2< \
|
||||
This & \
|
||||
, This Const() & \
|
||||
> \
|
||||
>::type \
|
||||
) \
|
||||
>::type const \
|
||||
operator =(This Const() &a) \
|
||||
{ \
|
||||
typedef \
|
||||
Typename() boost::proto::base_expr< \
|
||||
Typename() This::proto_domain \
|
||||
, boost::proto::tag::assign \
|
||||
, boost::proto::list2< \
|
||||
This & \
|
||||
, This Const() & \
|
||||
> \
|
||||
>::type \
|
||||
that_type; \
|
||||
that_type const that = { \
|
||||
*this \
|
||||
, a \
|
||||
}; \
|
||||
return Typename() This::proto_generator()(that); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
// MSVC 8.0 and higher seem to need copy-assignment operator to be overloaded on *both*
|
||||
// const and non-const rhs arguments.
|
||||
#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600)) && (BOOST_MSVC > 1310)
|
||||
#define BOOST_PROTO_EXTENDS_COPY_ASSIGN_(This, Typename) \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, BOOST_PP_EMPTY, Typename) \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, BOOST_PROTO_CONST, Typename) \
|
||||
/**/
|
||||
#else
|
||||
#define BOOST_PROTO_EXTENDS_COPY_ASSIGN_(This, Typename) \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_IMPL_(This, BOOST_PROTO_CONST, Typename) \
|
||||
/**/
|
||||
#endif
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(ThisConst, ThatConst) \
|
||||
template<typename A> \
|
||||
typename BOOST_PROTO_RESULT_OF< \
|
||||
proto_generator( \
|
||||
typename boost::proto::base_expr< \
|
||||
proto_domain \
|
||||
, boost::proto::tag::assign \
|
||||
, boost::proto::list2< \
|
||||
proto_derived_expr ThisConst() & \
|
||||
, typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \
|
||||
> \
|
||||
>::type \
|
||||
) \
|
||||
>::type const \
|
||||
operator =(A ThatConst() &a) ThisConst() \
|
||||
{ \
|
||||
typedef \
|
||||
typename boost::proto::base_expr< \
|
||||
proto_domain \
|
||||
, boost::proto::tag::assign \
|
||||
, boost::proto::list2< \
|
||||
proto_derived_expr ThisConst() & \
|
||||
, typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \
|
||||
> \
|
||||
>::type \
|
||||
that_type; \
|
||||
that_type const that = { \
|
||||
*static_cast<proto_derived_expr ThisConst() *>(this) \
|
||||
, boost::proto::as_child<proto_domain>(a) \
|
||||
}; \
|
||||
return proto_generator()(that); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_ASSIGN_CONST_() \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PROTO_CONST, BOOST_PP_EMPTY) \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PROTO_CONST, BOOST_PROTO_CONST) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST_() \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PP_EMPTY, BOOST_PP_EMPTY) \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(BOOST_PP_EMPTY, BOOST_PROTO_CONST) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_ASSIGN_() \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_CONST_() \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST_() \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_ASSIGN_CONST() \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_(proto_derived_expr, BOOST_PROTO_TYPENAME) \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_CONST_() \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST() \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_(proto_derived_expr, BOOST_PROTO_TYPENAME) \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST_() \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_ASSIGN() \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_(proto_derived_expr, BOOST_PROTO_TYPENAME) \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_() \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(ThisConst, ThatConst) \
|
||||
template<typename A> \
|
||||
typename BOOST_PROTO_RESULT_OF< \
|
||||
proto_generator( \
|
||||
typename boost::proto::base_expr< \
|
||||
proto_domain \
|
||||
, boost::proto::tag::subscript \
|
||||
, boost::proto::list2< \
|
||||
proto_derived_expr ThisConst() & \
|
||||
, typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \
|
||||
> \
|
||||
>::type \
|
||||
) \
|
||||
>::type const \
|
||||
operator [](A ThatConst() &a) ThisConst() \
|
||||
{ \
|
||||
typedef \
|
||||
typename boost::proto::base_expr< \
|
||||
proto_domain \
|
||||
, boost::proto::tag::subscript \
|
||||
, boost::proto::list2< \
|
||||
proto_derived_expr ThisConst() & \
|
||||
, typename boost::proto::result_of::as_child<A ThatConst(), proto_domain>::type \
|
||||
> \
|
||||
>::type \
|
||||
that_type; \
|
||||
that_type const that = { \
|
||||
*static_cast<proto_derived_expr ThisConst() *>(this) \
|
||||
, boost::proto::as_child<proto_domain>(a) \
|
||||
}; \
|
||||
return proto_generator()(that); \
|
||||
} \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST() \
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PROTO_CONST, BOOST_PP_EMPTY) \
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PROTO_CONST, BOOST_PROTO_CONST) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_SUBSCRIPT_NON_CONST() \
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PP_EMPTY, BOOST_PP_EMPTY) \
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(BOOST_PP_EMPTY, BOOST_PROTO_CONST) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_SUBSCRIPT() \
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST() \
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT_NON_CONST() \
|
||||
/**/
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_EXTENDS_FUNCTION_() \
|
||||
template<typename Sig> \
|
||||
struct result \
|
||||
{ \
|
||||
typedef \
|
||||
typename BOOST_PROTO_RESULT_OF< \
|
||||
proto_generator( \
|
||||
typename boost::proto::result_of::funop< \
|
||||
Sig \
|
||||
, proto_derived_expr \
|
||||
, proto_domain \
|
||||
>::type \
|
||||
) \
|
||||
>::type const \
|
||||
type; \
|
||||
}; \
|
||||
/**/
|
||||
|
||||
#ifndef BOOST_NO_VARIADIC_TEMPLATES
|
||||
#define BOOST_PROTO_EXTENDS_FUNCTION_CONST() \
|
||||
BOOST_PROTO_EXTENDS_FUNCTION_() \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_FUNCTION_NON_CONST() \
|
||||
BOOST_PROTO_EXTENDS_FUNCTION_() \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PP_EMPTY) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_FUNCTION() \
|
||||
BOOST_PROTO_EXTENDS_FUNCTION_() \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PP_EMPTY) \
|
||||
BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(BOOST_PROTO_CONST) \
|
||||
/**/
|
||||
#else
|
||||
#define BOOST_PROTO_EXTENDS_FUNCTION_CONST() \
|
||||
BOOST_PROTO_EXTENDS_FUNCTION_() \
|
||||
BOOST_PP_REPEAT_FROM_TO( \
|
||||
0 \
|
||||
, BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \
|
||||
, BOOST_PROTO_DEFINE_FUN_OP_CONST \
|
||||
, ~ \
|
||||
) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_FUNCTION_NON_CONST() \
|
||||
BOOST_PROTO_EXTENDS_FUNCTION_() \
|
||||
BOOST_PP_REPEAT_FROM_TO( \
|
||||
0 \
|
||||
, BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \
|
||||
, BOOST_PROTO_DEFINE_FUN_OP_NON_CONST \
|
||||
, ~ \
|
||||
) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_FUNCTION() \
|
||||
BOOST_PROTO_EXTENDS_FUNCTION_() \
|
||||
BOOST_PP_REPEAT_FROM_TO( \
|
||||
0 \
|
||||
, BOOST_PROTO_MAX_FUNCTION_CALL_ARITY \
|
||||
, BOOST_PROTO_DEFINE_FUN_OP \
|
||||
, ~ \
|
||||
) \
|
||||
/**/
|
||||
#endif
|
||||
|
||||
#define BOOST_PROTO_EXTENDS(Expr, Derived, Domain) \
|
||||
BOOST_PROTO_BASIC_EXTENDS(Expr, Derived, Domain) \
|
||||
BOOST_PROTO_EXTENDS_ASSIGN() \
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT() \
|
||||
BOOST_PROTO_EXTENDS_FUNCTION() \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_USING_ASSIGN(Derived) \
|
||||
typedef typename Derived::proto_extends proto_extends; \
|
||||
using proto_extends::operator =; \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_(Derived, BOOST_PROTO_TYPENAME) \
|
||||
/**/
|
||||
|
||||
#define BOOST_PROTO_EXTENDS_USING_ASSIGN_NON_DEPENDENT(Derived) \
|
||||
typedef Derived::proto_extends proto_extends; \
|
||||
using proto_extends::operator =; \
|
||||
BOOST_PROTO_EXTENDS_COPY_ASSIGN_(Derived, BOOST_PP_EMPTY) \
|
||||
/**/
|
||||
|
||||
namespace exprns_
|
||||
{
|
||||
/// \brief Empty type to be used as a dummy template parameter of
|
||||
/// POD expression wrappers. It allows argument-dependent lookup
|
||||
/// to find Proto's operator overloads.
|
||||
///
|
||||
/// \c proto::is_proto_expr allows argument-dependent lookup
|
||||
/// to find Proto's operator overloads. For example:
|
||||
///
|
||||
/// \code
|
||||
/// template<typename T, typename Dummy = proto::is_proto_expr>
|
||||
/// struct my_terminal
|
||||
/// {
|
||||
/// BOOST_PROTO_BASIC_EXTENDS(
|
||||
/// typename proto::terminal<T>::type
|
||||
/// , my_terminal<T>
|
||||
/// , default_domain
|
||||
/// )
|
||||
/// };
|
||||
///
|
||||
/// // ...
|
||||
/// my_terminal<int> _1, _2;
|
||||
/// _1 + _2; // OK, uses proto::operator+
|
||||
/// \endcode
|
||||
///
|
||||
/// Without the second \c Dummy template parameter, Proto's operator
|
||||
/// overloads would not be considered by name lookup.
|
||||
struct is_proto_expr
|
||||
{};
|
||||
|
||||
/// \brief extends\<\> class template for adding behaviors to a Proto expression template
|
||||
///
|
||||
template<
|
||||
typename Expr
|
||||
, typename Derived
|
||||
, typename Domain // = proto::default_domain
|
||||
, long Arity // = Expr::proto_arity_c
|
||||
>
|
||||
struct extends
|
||||
{
|
||||
extends()
|
||||
: proto_expr_()
|
||||
{}
|
||||
|
||||
extends(extends const &that)
|
||||
: proto_expr_(that.proto_expr_)
|
||||
{}
|
||||
|
||||
extends(Expr const &expr_)
|
||||
: proto_expr_(expr_)
|
||||
{}
|
||||
|
||||
typedef extends proto_extends;
|
||||
BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, typename Domain)
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_CONST_()
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST()
|
||||
|
||||
// Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
|
||||
// nested preprocessor loops, use file iteration here to generate
|
||||
// the operator() overloads, which is more efficient.
|
||||
#include <boost/proto/detail/extends_funop_const.hpp>
|
||||
};
|
||||
|
||||
/// \brief extends\<\> class template for adding behaviors to a Proto expression template
|
||||
///
|
||||
template<typename Expr, typename Derived, typename Domain>
|
||||
struct extends<Expr, Derived, Domain, 0>
|
||||
{
|
||||
extends()
|
||||
: proto_expr_()
|
||||
{}
|
||||
|
||||
extends(extends const &that)
|
||||
: proto_expr_(that.proto_expr_)
|
||||
{}
|
||||
|
||||
extends(Expr const &expr_)
|
||||
: proto_expr_(expr_)
|
||||
{}
|
||||
|
||||
typedef extends proto_extends;
|
||||
BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, typename Domain)
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_()
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT()
|
||||
|
||||
// Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
|
||||
// nested preprocessor loops, use file iteration here to generate
|
||||
// the operator() overloads, which is more efficient.
|
||||
#include <boost/proto/detail/extends_funop.hpp>
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
template<typename This, typename Fun, typename Domain>
|
||||
struct virtual_member
|
||||
{
|
||||
typedef Domain proto_domain;
|
||||
typedef typename Domain::proto_generator proto_generator;
|
||||
typedef virtual_member<This, Fun, Domain> proto_derived_expr;
|
||||
typedef tag::member proto_tag;
|
||||
typedef list2<This &, expr<tag::terminal, term<Fun> > const &> proto_args;
|
||||
typedef mpl::long_<2> proto_arity;
|
||||
typedef detail::not_a_valid_type proto_address_of_hack_type_;
|
||||
typedef void proto_is_expr_; /**< INTERNAL ONLY */
|
||||
static const long proto_arity_c = 2;
|
||||
typedef boost::proto::tag::proto_expr fusion_tag;
|
||||
typedef This &proto_child0;
|
||||
typedef expr<tag::terminal, term<Fun> > const &proto_child1;
|
||||
typedef expr<proto_tag, proto_args, proto_arity_c> proto_base_expr;
|
||||
typedef basic_expr<proto_tag, proto_args, proto_arity_c> proto_grammar;
|
||||
typedef void proto_is_aggregate_; /**< INTERNAL ONLY */
|
||||
|
||||
BOOST_PROTO_EXTENDS_ASSIGN_()
|
||||
BOOST_PROTO_EXTENDS_SUBSCRIPT()
|
||||
|
||||
// Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
|
||||
// nested preprocessor loops, use file iteration here to generate
|
||||
// the operator() overloads, which is more efficient.
|
||||
#define BOOST_PROTO_NO_WAVE_OUTPUT
|
||||
#include <boost/proto/detail/extends_funop.hpp>
|
||||
#undef BOOST_PROTO_NO_WAVE_OUTPUT
|
||||
|
||||
proto_base_expr const proto_base() const
|
||||
{
|
||||
proto_base_expr that = {this->child0(), this->child1()};
|
||||
return that;
|
||||
}
|
||||
|
||||
proto_child0 child0() const
|
||||
{
|
||||
using std::size_t;
|
||||
return *(This *)((char *)this - BOOST_PROTO_OFFSETOF(This, proto_member_union_start_));
|
||||
}
|
||||
|
||||
proto_child1 child1() const
|
||||
{
|
||||
static expr<tag::terminal, term<Fun>, 0> const that = {Fun()};
|
||||
return that;
|
||||
}
|
||||
};
|
||||
|
||||
/// INTERNAL ONLY
|
||||
///
|
||||
#define BOOST_PROTO_EXTENDS_MEMBER_(R, DOMAIN, ELEM) \
|
||||
boost::proto::exprns_::virtual_member< \
|
||||
proto_derived_expr \
|
||||
, BOOST_PP_TUPLE_ELEM(2, 0, ELEM) \
|
||||
, DOMAIN \
|
||||
> BOOST_PP_TUPLE_ELEM(2, 1, ELEM); \
|
||||
/**/
|
||||
|
||||
/// \brief For declaring virtual data members in an extension class.
|
||||
///
|
||||
#define BOOST_PROTO_EXTENDS_MEMBERS_WITH_DOMAIN(SEQ, DOMAIN) \
|
||||
union \
|
||||
{ \
|
||||
char proto_member_union_start_; \
|
||||
BOOST_PP_SEQ_FOR_EACH(BOOST_PROTO_EXTENDS_MEMBER_, DOMAIN, SEQ) \
|
||||
}; \
|
||||
/**/
|
||||
|
||||
/// \brief For declaring virtual data members in an extension class.
|
||||
///
|
||||
#define BOOST_PROTO_EXTENDS_MEMBERS(SEQ) \
|
||||
BOOST_PROTO_EXTENDS_MEMBERS_WITH_DOMAIN(SEQ, proto_domain) \
|
||||
/**/
|
||||
|
||||
}
|
||||
|
||||
}}
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user