logo       
<prev   next>

Choosing A Webhost:
A web hosting service is a type of Internet hosting service that allows individuals and organizations to provide their own website accessible via the World Wide Web. Web hosts are companies that provide space on a server they own for use by their clients as well as providing Internet connectivity, typically in a data center. Web hosts can also provide data center space and connectivity to the Internet for servers they do not own to be located in their data center, called colocation. more...

CVS: boost/boost/xpressive/proto make_expr.hpp, NONE, 1.1 basic_expr.hpp, 1: msg#00801

lib.boost.cvs

Subject: CVS: boost/boost/xpressive/proto make_expr.hpp, NONE, 1.1 basic_expr.hpp, 1.2, 1.3 fusion.hpp, 1.7, 1.8 proto_fwd.hpp, 1.14, 1.15 ref.hpp, 1.2, 1.3 traits.hpp, 1.2, 1.3

Update of /cvsroot/boost/boost/boost/xpressive/proto
In directory sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv17279/proto

Modified Files:
basic_expr.hpp fusion.hpp proto_fwd.hpp ref.hpp traits.hpp
Added Files:
make_expr.hpp
Log Message:
add make_expr, as_expr_ref and reimplement pass-through compiler

--- NEW FILE: make_expr.hpp ---
///////////////////////////////////////////////////////////////////////////////
/// \file unpack_expr.hpp
/// Given a Fusion sequence of arguments and the type of a proto Expression,
/// unpacks the sequence into the Expression.
//
// 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_PP_IS_ITERATING

#ifndef BOOST_PROTO_MAKE_EXPR_HPP_EAN_04_01_2005
#define BOOST_PROTO_MAKE_EXPR_HPP_EAN_04_01_2005

#include <boost/preprocessor/inc.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/punctuation/paren.hpp>
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/facilities/intercept.hpp>
#include <boost/preprocessor/repetition/enum.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/detail/workaround.hpp>
#include <boost/ref.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/xpressive/proto/proto_fwd.hpp>
#include <boost/xpressive/proto/traits.hpp>
#include <boost/fusion/sequence/intrinsic/size.hpp>
#include <boost/fusion/sequence/utility/unpack_args.hpp>

namespace boost { namespace proto
{

namespace detail
{
template<typename Tag, long Arity>
struct make_expr_impl;

#define BOOST_PROTO_AS_EXPR(z, n, data) proto::as_expr(BOOST_PP_CAT(a,
n))
#define BOOST_PP_ITERATION_PARAMS_1 (4, (1, BOOST_PROTO_MAX_ARITY,
<boost/xpressive/proto/make_expr.hpp>, 1))
#include BOOST_PP_ITERATE()
#undef BOOST_PP_ITERATION_PARAMS_1
#undef BOOST_PROTO_AS_EXPR
}

#define BOOST_PP_ITERATION_PARAMS_1 (4, (1, BOOST_PROTO_MAX_ARITY,
<boost/xpressive/proto/make_expr.hpp>, 2))
#include BOOST_PP_ITERATE()
#undef BOOST_PP_ITERATION_PARAMS_1

namespace meta
{
template<typename Tag, typename Sequence>
struct unpack_expr
: fusion::result_of::unpack_args<
detail::make_expr_impl<Tag,
fusion::result_of::size<Sequence>::type::value>
, Sequence
>
{};
}

template<typename Tag, typename Sequence>
typename meta::unpack_expr<Tag, Sequence const>::type
unpack_expr(Sequence const &sequence)
{
detail::make_expr_impl<Tag,
fusion::result_of::size<Sequence>::type::value> make_expr;
return fusion::unpack_args(make_expr, sequence);
}

}}

#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1400))

// Work around annoying boost::result_of with MSVC
#define BOOST_PP_ITERATION_PARAMS_1 (4, (1, BOOST_PROTO_MAX_ARITY,
<boost/xpressive/proto/make_expr.hpp>, 3))
#include BOOST_PP_ITERATE()
#undef BOOST_PP_ITERATION_PARAMS_1

#endif

#endif // BOOST_PROTO_MAKE_EXPR_HPP_EAN_04_01_2005

#elif 1 == BOOST_PP_ITERATION_FLAGS()

#define N BOOST_PP_ITERATION()

