Edit: /usr/include/boost/proto/proto_fwd.hpp (29385B)
///////////////////////////////////////////////////////////////////////////////
/// \file proto_fwd.hpp
/// Forward declarations of all of proto's public types and functions.
//
// 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_FWD_HPP_EAN_04_01_2005
#define BOOST_PROTO_FWD_HPP_EAN_04_01_2005
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#ifndef BOOST_PROTO_MAX_ARITY
# define BOOST_PROTO_MAX_ARITY 10
#endif
#ifndef BOOST_PROTO_MAX_LOGICAL_ARITY
# define BOOST_PROTO_MAX_LOGICAL_ARITY 10
#endif
#ifndef BOOST_PROTO_MAX_FUNCTION_CALL_ARITY
# define BOOST_PROTO_MAX_FUNCTION_CALL_ARITY BOOST_PROTO_MAX_ARITY
#endif
#if BOOST_PROTO_MAX_ARITY < 3
# error BOOST_PROTO_MAX_ARITY must be at least 3
#endif
#if BOOST_PROTO_MAX_FUNCTION_CALL_ARITY > BOOST_PROTO_MAX_ARITY
# error BOOST_PROTO_MAX_FUNCTION_CALL_ARITY cannot be larger than BOOST_PROTO_MAX_ARITY
#endif
#ifndef BOOST_PROTO_DONT_USE_PREPROCESSED_FILES
#if 10 < BOOST_PROTO_MAX_ARITY || \
10 < BOOST_PROTO_MAX_LOGICAL_ARITY || \
10 < BOOST_PROTO_MAX_FUNCTION_CALL_ARITY
#define BOOST_PROTO_DONT_USE_PREPROCESSED_FILES
#endif
#endif
#ifndef BOOST_PROTO_BROKEN_CONST_OVERLOADS
# if BOOST_WORKAROUND(__GNUC__, == 3) \
|| BOOST_WORKAROUND(__EDG_VERSION__, BOOST_TESTED_AT(310))
# define BOOST_PROTO_BROKEN_CONST_OVERLOADS
# endif
#endif
#ifndef BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS
# if BOOST_WORKAROUND(__GNUC__, == 3) \
|| BOOST_WORKAROUND(__EDG_VERSION__, BOOST_TESTED_AT(310))
# define BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS
# endif
#endif
#ifdef BOOST_PROTO_BROKEN_CONST_OVERLOADS
# include
# include
# define BOOST_PROTO_DISABLE_IF_IS_CONST(T)\
, typename boost::disable_if_c::value, boost::proto::detail::undefined>::type * = 0
#else
# define BOOST_PROTO_DISABLE_IF_IS_CONST(T)
#endif
#ifdef BOOST_PROTO_BROKEN_CONST_QUALIFIED_FUNCTIONS
# include
# include
# define BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T)\
, typename boost::disable_if_c::value, boost::proto::detail::undefined>::type * = 0
#else
# define BOOST_PROTO_DISABLE_IF_IS_FUNCTION(T)
#endif
#ifndef BOOST_PROTO_BROKEN_PTS
# if BOOST_WORKAROUND(BOOST_MSVC, <= 1400)
# define BOOST_PROTO_BROKEN_PTS
# endif
#endif
#ifdef BOOST_NO_CXX11_DECLTYPE_N3276
# // Proto can only use the decltype-based result_of if N3276 has been
# // implemented by the compiler.
# // See http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2011/n3276.pdf
# ifndef BOOST_PROTO_USE_NORMAL_RESULT_OF
# define BOOST_PROTO_USE_NORMAL_RESULT_OF
# endif
#endif
// Unless compiler support is there, use tr1_result_of instead of
// result_of to avoid the problems addressed by N3276.
#ifdef BOOST_PROTO_USE_NORMAL_RESULT_OF
# define BOOST_PROTO_RESULT_OF boost::result_of
#else
# define BOOST_PROTO_RESULT_OF boost::tr1_result_of
#endif
// If we're using the decltype-based result_of, we need to be a bit
// stricter about the return types of some functions.
#if defined(BOOST_RESULT_OF_USE_DECLTYPE) && defined(BOOST_PROTO_USE_NORMAL_RESULT_OF)
# define BOOST_PROTO_STRICT_RESULT_OF
# define BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(X, Y) X
#else
# define BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(X, Y) Y
#endif
#ifdef BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING
# define BOOST_PROTO_EXTENDED_TEMPLATE_PARAMETERS_MATCHING
#endif
#if defined(_MSC_VER)
# define BOOST_PROTO_PUSH_WARNINGS __pragma(warning(push))
# define BOOST_PROTO_POP_WARNINGS __pragma(warning(pop))
# define BOOST_PROTO_DISABLE_MSVC_C4180 __pragma(warning(disable : 4180)) // qualifier applied to function type has no meaning; ignored
# define BOOST_PROTO_DISABLE_MSVC_C4522 __pragma(warning(disable : 4522)) // 'class' : multiple assignment operators specified
# define BOOST_PROTO_DISABLE_MSVC_C4714 __pragma(warning(disable : 4714)) // function 'xxx' marked as __forceinline not inlined
#else
# define BOOST_PROTO_PUSH_WARNINGS
# define BOOST_PROTO_POP_WARNINGS
# define BOOST_PROTO_DISABLE_MSVC_C4180
# define BOOST_PROTO_DISABLE_MSVC_C4522
# define BOOST_PROTO_DISABLE_MSVC_C4714
#endif
namespace boost { namespace proto
{
namespace detail
{
typedef char yes_type;
typedef char (&no_type)[2];
template
struct sized_type
{
typedef char (&type)[N];
};
struct dont_care;
struct undefined; // leave this undefined
struct not_a_valid_type;
struct private_type_
{
private_type_ operator ,(int) const;
};
template
struct uncvref
{
typedef T type;
};
template
struct uncvref
{
typedef T type;
};
template
struct uncvref
{
typedef T type;
};
template
struct uncvref
{
typedef T type;
};
template
struct uncvref
{
typedef T type[N];
};
template
struct uncvref
{
typedef T type[N];
};
template
struct uncvref
{
typedef T type[N];
};
struct ignore
{
ignore()
{}
template
ignore(T const &)
{}
};
/// INTERNAL ONLY
///
#define BOOST_PROTO_UNCVREF(X) \
typename boost::proto::detail::uncvref::type \
/**/
struct _default;
struct not_a_domain;
struct not_a_grammar;
struct not_a_generator;
template
struct is_transform_;
template
struct is_aggregate_;
template
struct flat_view;
}
typedef detail::ignore const ignore;
namespace argsns_
{
template
struct term;
#define M0(Z, N, DATA) \
template struct BOOST_PP_CAT(list, N); \
/**/
BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), M0, ~)
#undef M0
}
using namespace argsns_;
///////////////////////////////////////////////////////////////////////////////
// Operator tags
namespace tagns_
{
namespace tag
{
struct terminal;
struct unary_plus;
struct negate;
struct dereference;
struct complement;
struct address_of;
struct logical_not;
struct pre_inc;
struct pre_dec;
struct post_inc;
struct post_dec;
struct shift_left;
struct shift_right;
struct multiplies;
struct divides;
struct modulus;
struct plus;
struct minus;
struct less;
struct greater;
struct less_equal;
struct greater_equal;
struct equal_to;
struct not_equal_to;
struct logical_or;
struct logical_and;
struct bitwise_and;
struct bitwise_or;
struct bitwise_xor;
struct comma;
struct mem_ptr;
struct assign;
struct shift_left_assign;
struct shift_right_assign;
struct multiplies_assign;
struct divides_assign;
struct modulus_assign;
struct plus_assign;
struct minus_assign;
struct bitwise_and_assign;
struct bitwise_or_assign;
struct bitwise_xor_assign;
struct subscript;
struct member;
struct if_else_;
struct function;
// Fusion tags
template struct proto_expr;
template struct proto_expr_iterator;
template struct proto_flat_view;
}
}
using namespace tagns_;
template
struct tag_of;
////////////////////////////////////////////////////////////////////////////////////////////////
struct _;
////////////////////////////////////////////////////////////////////////////////////////////////
struct default_generator;
struct basic_default_generator;
template class Extends>
struct generator;
template class Extends>
struct pod_generator;
struct by_value_generator;
template
struct compose_generators;
template
struct wants_basic_expr;
template
struct use_basic_expr;
////////////////////////////////////////////////////////////////////////////////////////////////
namespace domainns_
{
typedef detail::not_a_domain no_super_domain;
template<
typename Generator = default_generator
, typename Grammar = proto::_
, typename Super = no_super_domain
>
struct domain;
struct default_domain;
struct basic_default_domain;
struct deduce_domain;
template::value>
struct base_expr;
}
using namespace domainns_;
////////////////////////////////////////////////////////////////////////////////////////////////
namespace exprns_
{
template
struct basic_expr;
template
struct expr;
template<
typename Expr
, typename Derived
, typename Domain = default_domain
, long Arity = Expr::proto_arity_c
>
struct extends;
template
struct virtual_member;
struct is_proto_expr;
}
////////////////////////////////////////////////////////////////////////////////////////////////
using exprns_::expr;
using exprns_::basic_expr;
using exprns_::extends;
using exprns_::is_proto_expr;
template
struct or_;
template
struct and_;
template
struct not_;
template >
struct if_;
template()>
struct switch_;
template
struct exact;
template
struct convertible_to;
template
struct vararg;
struct pack;
// Boost bug https://svn.boost.org/trac/boost/ticket/4602
//int const N = INT_MAX;
int const N = (INT_MAX >> 10);
namespace context
{
struct null_context;
template
struct null_eval;
struct default_context;
template
struct default_eval;
template
struct callable_context;
template
struct callable_eval;
}
using context::null_context;
using context::null_eval;
using context::default_context;
using context::default_eval;
using context::callable_context;
using context::callable_eval;
namespace utility
{
template
struct literal;
}
using utility::literal;
namespace result_of
{
template
struct as_expr;
template
struct as_child;
template >
struct child;
template
struct child_c;
template
struct left;
template
struct right;
template
struct deep_copy;
template
struct eval;
template<
typename Tag
, typename DomainOrA0
BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(
BOOST_PROTO_MAX_ARITY
, typename A
, = void BOOST_PP_INTERCEPT
)
, typename Void = void
>
struct make_expr;
template
struct unpack_expr;
template
struct as_env;
template
struct has_env_var;
template
struct env_var;
}
template
struct is_expr;
template
struct is_domain;
template
struct is_sub_domain_of;
template
struct is_env;
template
struct arity_of;
template
struct domain_of;
template
struct matches;
// Generic expression metafunctions and
// grammar elements
template
struct unary_expr;
template
struct binary_expr;
template
struct nary_expr;
// Specific expression metafunctions and
// grammar elements, for convenience
template struct terminal;
template struct unary_plus;
template struct negate;
template struct dereference;
template struct complement;
template struct address_of;
template struct logical_not;
template struct pre_inc;
template struct pre_dec;
template struct post_inc;
template struct post_dec;
template struct shift_left;
template struct shift_right;
template struct multiplies;
template struct divides;
template struct modulus;
template struct plus;
template struct minus;
template struct less;
template struct greater;
template struct less_equal;
template struct greater_equal;
template struct equal_to;
template struct not_equal_to;
template struct logical_or;
template struct logical_and;
template struct bitwise_and;
template struct bitwise_or;
template struct bitwise_xor;
template struct comma;
template struct mem_ptr;
template struct assign;
template struct shift_left_assign;
template struct shift_right_assign;
template struct multiplies_assign;
template struct divides_assign;
template struct modulus_assign;
template struct plus_assign;
template struct minus_assign;
template struct bitwise_and_assign;
template struct bitwise_or_assign;
template struct bitwise_xor_assign;
template struct subscript;
template struct member;
template struct if_else_;
template
struct function;
namespace functional
{
struct left;
struct right;
struct eval;
struct deep_copy;
template
struct as_expr;
template
struct as_child;
template >
struct child;
template
struct child_c;
struct as_env;
template
struct has_env_var;
template
struct env_var;
template
struct make_expr;
template
struct unpack_expr;
typedef make_expr make_terminal;
typedef make_expr make_unary_plus;
typedef make_expr make_negate;
typedef make_expr make_dereference;
typedef make_expr make_complement;
typedef make_expr make_address_of;
typedef make_expr make_logical_not;
typedef make_expr make_pre_inc;
typedef make_expr make_pre_dec;
typedef make_expr make_post_inc;
typedef make_expr make_post_dec;
typedef make_expr make_shift_left;
typedef make_expr make_shift_right;
typedef make_expr make_multiplies;
typedef make_expr make_divides;
typedef make_expr make_modulus;
typedef make_expr make_plus;
typedef make_expr make_minus;
typedef make_expr make_less;
typedef make_expr make_greater;
typedef make_expr make_less_equal;
typedef make_expr make_greater_equal;
typedef make_expr make_equal_to;
typedef make_expr make_not_equal_to;
typedef make_expr make_logical_or;
typedef make_expr make_logical_and;
typedef make_expr make_bitwise_and;
typedef make_expr make_bitwise_or;
typedef make_expr make_bitwise_xor;
typedef make_expr make_comma;
typedef make_expr make_mem_ptr;
typedef make_expr make_assign;
typedef make_expr make_shift_left_assign;
typedef make_expr make_shift_right_assign;
typedef make_expr make_multiplies_assign;
typedef make_expr make_divides_assign;
typedef make_expr make_modulus_assign;
typedef make_expr make_plus_assign;
typedef make_expr make_minus_assign;
typedef make_expr make_bitwise_and_assign;
typedef make_expr make_bitwise_or_assign;
typedef make_expr make_bitwise_xor_assign;
typedef make_expr make_subscript;
typedef make_expr make_if_else;
typedef make_expr make_function;
struct flatten;
struct make_pair;
struct first;
struct second;
struct at;
struct pop_front;
struct push_front;
struct pop_back;
struct push_back;
struct reverse;
}
typedef functional::flatten _flatten;
typedef functional::make_pair _make_pair;
typedef functional::first _first;
typedef functional::second _second;
typedef functional::at _at;
typedef functional::pop_front _pop_front;
typedef functional::push_front _push_front;
typedef functional::pop_back _pop_back;
typedef functional::push_back _push_back;
typedef functional::reverse _reverse;
typedef functional::eval _eval;
struct _deep_copy;
typedef functional::make_expr _make_terminal;
typedef functional::make_expr _make_unary_plus;
typedef functional::make_expr _make_negate;
typedef functional::make_expr _make_dereference;
typedef functional::make_expr _make_complement;
typedef functional::make_expr _make_address_of;
typedef functional::make_expr _make_logical_not;
typedef functional::make_expr _make_pre_inc;
typedef functional::make_expr _make_pre_dec;
typedef functional::make_expr _make_post_inc;
typedef functional::make_expr _make_post_dec;
typedef functional::make_expr _make_shift_left;
typedef functional::make_expr _make_shift_right;
typedef functional::make_expr _make_multiplies;
typedef functional::make_expr _make_divides;
typedef functional::make_expr _make_modulus;
typedef functional::make_expr _make_plus;
typedef functional::make_expr _make_minus;
typedef functional::make_expr _make_less;
typedef functional::make_expr _make_greater;
typedef functional::make_expr _make_less_equal;
typedef functional::make_expr _make_greater_equal;
typedef functional::make_expr _make_equal_to;
typedef functional::make_expr _make_not_equal_to;
typedef functional::make_expr _make_logical_or;
typedef functional::make_expr _make_logical_and;
typedef functional::make_expr _make_bitwise_and;
typedef functional::make_expr _make_bitwise_or;
typedef functional::make_expr _make_bitwise_xor;
typedef functional::make_expr _make_comma;
typedef functional::make_expr _make_mem_ptr;
typedef functional::make_expr _make_assign;
typedef functional::make_expr _make_shift_left_assign;
typedef functional::make_expr _make_shift_right_assign;
typedef functional::make_expr _make_multiplies_assign;
typedef functional::make_expr _make_divides_assign;
typedef functional::make_expr _make_modulus_assign;
typedef functional::make_expr _make_plus_assign;
typedef functional::make_expr _make_minus_assign;
typedef functional::make_expr _make_bitwise_and_assign;
typedef functional::make_expr _make_bitwise_or_assign;
typedef functional::make_expr _make_bitwise_xor_assign;
typedef functional::make_expr _make_subscript;
typedef functional::make_expr _make_if_else;
typedef functional::make_expr _make_function;
template
struct is_callable;
template
struct is_transform;
template
struct is_aggregate;
#define BOOST_PROTO_UNEXPR() typedef int proto_is_expr_;
#define BOOST_PROTO_CALLABLE() typedef void proto_is_callable_;
#define BOOST_PROTO_AGGREGATE() typedef void proto_is_aggregate_;
#define BOOST_PROTO_USE_BASIC_EXPR() typedef void proto_use_basic_expr_;
struct callable
{
BOOST_PROTO_CALLABLE()
};
namespace envns_
{
struct key_not_found;
struct empty_env;
typedef int empty_state;
template
struct env;
struct data_type;
struct transforms_type;
}
using envns_::key_not_found;
using envns_::empty_env;
using envns_::empty_state;
using envns_::env;
using envns_::data_type;
using envns_::transforms_type;
struct external_transform;
template
struct transform;
template
struct when;
template
struct otherwise;
template
struct call;
template
struct make;
template
struct protect;
template
struct noinvoke;
template
struct lazy;
template
struct fold;
template
struct reverse_fold;
// Q: can we replace fold_tree with fold ?
// A: once segmented Fusion works well.
template
struct fold_tree;
template