Update of /cvsroot/boost/boost/boost/xpressive/proto/v1_
In directory sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv13713/proto/v1_
Added Files:
Tag: PROTO2
arg_traits.hpp op_base.hpp op_tags.hpp operators.hpp proto.hpp
proto_fwd.hpp proto_typeof.hpp
Log Message:
make proto 2 the default, major refactorization, result_of integration
--- NEW FILE: arg_traits.hpp ---
///////////////////////////////////////////////////////////////////////////////
/// \file arg_traits.hpp
/// Contains definitions for value_type\<\>, arg_type\<\>, left_type\<\>,
/// right_type\<\>, tag_type\<\>, and the helper functions arg(), left(),
/// and right().
//
// Copyright 2004 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_V1_ARG_TRAITS_HPP_EAN_04_01_2005
#define BOOST_PROTO_V1_ARG_TRAITS_HPP_EAN_04_01_2005
#include <boost/call_traits.hpp>
#include <boost/xpressive/proto/v1_/proto_fwd.hpp>
namespace boost { namespace proto1
{
///////////////////////////////////////////////////////////////////////////////
// value_type
// specialize this to control how user-defined types are stored in the
parse tree
template<typename T>
struct value_type
{
typedef typename boost::call_traits<T>::value_type type;
};
template<>
struct value_type<fusion::void_t>
{
typedef fusion::void_t type;
};
///////////////////////////////////////////////////////////////////////////////
// argument type extractors
template<typename Op>
struct arg_type
{
typedef typename Op::arg_type type;
typedef type const &const_reference;
};
template<typename Op, typename Param>
struct arg_type<op_proxy<Op, Param> >
{
typedef typename Op::arg_type type;
typedef type const const_reference;
};
///////////////////////////////////////////////////////////////////////////////
// argument type extractors
template<typename Op>
struct left_type
{
typedef typename Op::left_type type;
typedef type const &const_reference;
};
template<typename Op, typename Param>
struct left_type<op_proxy<Op, Param> >
{
typedef typename Op::left_type type;
typedef type const const_reference;
};
///////////////////////////////////////////////////////////////////////////////
// argument type extractors
template<typename Op>
struct right_type
{
typedef typename Op::right_type type;
typedef type const &const_reference;
};
template<typename Op, typename Param>
struct right_type<op_proxy<Op, Param> >
{
typedef typename Op::right_type type;
typedef type const const_reference;
};
///////////////////////////////////////////////////////////////////////////////
// tag extractor
template<typename Op>
struct tag_type
{
typedef typename Op::tag_type type;
};
template<typename Op, typename Param>
struct tag_type<op_proxy<Op, Param> >
{
typedef typename Op::tag_type type;
};
///////////////////////////////////////////////////////////////////////////////
// arg
template<typename Op>
inline typename arg_type<Op>::const_reference arg(Op const &op)
{
return op.cast().arg;
}
///////////////////////////////////////////////////////////////////////////////
// left
template<typename Op>
inline typename left_type<Op>::const_reference left(Op const &op)
{
return op.cast().left;
}
///////////////////////////////////////////////////////////////////////////////
// right
template<typename Op>
inline typename right_type<Op>::const_reference right(Op const &op)
{
return op.cast().right;
}
}}
#endif
--- NEW FILE: op_base.hpp ---
///////////////////////////////////////////////////////////////////////////////
/// \file op_base.hpp
/// Contains definitions of unary_op\<\>, binary_op\<\> and nary_op\<\>,
/// as well as the is_op\<\> and the make_op() helper function.
//
// Copyright 2004 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_V1_OP_BASE_HPP_EAN_04_01_2005
#define BOOST_PROTO_V1_OP_BASE_HPP_EAN_04_01_2005
#include <boost/mpl/if.hpp>
#include <boost/mpl/or.hpp>
#include <boost/preprocessor/arithmetic/inc.hpp>
#include <boost/preprocessor/facilities/intercept.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_base_and_derived.hpp>
#include <boost/spirit/fusion/sequence/tuple.hpp>
#include <boost/xpressive/proto/v1_/proto_fwd.hpp>
#include <boost/xpressive/proto/v1_/arg_traits.hpp>
namespace boost { namespace proto1
{
///////////////////////////////////////////////////////////////////////////////
// op_root
struct op_root
{
};
///////////////////////////////////////////////////////////////////////////////
// is_proxy
template<typename T>
struct is_proxy
: mpl::false_
{
};
template<typename Op, typename Param>
struct is_proxy<op_proxy<Op, Param> >
: mpl::true_
{
};
///////////////////////////////////////////////////////////////////////////////
// is_op
template<typename T>
struct is_op
: mpl::or_<is_proxy<T>, is_base_and_derived<op_root, T> >
{
};
///////////////////////////////////////////////////////////////////////////////
// as_op
template<typename Op>
struct as_op<Op, true>
{
typedef typename Op::type type;
static typename Op::const_reference make(Op const &op)
{
return op.cast();
}
};
template<typename T>
struct as_op<T, false>
{
typedef unary_op<T, noop_tag> type;
static type const make(T const &t)
{
return noop(t);
}
};
// These operators must be members.
#define BOOST_PROTO_V1_DEFINE_MEMBER_OPS()
\
template<typename Arg>
\
binary_op<Op, typename as_op<Arg>::type, assign_tag> const
\
operator =(Arg const &arg) const
\
{
\
return make_op<assign_tag>(this->cast(), as_op<Arg>::make(arg));
\
}
\
template<typename Arg>
\
binary_op<Op, typename as_op<Arg>::type, subscript_tag> const
\
operator [](Arg const &arg) const
\
{
\
return make_op<subscript_tag>(this->cast(), as_op<Arg>::make(arg));
\
}
\
nary_op<Op> operator ()() const
\
{
\
return nary_op<Op>(this->cast());
\
}
\
BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY),
BOOST_PROTO_V1_FUN_OP, _)
#define BOOST_PROTO_V1_FUN_OP(z, n, _)
\
template<BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>
\
nary_op<Op BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, A)>
\
operator ()(BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, A, const &a)) const
\
{
\
return nary_op<Op BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, A)>
\
(this->cast() BOOST_PP_ENUM_TRAILING_PARAMS_Z(z, n, a));
\
}
///////////////////////////////////////////////////////////////////////////////
// op_base
template<typename Op>
struct op_base : op_root
{
typedef Op type;
typedef type const &const_reference;
Op &cast()
{
return *static_cast<Op *>(this);
}
Op const &cast() const
{
return *static_cast<Op const *>(this);
}
BOOST_PROTO_V1_DEFINE_MEMBER_OPS()
};
///////////////////////////////////////////////////////////////////////////////
// unary_op
template<typename Arg, typename Tag>
struct unary_op : op_base<unary_op<Arg, Tag> >
{
typedef typename value_type<Arg>::type arg_type;
typedef Tag tag_type;
arg_type arg;
unary_op()
: arg()
{}
explicit unary_op(typename call_traits<Arg>::param_type arg_)
: arg(arg_)
{}
using op_base<unary_op<Arg, Tag> >::operator =;
};
///////////////////////////////////////////////////////////////////////////////
// binary_op
template<typename Left, typename Right, typename Tag>
struct binary_op : op_base<binary_op<Left, Right, Tag> >
{
typedef typename value_type<Left>::type left_type;
typedef typename value_type<Right>::type right_type;
typedef Tag tag_type;
left_type left;
right_type right;
binary_op()
: left()
, right()
{}
binary_op(
typename call_traits<Left>::param_type left_
, typename call_traits<Right>::param_type right_)
: left(left_)
, right(right_)
{}
using op_base<binary_op<Left, Right, Tag> >::operator =;
};
///////////////////////////////////////////////////////////////////////////////
// nary_op
template<typename Fun, BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_ARITY, typename
A)>
struct nary_op
: op_base<nary_op<Fun, BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_ARITY, A)> >
{
typedef function_tag tag_type;
typedef Fun functor_type;
typedef fusion::tuple<
BOOST_PP_ENUM_BINARY_PARAMS(
BOOST_PROTO_MAX_ARITY, typename value_type<A, >::type
BOOST_PP_INTERCEPT)
> args_type;
functor_type functor;
args_type args;
nary_op()
: functor()
, args()
{}
#define BOOST_PROTO_V1_NARY_OP_CTOR(z, n, _)
\
nary_op(
\
typename call_traits<Fun>::param_type fun
\
BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(z, n, typename
call_traits<A, >::param_type a))\
: functor(fun)
\
, args(BOOST_PP_ENUM_PARAMS_Z(z, n, a))
\
{}
BOOST_PP_REPEAT(BOOST_PP_INC(BOOST_PROTO_MAX_ARITY),
BOOST_PROTO_V1_NARY_OP_CTOR, _)
#undef BOOST_PROTO_V1_NARY_OP_CTOR
using op_base<nary_op<Fun, BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_ARITY,
A)> >::operator =;
};
///////////////////////////////////////////////////////////////////////////////
// op_proxy
template<typename Op, typename Param>
struct op_proxy
{
typedef Op type;
typedef type const const_reference;
Param param_;
Op const cast() const
{
return Op(this->param_);
}
operator Op const() const
{
return this->cast();
}
BOOST_PROTO_V1_DEFINE_MEMBER_OPS()
};
template<typename Op>
struct op_proxy<Op, void>
{
typedef Op type;
typedef type const const_reference;
Op const cast() const
{
return Op();
}
operator Op const() const
{
return this->cast();
}
BOOST_PROTO_V1_DEFINE_MEMBER_OPS()
};
///////////////////////////////////////////////////////////////////////////////
// make_op
template<typename Op, typename Arg>
unary_op<Arg, Op> const
make_op(Arg const &arg)
{
return unary_op<Arg, Op>(arg);
}
///////////////////////////////////////////////////////////////////////////////
// make_op
template<typename Op, typename Left, typename Right>
binary_op<Left, Right, Op> const
make_op(Left const &left, Right const &right)
{
return binary_op<Left, Right, Op>(left, right);
}
}}
#endif
--- NEW FILE: op_tags.hpp ---
///////////////////////////////////////////////////////////////////////////////
/// \file op_tags.hpp
/// Contains the tags for all the overloadable operators in C++, as well as
/// the base tags unary_tag, binary_tag and nary_tag, as well as the
is_unary\<\>,
/// is_binary\<\> and is_nary\<\> predicates.
//
// Copyright 2004 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_V1_OP_TAGS_HPP_EAN_04_01_2005
#define BOOST_PROTO_V1_OP_TAGS_HPP_EAN_04_01_2005
#include <boost/type_traits/is_base_and_derived.hpp>
#include <boost/xpressive/proto/v1_/proto_fwd.hpp>
namespace boost { namespace proto1
{
///////////////////////////////////////////////////////////////////////////////
// Operator tags
struct unary_tag {};
struct binary_tag {};
struct nary_tag {}; // for operator()
struct noop_tag : unary_tag {};
struct unary_plus_tag : unary_tag {};
struct unary_minus_tag : unary_tag {};
struct unary_star_tag : unary_tag {};
struct complement_tag : unary_tag {};
struct address_of_tag : unary_tag {};
struct logical_not_tag : unary_tag {};
struct pre_inc_tag : unary_tag {};
struct pre_dec_tag : unary_tag {};
struct post_inc_tag : unary_tag {};
struct post_dec_tag : unary_tag {};
struct left_shift_tag : binary_tag {};
struct right_shift_tag : binary_tag {};
struct multiply_tag : binary_tag {};
struct divide_tag : binary_tag {};
struct modulus_tag : binary_tag {};
struct add_tag : binary_tag {};
struct subtract_tag : binary_tag {};
struct less_tag : binary_tag {};
struct greater_tag : binary_tag {};
struct less_equal_tag : binary_tag {};
struct greater_equal_tag : binary_tag {};
struct equal_tag : binary_tag {};
struct not_equal_tag : binary_tag {};
struct logical_or_tag : binary_tag {};
struct logical_and_tag : binary_tag {};
struct bitand_tag : binary_tag {};
struct bitor_tag : binary_tag {};
struct bitxor_tag : binary_tag {};
struct comma_tag : binary_tag {};
struct mem_ptr_tag : binary_tag {};
struct assign_tag : binary_tag {};
struct left_shift_assign_tag : binary_tag {};
struct right_shift_assign_tag : binary_tag {};
struct multiply_assign_tag : binary_tag {};
struct divide_assign_tag : binary_tag {};
struct modulus_assign_tag : binary_tag {};
struct add_assign_tag : binary_tag {};
struct subtract_assign_tag : binary_tag {};
struct bitand_assign_tag : binary_tag {};
struct bitor_assign_tag : binary_tag {};
struct bitxor_assign_tag : binary_tag {};
struct subscript_tag : binary_tag {};
struct function_tag : nary_tag {};
///////////////////////////////////////////////////////////////////////////////
// is_unary
template<typename Tag>
struct is_unary
: boost::is_base_and_derived<unary_tag, Tag>
{
};
///////////////////////////////////////////////////////////////////////////////
// is_binary
template<typename Tag>
struct is_binary
: boost::is_base_and_derived<binary_tag, Tag>
{
};
///////////////////////////////////////////////////////////////////////////////
// is_nary
template<typename Tag>
struct is_nary
: boost::is_base_and_derived<nary_tag, Tag>
{
};
}}
#endif
--- NEW FILE: operators.hpp ---
///////////////////////////////////////////////////////////////////////////////
/// \file operators.hpp
/// Contains all the overloaded operators that make it possible to build
/// expression templates using proto1 components
//
// Copyright 2004 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_V1_OPERATORS_HPP_EAN_04_01_2005
#define BOOST_PROTO_V1_OPERATORS_HPP_EAN_04_01_2005
#include <boost/mpl/or.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/preprocessor/punctuation/comma.hpp>
#include <boost/xpressive/proto/v1_/proto_fwd.hpp>
#include <boost/xpressive/proto/v1_/op_tags.hpp>
#include <boost/xpressive/proto/v1_/op_base.hpp>
namespace boost { namespace proto1
{
///////////////////////////////////////////////////////////////////////////////
// unary_op_generator
template<typename Arg, typename Tag>
struct unary_op_generator
{
typedef unary_op<
typename as_op<Arg>::type
, Tag
> type;
};
///////////////////////////////////////////////////////////////////////////////
// binary_op_generator
template<typename Left, typename Right, typename Tag>
struct binary_op_generator
{
typedef binary_op<
typename as_op<Left>::type
, typename as_op<Right>::type
, Tag
> type;
};
///////////////////////////////////////////////////////////////////////////////
// unary operators
template<typename Arg>
unary_op<Arg, noop_tag> const
noop(Arg const &arg)
{
return make_op<noop_tag>(arg);
}
#define BOOST_PROTO_V1_UNARY_OP(op, tag)
\
template<typename Arg>
\
inline typename lazy_enable_if<is_op<Arg>, unary_op_generator<Arg, tag>
>::type const \
operator op(Arg const &arg)
\
{
\
return make_op<tag>(as_op<Arg>::make(arg));
\
}
#define BOOST_PROTO_V1_BINARY_OP(op, tag)
\
template<typename Left, typename Right>
\
inline typename lazy_enable_if<
\
mpl::or_<is_op<Left>, is_op<Right> >
\
, binary_op_generator<Left, Right, tag>
\
>::type const
\
operator op(Left const &left, Right const &right)
\
{
\
return make_op<tag>(as_op<Left>::make(left),
as_op<Right>::make(right)); \
}
BOOST_PROTO_V1_UNARY_OP(+, unary_plus_tag)
BOOST_PROTO_V1_UNARY_OP(-, unary_minus_tag)
BOOST_PROTO_V1_UNARY_OP(*, unary_star_tag)
BOOST_PROTO_V1_UNARY_OP(~, complement_tag)
BOOST_PROTO_V1_UNARY_OP(&, address_of_tag)
BOOST_PROTO_V1_UNARY_OP(!, logical_not_tag)
BOOST_PROTO_V1_UNARY_OP(++, pre_inc_tag)
BOOST_PROTO_V1_UNARY_OP(--, pre_dec_tag)
BOOST_PROTO_V1_BINARY_OP(<<, left_shift_tag)
BOOST_PROTO_V1_BINARY_OP(>>, right_shift_tag)
BOOST_PROTO_V1_BINARY_OP(*, multiply_tag)
BOOST_PROTO_V1_BINARY_OP(/, divide_tag)
BOOST_PROTO_V1_BINARY_OP(%, modulus_tag)
BOOST_PROTO_V1_BINARY_OP(+, add_tag)
BOOST_PROTO_V1_BINARY_OP(-, subtract_tag)
BOOST_PROTO_V1_BINARY_OP(<, less_tag)
BOOST_PROTO_V1_BINARY_OP(>, greater_tag)
BOOST_PROTO_V1_BINARY_OP(<=, less_equal_tag)
BOOST_PROTO_V1_BINARY_OP(>=, greater_equal_tag)
BOOST_PROTO_V1_BINARY_OP(==, equal_tag)
BOOST_PROTO_V1_BINARY_OP(!=, not_equal_tag)
BOOST_PROTO_V1_BINARY_OP(||, logical_or_tag)
BOOST_PROTO_V1_BINARY_OP(&&, logical_and_tag)
BOOST_PROTO_V1_BINARY_OP(&, bitand_tag)
BOOST_PROTO_V1_BINARY_OP(|, bitor_tag)
BOOST_PROTO_V1_BINARY_OP(^, bitxor_tag)
BOOST_PROTO_V1_BINARY_OP(BOOST_PP_COMMA(), comma_tag)
BOOST_PROTO_V1_BINARY_OP(->*, mem_ptr_tag)
BOOST_PROTO_V1_BINARY_OP(<<=, left_shift_assign_tag)
BOOST_PROTO_V1_BINARY_OP(>>=, right_shift_assign_tag)
BOOST_PROTO_V1_BINARY_OP(*=, multiply_assign_tag)
BOOST_PROTO_V1_BINARY_OP(/=, divide_assign_tag)
BOOST_PROTO_V1_BINARY_OP(%=, modulus_assign_tag)
BOOST_PROTO_V1_BINARY_OP(+=, add_assign_tag)
BOOST_PROTO_V1_BINARY_OP(-=, subtract_assign_tag)
BOOST_PROTO_V1_BINARY_OP(&=, bitand_assign_tag)
BOOST_PROTO_V1_BINARY_OP(|=, bitor_assign_tag)
BOOST_PROTO_V1_BINARY_OP(^=, bitxor_assign_tag)
#undef BOOST_PROTO_V1_BINARY_OP
#undef BOOST_PROTO_V1_UNARY_OP
///////////////////////////////////////////////////////////////////////////////
// post-fix operators
template<typename Arg>
inline typename lazy_enable_if<is_op<Arg>, unary_op_generator<Arg,
post_inc_tag> >::type const
operator ++(Arg const &arg, int)
{
return make_op<post_inc_tag>(arg.cast());
}
template<typename Arg>
inline typename lazy_enable_if<is_op<Arg>, unary_op_generator<Arg,
post_dec_tag> >::type const
operator --(Arg const &arg, int)
{
return make_op<post_dec_tag>(arg.cast());
}
}}
#endif
--- NEW FILE: proto.hpp ---
///////////////////////////////////////////////////////////////////////////////
/// \file proto1.hpp
/// The proto1 expression template compiler and supporting utilities.
//
// Copyright 2004 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_V1_HPP_EAN_04_01_2005
#define BOOST_PROTO_V1_HPP_EAN_04_01_2005
#include <boost/xpressive/proto/v1_/proto_fwd.hpp>
#include <boost/xpressive/proto/v1_/op_tags.hpp>
#include <boost/xpressive/proto/v1_/op_base.hpp>
#include <boost/xpressive/proto/v1_/operators.hpp>
#include <boost/xpressive/proto/v1_/arg_traits.hpp>
namespace boost { namespace proto1
{
///////////////////////////////////////////////////////////////////////////////
// compile_result
template<typename Op, typename State, typename Visitor, typename DomainTag>
struct compile_result
{
typedef typename as_op<Op>::type op_type;
typedef typename tag_type<op_type>::type tag_type;
typedef compiler<tag_type, DomainTag> compiler_type;
typedef typename compiler_type::BOOST_NESTED_TEMPLATE apply<op_type,
State, Visitor>::type type;
};
///////////////////////////////////////////////////////////////////////////////
// compile
template<typename Op, typename State, typename Visitor, typename DomainTag>
typename compile_result<Op, State, Visitor, DomainTag>::type const
compile(Op const &op, State const &state, Visitor &visitor, DomainTag)
{
typedef typename as_op<Op>::type op_type;
typedef compiler<typename tag_type<op_type>::type, DomainTag> compiler;
return compiler::call(as_op<Op>::make(op), state, visitor);
}
}} // namespace boost::proto1
#endif
--- NEW FILE: proto_fwd.hpp ---
///////////////////////////////////////////////////////////////////////////////
/// \file proto_fwd.hpp
/// Forward declarations of all of proto1's public types and functions.
//
// Copyright 2004 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_V1_FWD_HPP_EAN_04_01_2005
#define BOOST_PROTO_V1_FWD_HPP_EAN_04_01_2005
#include <boost/mpl/bool.hpp>
#include <boost/mpl/apply_fwd.hpp>
#include <boost/spirit/fusion/sequence/tuple_forward.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
#ifndef BOOST_PROTO_MAX_ARITY
# define BOOST_PROTO_MAX_ARITY FUSION_MAX_TUPLE_SIZE
#endif
namespace boost { namespace proto1
{
///////////////////////////////////////////////////////////////////////////////
// Operator tags
struct unary_tag;
struct binary_tag;
struct nary_tag;
struct noop_tag;
struct unary_plus_tag;
struct unary_minus_tag;
struct unary_star_tag;
struct complement_tag;
struct address_of_tag;
struct logical_not_tag;
struct pre_inc_tag;
struct pre_dec_tag;
struct post_inc_tag;
struct post_dec_tag;
struct left_shift_tag;
struct right_shift_tag;
struct multiply_tag;
struct divide_tag;
struct modulus_tag;
struct add_tag;
struct subtract_tag;
struct less_tag;
struct greater_tag;
struct less_equal_tag;
struct greater_equal_tag;
struct equal_tag;
struct not_equal_tag;
struct logical_or_tag;
struct logical_and_tag;
struct bitand_tag;
struct bitor_tag;
struct bitxor_tag;
struct comma_tag;
struct mem_ptr_tag;
struct assign_tag;
struct left_shift_assign_tag;
struct right_shift_assign_tag;
struct multiply_assign_tag;
struct divide_assign_tag;
struct modulus_assign_tag;
struct add_assign_tag;
struct subtract_assign_tag;
struct bitand_assign_tag;
struct bitor_assign_tag;
struct bitxor_assign_tag;
struct subscript_tag;
struct function_tag;
template<typename Tag>
struct is_unary;
template<typename Tag>
struct is_binary;
template<typename Tag>
struct is_nary;
template<typename Arg, typename Op>
struct unary_op;
template<typename Left, typename Right, typename Op>
struct binary_op;
template<typename Op, typename Param = void>
struct op_proxy;
template
<
typename Fun
, BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_ARITY, typename A,
fusion::void_t)
>
struct nary_op;
template<typename Op, typename Arg>
unary_op<Arg, Op> const
make_op(Arg const &arg);
template<typename Op, typename Left, typename Right>
binary_op<Left, Right, Op> const
make_op(Left const &left, Right const &right);
template<typename Arg>
unary_op<Arg, noop_tag> const
noop(Arg const &arg);
struct op_root;
template<typename T>
struct is_proxy;
template<typename T>
struct is_op;
template<typename T, bool IsOp = is_op<T>::value>
struct as_op;
template<typename Op>
struct op_base;
template<typename T>
struct value_type;
template<typename Op>
struct arg_type;
template<typename Op>
struct left_type;
template<typename Op>
struct right_type;
template<typename Op>
struct tag_type;
template<typename OpTag, typename DomainTag, typename Dummy = void>
struct compiler;
template<typename OpTag, typename DomainTag, bool RightFirst = true>
struct fold_compiler;
template<typename Lambda, typename DomainTag, typename Compiler = void>
struct transform_compiler;
template<typename Lambda, typename DomainTag>
struct branch_compiler;
template<typename Predicate, typename IfCompiler, typename ElseCompiler>
struct conditional_compiler;
template<typename Lambda, typename Map>
struct switch_compiler;
struct error_compiler;
struct identity_transform;
struct arg_transform;
struct left_transform;
struct right_transform;
template<typename Always>
struct always_transform;
template<typename First, typename Second>
struct compose_transforms;
template<typename Predicate, typename IfTransform, typename ElseTransform =
identity_transform>
struct conditional_transform;
template<typename Op>
typename arg_type<Op>::const_reference arg(Op const &op);
template<typename Op>
typename left_type<Op>::const_reference left(Op const &op);
template<typename Op>
typename right_type<Op>::const_reference right(Op const &op);
template<typename Op, typename State, typename Visitor, typename DomainTag>
struct compile_result;
template<typename Op, typename State, typename Visitor, typename DomainTag>
typename compile_result<Op, State, Visitor, DomainTag>::type const
compile(Op const &op, State const &state, Visitor &visitor, DomainTag
tag_type);
}} // namespace boost::proto1
#endif
--- NEW FILE: proto_typeof.hpp ---
///////////////////////////////////////////////////////////////////////////////
/// \file proto_typeof.hpp
/// Type registrations so that proto1 expression templates can be used together
/// with the Boost.Typeof library.
//
// Copyright 2004 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_XPRESSIVE_PROTO_PROTO_TYPEOF_H
#define BOOST_XPRESSIVE_PROTO_PROTO_TYPEOF_H
// MS compatible compilers support #pragma once
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif
#include <boost/config.hpp>
#include <boost/typeof/typeof.hpp>
#include <boost/xpressive/proto/v1_/proto_fwd.hpp>
#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::unary_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::binary_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::nary_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::noop_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::unary_plus_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::unary_minus_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::unary_star_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::complement_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::address_of_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::logical_not_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::pre_inc_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::pre_dec_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::post_inc_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::post_dec_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::left_shift_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::right_shift_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::multiply_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::divide_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::modulus_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::add_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::subtract_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::less_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::greater_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::less_equal_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::greater_equal_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::equal_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::not_equal_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::logical_or_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::logical_and_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::bitand_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::bitor_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::bitxor_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::comma_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::mem_ptr_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::assign_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::left_shift_assign_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::right_shift_assign_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::multiply_assign_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::divide_assign_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::modulus_assign_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::add_assign_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::subtract_assign_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::bitand_assign_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::bitor_assign_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::bitxor_assign_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::subscript_tag)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto1::function_tag)
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto1::unary_op, (typename)(typename))
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto1::binary_op,
(typename)(typename)(typename))
#endif
-------------------------------------------------------------------------
Using Tomcat but need to do more? Need to support web services, security?
Get stuff done quickly with pre-integrated technology to make your job easier
Download IBM WebSphere Application Server v.1.0.1 based on Apache Geronimo
http://sel.as-us.falkag.net/sel?cmd=lnk&kid=120709&bid=263057&dat=121642
|