template<typename Tag>
struct make_expr_impl<Tag, N>
{
template<BOOST_PP_ENUM_PARAMS(N, typename A)>
struct result_
{
typedef basic_expr<Tag, BOOST_PP_CAT(mpl::vector, N)<
BOOST_PP_ENUM_BINARY_PARAMS(N, typename
meta::as_expr<A, >::type BOOST_PP_INTERCEPT)
> > type;
};

template<typename Sig>
struct result;

template<typename This BOOST_PP_ENUM_TRAILING_PARAMS(N,
typename A)>
struct result<This(BOOST_PP_ENUM_PARAMS(N, A))>
: result_<BOOST_PP_ENUM_BINARY_PARAMS(N, typename
meta::value_type<A, >::type BOOST_PP_INTERCEPT)>
{};

template<BOOST_PP_ENUM_PARAMS(N, typename A)>
typename result_<BOOST_PP_ENUM_PARAMS(N, A)>::type
operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const &a)) const
{
typename result_<BOOST_PP_ENUM_PARAMS(N, A)>::type that =
{BOOST_PP_ENUM(N, BOOST_PROTO_AS_EXPR, _)};
return that;
}
};

#undef N

#elif 2 == BOOST_PP_ITERATION_FLAGS()

#define N BOOST_PP_ITERATION()

template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
typename detail::make_expr_impl<Tag, N>::BOOST_NESTED_TEMPLATE
result_<BOOST_PP_ENUM_PARAMS(N, A)>::type
make_expr(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const &a))
{
return detail::make_expr_impl<Tag, N>()(BOOST_PP_ENUM_PARAMS(N, a));
}

#undef N

#elif 3 == BOOST_PP_ITERATION_FLAGS()

#define N BOOST_PP_ITERATION()

namespace boost
{
template<typename Tag, long Arity BOOST_PP_ENUM_TRAILING_PARAMS(N,
typename A)>
struct result_of<proto::detail::make_expr_impl<Tag,
Arity>(BOOST_PP_ENUM_PARAMS(N, A))>
: proto::detail::make_expr_impl<Tag, Arity>::template
result_<BOOST_PP_ENUM_BINARY_PARAMS(N, typename proto::meta::value_type<A,
>::type BOOST_PP_INTERCEPT)>
{};
}

#undef N

#endif

Index: basic_expr.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/basic_expr.hpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- basic_expr.hpp 29 Oct 2006 06:14:41 -0000 1.2
+++ basic_expr.hpp 30 Oct 2006 02:00:19 -0000 1.3
@@ -39,11 +39,12 @@
/**/

#define BOOST_PROTO_AS_OP(z, n, data)\
- proto::as_expr(BOOST_PP_CAT(a,n))\
+ proto::as_expr_ref(BOOST_PP_CAT(a,n))\
/**/

#define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY,
<boost/xpressive/proto/basic_expr.hpp>))
#include BOOST_PP_ITERATE()
+ #undef BOOST_PP_ITERATION_PARAMS_1

#undef BOOST_PROTO_ARG
#undef BOOST_PROTO_VOID
@@ -60,6 +61,7 @@
typedef Tag tag_type;
typedef Args args_type;
typedef mpl::long_<BOOST_PP_ITERATION()> arity;
+ typedef proto_expr_tag tag;
typedef proto_expr_tag fusion_tag;

BOOST_PP_REPEAT(BOOST_PP_ITERATION(), BOOST_PROTO_ARG, _)
@@ -71,18 +73,18 @@
}

template<typename A>
- basic_expr<assign_tag, mpl::vector2<ref<basic_expr>, typename
meta::as_expr<A>::type> > const
+ basic_expr<assign_tag, mpl::vector2<ref<basic_expr>, typename
meta::as_expr_ref<A>::type> > const
operator =(A const &a) const
{
- basic_expr<assign_tag, mpl::vector2<ref<basic_expr>, typename
meta::as_expr<A>::type> > that = {{*this}, proto::as_expr(a)};
+ basic_expr<assign_tag, mpl::vector2<ref<basic_expr>, typename
meta::as_expr_ref<A>::type> > that = {{*this}, proto::as_expr_ref(a)};
return that;
}

template<typename A>
- basic_expr<subscript_tag, mpl::vector2<ref<basic_expr>, typename
meta::as_expr<A>::type> > const
+ basic_expr<subscript_tag, mpl::vector2<ref<basic_expr>, typename
meta::as_expr_ref<A>::type> > const
operator [](A const &a) const
{
- basic_expr<subscript_tag, mpl::vector2<ref<basic_expr>,
typename meta::as_expr<A>::type> > that = {{*this}, proto::as_expr(a)};
+ basic_expr<subscript_tag, mpl::vector2<ref<basic_expr>,
typename meta::as_expr_ref<A>::type> > that = {{*this}, proto::as_expr_ref(a)};
return that;
}

@@ -95,16 +97,17 @@

#define BOOST_PP_ITERATION_PARAMS_2 (3, (1, BOOST_PROTO_MAX_ARITY,
<boost/xpressive/proto/basic_expr.hpp>))
#include BOOST_PP_ITERATE()
+ #undef BOOST_PP_ITERATION_PARAMS_2
};

#elif BOOST_PP_ITERATION_DEPTH() == 2

#define N BOOST_PP_ITERATION()
template<BOOST_PP_ENUM_PARAMS(N, typename A)>
- basic_expr<function_tag, BOOST_PP_CAT(mpl::vector,
BOOST_PP_INC(N))<ref<basic_expr> BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N,
typename meta::as_expr<A, >::type BOOST_PP_INTERCEPT)> > const
+ basic_expr<function_tag, BOOST_PP_CAT(mpl::vector,
BOOST_PP_INC(N))<ref<basic_expr> BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N,
typename meta::as_expr_ref<A, >::type BOOST_PP_INTERCEPT)> > const
operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const &a)) const
{
- basic_expr<function_tag, BOOST_PP_CAT(mpl::vector,
BOOST_PP_INC(N))<ref<basic_expr> BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N,
typename meta::as_expr<A, >::type BOOST_PP_INTERCEPT)> > that = {{*this}
BOOST_PP_ENUM_TRAILING(N, BOOST_PROTO_AS_OP, _)};
+ basic_expr<function_tag, BOOST_PP_CAT(mpl::vector,
BOOST_PP_INC(N))<ref<basic_expr> BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N,
typename meta::as_expr_ref<A, >::type BOOST_PP_INTERCEPT)> > that = {{*this}
BOOST_PP_ENUM_TRAILING(N, BOOST_PROTO_AS_OP, _)};
return that;
}
#undef N

Index: fusion.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/fusion.hpp,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -d -r1.7 -r1.8
--- fusion.hpp 29 Oct 2006 06:14:41 -0000 1.7
+++ fusion.hpp 30 Oct 2006 02:00:19 -0000 1.8
@@ -13,14 +13,13 @@
#include <boost/preprocessor/repetition/repeat.hpp>

#include <boost/mpl/if.hpp>
-//#include <boost/mpl/at.hpp>
-//#include <boost/mpl/size.hpp>
-//#include <boost/mpl/deref.hpp>
-//#include <boost/mpl/advance.hpp>
-//#include <boost/mpl/distance.hpp>
-//#include <boost/mpl/begin_end.hpp>
-//#include <boost/mpl/next_prior.hpp>
-//#include <boost/mpl/sequence_tag_fwd.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/advance.hpp>
+#include <boost/mpl/distance.hpp>
+#include <boost/mpl/begin_end.hpp>
+#include <boost/mpl/next_prior.hpp>

#include <boost/fusion/support/is_view.hpp>
#include <boost/fusion/support/tag_of_fwd.hpp>
@@ -42,7 +41,7 @@
template<typename Expr, long N>
struct arg_impl;

- #define BOOST_PROTO_DEFINE_GET_IMPL(z, N, data)\
+ #define BOOST_PROTO_DEFINE_ARG_IMPL(z, N, data)\
template<typename Expr>\
struct arg_impl<Expr, N>\
{\
@@ -55,7 +54,9 @@
};\
/**/

- BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_DEFINE_GET_IMPL, _)
+ BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_DEFINE_ARG_IMPL, _)
+
+ #undef BOOST_PROTO_DEFINE_ARG_IMPL

template<typename Expr, int Pos>
struct ref_iterator
@@ -64,6 +65,7 @@
typedef Expr expr_type;
typedef mpl::long_<Pos> index;
typedef fusion::forward_traversal_tag category;
+ typedef proto_ref_iterator_tag tag;
typedef proto_ref_iterator_tag fusion_tag;

ref_iterator(Expr expr)
@@ -305,61 +307,91 @@
}
}}

-//namespace boost { namespace mpl
-//{
-// template<typename Tag, typename Args, long Arity>
-// struct sequence_tag<proto::basic_expr<Tag, Args, Arity> >
-// {
-// typedef proto::proto_expr_tag type;
-// };
-//
-// template<typename Expr>
-// struct sequence_tag<proto::ref<Expr> >
-// {
-// typedef proto::proto_expr_tag type;
-// };
-//
-// template<>
-// struct begin_impl<proto::proto_expr_tag>
-// {
-// template<typename Sequence>
-// struct apply
-// : begin_impl<typename sequence_tag<typename
Sequence::args_type>::type>
-// ::template apply<typename Sequence::args_type>
-// {};
-// };
-//
-// template<>
-// struct end_impl<proto::proto_expr_tag>
-// {
-// template<typename Sequence>
-// struct apply
-// : end_impl<typename sequence_tag<typename
Sequence::args_type>::type>
-// ::template apply<typename Sequence::args_type>
-// {};
-// };
-//
-// template<>
-// struct size_impl<proto::proto_expr_tag>
-// {
-// template<typename Sequence>
-// struct apply
-// {
-// typedef typename Sequence::arity type;
-// };
-// };
-//
-// template<>
-// struct at_impl<proto::proto_expr_tag>
-// {
-// template<typename Sequence, typename N>
-// struct apply
-// : at_impl<typename sequence_tag<typename
Sequence::args_type>::type>
-// ::template apply<typename Sequence::args_type, N>
-// {};
-// };
-//
-//}} // namespace boost::mpl
+namespace boost { namespace mpl
+{
+ //template<>
+ //struct begin_impl<proto::proto_expr_tag>
+ //{
+ // template<typename Sequence>
+ // struct apply
+ // : begin_impl<typename sequence_tag<typename
Sequence::args_type>::type>
+ // ::template apply<typename Sequence::args_type>
+ // {};
+ //};
+
+ //template<>
+ //struct end_impl<proto::proto_expr_tag>
+ //{
+ // template<typename Sequence>
+ // struct apply
+ // : end_impl<typename sequence_tag<typename
Sequence::args_type>::type>
+ // ::template apply<typename Sequence::args_type>
+ // {};
+ //};
+
+ //template<>
+ //struct size_impl<proto::proto_expr_tag>
+ //{
+ // template<typename Sequence>
+ // struct apply
+ // {
+ // typedef typename Sequence::arity type;
+ // };
+ //};
+
+ //template<>
+ //struct at_impl<proto::proto_expr_tag>
+ //{
+ // template<typename Sequence, typename N>
+ // struct apply
+ // : at_impl<typename sequence_tag<typename
Sequence::args_type>::type>
+ // ::template apply<typename Sequence::args_type, N>
+ // {};
+ //};
+
+
+ template<>
+ struct begin_impl<proto::proto_ref_tag>
+ {
+ template<typename Sequence>
+ struct apply
+ : begin_impl<typename sequence_tag<typename
Sequence::args_type>::type>
+ ::template apply<typename Sequence::args_type>
+ {};
+ };
+
+ template<>
+ struct end_impl<proto::proto_ref_tag>
+ {
+ template<typename Sequence>
+ struct apply
+ : end_impl<typename sequence_tag<typename Sequence::args_type>::type>
+ ::template apply<typename Sequence::args_type>
+ {};
+ };
+
+ template<>
+ struct size_impl<proto::proto_ref_tag>
+ {
+ template<typename Sequence>
+ struct apply
+ {
+ typedef typename Sequence::arity type;
+ };
+ };
+
+ template<>
+ struct at_impl<proto::proto_ref_tag>
+ {
+ template<typename Sequence, typename N>
+ struct apply
+ : at_impl<typename sequence_tag<typename Sequence::args_type>::type>
+ ::template apply<typename Sequence::args_type, N>
+ {};
+ };
+
+
+}} // namespace boost::mpl

//namespace boost { namespace mpl
//{

Index: proto_fwd.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/proto_fwd.hpp,v
retrieving revision 1.14
retrieving revision 1.15
diff -u -d -r1.14 -r1.15
--- proto_fwd.hpp 29 Oct 2006 06:14:41 -0000 1.14
+++ proto_fwd.hpp 30 Oct 2006 02:00:19 -0000 1.15
@@ -137,11 +137,20 @@
};

template<typename T>
+ struct is_basic_expr;
+
+ template<typename T>
+ struct is_ref;
+
+ template<typename T>
struct is_expr;

template<typename T, bool IsExpr = is_expr<T>::value>
struct as_expr;

+ template<typename T, bool IsBasicExpr = is_basic_expr<T>::value, bool
IsRef = is_ref<T>::value>
+ struct as_expr_ref;
+
template<typename Expr, typename State, typename Visitor, typename
DomainTag>
struct compile;

@@ -175,12 +184,12 @@
namespace op
{
struct compile;
- struct as_expr;
struct make_terminal;
struct arg;
struct left;
struct right;
struct as_expr;
+ struct as_expr_ref;
}

}} // namespace boost::proto

Index: ref.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/ref.hpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- ref.hpp 29 Oct 2006 06:14:41 -0000 1.2
+++ ref.hpp 30 Oct 2006 02:00:19 -0000 1.3
@@ -25,6 +25,7 @@
typedef typename Expr::tag_type tag_type;
typedef typename Expr::args_type args_type;
typedef typename Expr::arity arity;
+ typedef proto_ref_tag tag;
typedef proto_ref_tag fusion_tag;

BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_ARG, _)

Index: traits.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/traits.hpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- traits.hpp 29 Oct 2006 06:14:41 -0000 1.2
+++ traits.hpp 30 Oct 2006 02:00:19 -0000 1.3
@@ -12,6 +12,7 @@
#define BOOST_PROTO_ARG_TRAITS_HPP_EAN_04_01_2005

#include <boost/ref.hpp>
+#include <boost/mpl/or.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/call_traits.hpp>
#include <boost/static_assert.hpp>
@@ -26,25 +27,47 @@

namespace meta
{
- // is_expr
+ // is_basic_expr
template<typename T>
- struct is_expr
+ struct is_basic_expr
: mpl::false_
{};

template<typename Tag, typename Args, long Arity>
- struct is_expr<basic_expr<Tag, Args, Arity> >
+ struct is_basic_expr<basic_expr<Tag, Args, Arity> >
: mpl::true_
{};

- template<typename Expr>
- struct is_expr<ref<Expr> >
+ template<typename T>
+ struct is_basic_expr<T const>
+ : is_basic_expr<T>
+ {};
+
+ // is_ref
+ template<typename T>
+ struct is_ref
+ : mpl::false_
+ {};
+
+ template<typename T>
+ struct is_ref<ref<T> >
: mpl::true_
{};

+ template<typename T>
+ struct is_ref<T const>
+ : is_ref<T>
+ {};
+
+ // is_expr
+ template<typename T>
+ struct is_expr
+ : mpl::or_<is_basic_expr<T>, is_ref<T> >
+ {};
+
// as_expr
- template<typename T, bool IsExpr>
- struct as_expr
+ template<typename T>
+ struct as_expr<T, false>
{
typedef basic_expr<terminal_tag, mpl::vector1<typename
call_traits<T>::value_type> > type;
};
@@ -52,13 +75,27 @@
template<typename T>
struct as_expr<T, true>
{
- typedef ref<T> type;
+ typedef T type;
};

+ // as_expr_ref
template<typename T>
- struct as_expr<ref<T>, true>
+ struct as_expr_ref<T, false, false>
{
- typedef ref<T> type;
+ typedef basic_expr<terminal_tag, mpl::vector1<typename
call_traits<T>::value_type> > type;
+ };
+
+ template<typename T>
+ struct as_expr_ref<T, true, false>
+ {
+ typedef ref<typename remove_cv<T>::type> type;
+ };
+
+ template<typename T>
+ struct as_expr_ref<T, false, true>
+ {
+ BOOST_STATIC_ASSERT(!is_ref<typename T::expr_type>::value);
+ typedef T type;
};

// arg
@@ -134,6 +171,36 @@
return that;
}

+ template<typename Tag, typename Args, long Arity>
+ basic_expr<Tag, Args, Arity> const &operator()(basic_expr<Tag,
Args, Arity> const &t) const
+ {
+ return t;
+ }
+
+ template<typename T>
+ ref<T> const &operator()(ref<T> const &t) const
+ {
+ return t;
+ }
+ };
+
+ struct as_expr_ref
+ {
+ template<typename Sig>
+ struct result;
+
+ template<typename This, typename T>
+ struct result<This(T)>
+ : meta::as_expr_ref<typename meta::value_type<T>::type>
+ {};
+
+ template<typename T>
+ typename meta::as_expr_ref<T>::type operator()(T const &t) const
+ {
+ typename meta::as_expr_ref<T>::type that = {t};
+ return that;
+ }
+
template<typename T>
ref<T> const &operator()(ref<T> const &t) const
{
@@ -213,62 +280,11 @@
}

op::as_expr const as_expr = {};
+ op::as_expr_ref const as_expr_ref = {};
op::make_terminal const make_terminal = {};
op::arg const arg = {};
op::left const left = {};
op::right const right = {};
-
-
///////////////////////////////////////////////////////////////////////////////
- // make_expr (unary)
- template<typename Tag, typename Arg>
- basic_expr<Tag, mpl::vector1<Arg> > const
- make_expr(Arg const &arg)
- {
- basic_expr<Tag, mpl::vector1<Arg> > that = {arg};
- return that;
- }
-
- template<typename Tag, typename Arg>
- basic_expr<Tag, mpl::vector1<ref<Arg> > > const
- make_expr(reference_wrapper<Arg> const &arg)
- {
- basic_expr<Tag, mpl::vector1<ref<Arg> > > that = {{arg.get()}};
- return that;
- }
-
-
///////////////////////////////////////////////////////////////////////////////
- // make_expr (binary)
- template<typename Tag, typename Left, typename Right>
- basic_expr<Tag, mpl::vector2<Left, Right> > const
- make_expr(Left const &left, Right const &right)
- {
- basic_expr<Tag, mpl::vector2<Left, Right> > that = {left, right};
- return that;
- }
-
- template<typename Tag, typename Left, typename Right>
- basic_expr<Tag, mpl::vector2<ref<Left>, Right> > const
- make_expr(reference_wrapper<Left> const &left, Right const &right)
- {
- basic_expr<Tag, mpl::vector2<ref<Left>, Right> > that = {{left.get()},
right};
- return that;
- }
-
- template<typename Tag, typename Left, typename Right>
- basic_expr<Tag, mpl::vector2<Left, ref<Right> > > const
- make_expr(Left const &left, reference_wrapper<Right> const &right)
- {
- basic_expr<Tag, mpl::vector2<Left, ref<Right> > > that = {left,
{right.get()}};
- return that;
- }
-
- template<typename Tag, typename Left, typename Right>
- basic_expr<Tag, mpl::vector2<ref<Left>, ref<Right> > > const
- make_expr(reference_wrapper<Left> const &left, reference_wrapper<Right>
const &right)
- {
- basic_expr<Tag, mpl::vector2<ref<Left>, ref<Right> > > that =
{{left.get()}, {right.get()}};
- return that;
- }
}}

#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
<Prev in Thread] Current Thread [Next in Thread>
Previous by Date:  CVS: boost/boost/xpressive/proto/compiler pass_through.hpp, 1.3, 1.4, Eric Niebler
Next by Date:  CVS: boost/boost/xpressive/proto fusion.hpp, 1.8, 1.9 make_expr.hpp, 1.1, 1.2, Eric Niebler
Previous by Thread:  CVS: boost/boost/xpressive/proto/compiler pass_through.hpp, 1.3, 1.4, Eric Niebler
Next by Thread:  CVS: boost/boost/xpressive/proto fusion.hpp, 1.8, 1.9 make_expr.hpp, 1.1, 1.2, Eric Niebler
Indexes:  [Date] [Thread] [Top] [All Lists]

Google Custom Search
Recently Viewed:
qnx.openqnx.dev...    gcc.libstdc++.c...    solaris.opensol...    information-ret...    misc.misterhous...    web.catalyst.ge...    apache.webservi...    redhat.release....    hardware.lirc/2...    kernel.autofs/2...    technology.sust...    linux.vdr/2003-...    editors.lyx.gen...    org.user-groups...    netbsd.devel.pk...    xdg.devel/2004-...    version-control...    jakarta.slide.d...    debian.packages...    creativecommons...    ports.ppc.embed...    bug-tracking.bu...   
Home | blog view | USPTO Patent Archive | advertise | OSDir is an inevitable website. super tiny logo

Free Magazines

Cisco News
Receive a free quarterly e-newsletter with exclusive articles on how Cisco IT uses its own products and solutions to enable the business.
subscribe

Systems Management News, the newspaper for IT systems administration and data center managers! Each issue of Systems Management News is chock-full of news and analysis to help you understand what's happening in your field.
subscribe

The Enterprise Newsweekly eWeek is the essential technology information source for builders of e-business.
subscribe

Oracle Magazine Oracle Magazine contains technology strategy articles, sample code, tips, Oracle and partner news, how to articles for developers and DBAs, and more. Oracle (NASDAQ: ORCL) is the world's largest enterprise software company.
subscribe

Total Telecom Total Telecom is "The Economist of the communications industry".
subscribe

Navigation