+++ /dev/null
-/*=============================================================================
- Phoenix V1.2.1
- Copyright (c) 2001-2002 Joel de Guzman
-
- 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 PHOENIX_OPERATORS_HPP
-#define PHOENIX_OPERATORS_HPP
-
-///////////////////////////////////////////////////////////////////////////////
-#if !defined(BOOST_NO_CWCTYPE)
- #include <cwctype>
-#endif
-
-#if defined(__BORLANDC__) || (defined(__ICL) && __ICL >= 700)
-#define CREF const&
-#else
-#define CREF
-#endif
-
-#include <climits>
-#include <boost/spirit/home/classic/phoenix/actor.hpp>
-#include <boost/spirit/home/classic/phoenix/composite.hpp>
-#include <boost/config.hpp>
-#include <boost/mpl/if.hpp>
-
-///////////////////////////////////////////////////////////////////////////////
-namespace phoenix {
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// Operators
-//
-// Lazy operators
-//
-// This class provides a mechanism for lazily evaluating operators.
-// Syntactically, a lazy operator looks like an ordinary C/C++
-// infix, prefix or postfix operator. The operator application
-// looks the same. However, unlike ordinary operators, the actual
-// operator execution is deferred. (see actor.hpp, primitives.hpp
-// and composite.hpp for an overview). Samples:
-//
-// arg1 + arg2
-// 1 + arg1 * arg2
-// 1 / -arg1
-// arg1 < 150
-//
-// T1 set of classes implement all the C++ free operators. Like
-// lazy functions (see functions.hpp), lazy operators are not
-// immediately executed when invoked. Instead, a composite (see
-// composite.hpp) object is created and returned to the caller.
-// Example:
-//
-// (arg1 + arg2) * arg3
-//
-// does nothing more than return a composite. T1 second function
-// call will evaluate the actual operators. Example:
-//
-// int i = 4, j = 5, k = 6;
-// cout << ((arg1 + arg2) * arg3)(i, j, k);
-//
-// will print out "54".
-//
-// Arbitrarily complex expressions can be lazily evaluated
-// following three simple rules:
-//
-// 1) Lazy evaluated binary operators apply when at least one
-// of the operands is an actor object (see actor.hpp and
-// primitives.hpp). Consequently, if an operand is not an actor
-// object, it is implicitly converted to an object of type
-// actor<value<T> > (where T is the original type of the
-// operand).
-//
-// 2) Lazy evaluated unary operators apply only to operands
-// which are actor objects.
-//
-// 3) The result of a lazy operator is a composite actor object
-// that can in turn apply to rule 1.
-//
-// Example:
-//
-// arg1 + 3
-//
-// is a lazy expression involving the operator+. Following rule 1,
-// lazy evaluation is triggered since arg1 is an instance of an
-// actor<argument<N> > class (see primitives.hpp). The right
-// operand <3> is implicitly converted to an actor<value<int> >.
-// The result of this binary + expression is a composite object,
-// following rule 3.
-//
-// Take note that although at least one of the operands must be a
-// valid actor class in order for lazy evaluation to take effect,
-// if this is not the case and we still want to lazily evaluate an
-// expression, we can use var(x), val(x) or cref(x) to transform
-// the operand into a valid action object (see primitives.hpp).
-// Example:
-//
-// val(1) << 3;
-//
-// Supported operators:
-//
-// Unary operators:
-//
-// prefix: ~, !, -, +, ++, --, & (reference), * (dereference)
-// postfix: ++, --
-//
-// Binary operators:
-//
-// =, [], +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=
-// +, -, *, /, %, &, |, ^, <<, >>
-// ==, !=, <, >, <=, >=
-// &&, ||
-//
-// Each operator has a special tag type associated with it. For
-// example the binary + operator has a plus_op tag type associated
-// with it. This is used to specialize either the unary_operator or
-// binary_operator template classes (see unary_operator and
-// binary_operator below). Specializations of these unary_operator
-// and binary_operator are the actual workhorses that implement the
-// operations. The behavior of each lazy operator depends on these
-// unary_operator and binary_operator specializations. 'preset'
-// specializations conform to the canonical operator rules modeled
-// by the behavior of integers and pointers:
-//
-// Prefix -, + and ~ accept constant arguments and return an
-// object by value.
-//
-// The ! accept constant arguments and returns a boolean
-// result.
-//
-// The & (address-of), * (dereference) both return a reference
-// to an object.
-//
-// Prefix ++ returns a reference to its mutable argument after
-// it is incremented.
-//
-// Postfix ++ returns the mutable argument by value before it
-// is incremented.
-//
-// The += and its family accept mutable right hand side (rhs)
-// operand and return a reference to the rhs operand.
-//
-// Infix + and its family accept constant arguments and return
-// an object by value.
-//
-// The == and its family accept constant arguments and return a
-// boolean result.
-//
-// Operators && and || accept constant arguments and return a
-// boolean result and are short circuit evaluated as expected.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// Operator tags
-//
-// Each C++ operator has a corresponding tag type. This is
-// used as a means for specializing the unary_operator and
-// binary_operator (see below). The tag also serves as the
-// lazy operator type compatible as a composite operation
-// see (composite.hpp).
-//
-///////////////////////////////////////////////////////////////////////////////
-
-// Unary operator tags
-
-struct negative_op; struct positive_op;
-struct logical_not_op; struct invert_op;
-struct reference_op; struct dereference_op;
-struct pre_incr_op; struct pre_decr_op;
-struct post_incr_op; struct post_decr_op;
-
-// Binary operator tags
-
-struct assign_op; struct index_op;
-struct plus_assign_op; struct minus_assign_op;
-struct times_assign_op; struct divide_assign_op; struct mod_assign_op;
-struct and_assign_op; struct or_assign_op; struct xor_assign_op;
-struct shift_l_assign_op; struct shift_r_assign_op;
-
-struct plus_op; struct minus_op;
-struct times_op; struct divide_op; struct mod_op;
-struct and_op; struct or_op; struct xor_op;
-struct shift_l_op; struct shift_r_op;
-
-struct eq_op; struct not_eq_op;
-struct lt_op; struct lt_eq_op;
-struct gt_op; struct gt_eq_op;
-struct logical_and_op; struct logical_or_op;
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// unary_operator<TagT, T>
-//
-// The unary_operator class implements most of the C++ unary
-// operators. Each specialization is basically a simple static eval
-// function plus a result_type typedef that determines the return
-// type of the eval function.
-//
-// TagT is one of the unary operator tags above and T is the data
-// type (argument) involved in the operation.
-//
-// Only the behavior of C/C++ built-in types are taken into account
-// in the specializations provided below. For user-defined types,
-// these specializations may still be used provided that the
-// operator overloads of such types adhere to the standard behavior
-// of built-in types.
-//
-// T1 separate special_ops.hpp file implements more stl savvy
-// specializations. Other more specialized unary_operator
-// implementations may be defined by the client for specific
-// unary operator tags/data types.
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename TagT, typename T>
-struct unary_operator;
-
-//////////////////////////////////
-template <typename T>
-struct unary_operator<negative_op, T> {
-
- typedef T const result_type;
- static result_type eval(T const& v)
- { return -v; }
-};
-
-//////////////////////////////////
-template <typename T>
-struct unary_operator<positive_op, T> {
-
- typedef T const result_type;
- static result_type eval(T const& v)
- { return +v; }
-};
-
-//////////////////////////////////
-template <typename T>
-struct unary_operator<logical_not_op, T> {
-
- typedef T const result_type;
- static result_type eval(T const& v)
- { return !v; }
-};
-
-//////////////////////////////////
-template <typename T>
-struct unary_operator<invert_op, T> {
-
- typedef T const result_type;
- static result_type eval(T const& v)
- { return ~v; }
-};
-
-//////////////////////////////////
-template <typename T>
-struct unary_operator<reference_op, T> {
-
- typedef T* result_type;
- static result_type eval(T& v)
- { return &v; }
-};
-
-//////////////////////////////////
-template <typename T>
-struct unary_operator<dereference_op, T*> {
-
- typedef T& result_type;
- static result_type eval(T* v)
- { return *v; }
-};
-
-//////////////////////////////////
-template <typename T>
-struct unary_operator<dereference_op, T* const> {
-
- typedef T& result_type;
- static result_type eval(T* const v)
- { return *v; }
-};
-
-//////////////////////////////////
-template <>
-struct unary_operator<dereference_op, nil_t> {
-
- // G++ eager template instantiation
- // somehow requires this.
- typedef nil_t result_type;
-};
-
-//////////////////////////////////
-#ifndef __BORLANDC__
-template <>
-struct unary_operator<dereference_op, nil_t const> {
-
- // G++ eager template instantiation
- // somehow requires this.
- typedef nil_t result_type;
-};
-#endif
-
-//////////////////////////////////
-template <typename T>
-struct unary_operator<pre_incr_op, T> {
-
- typedef T& result_type;
- static result_type eval(T& v)
- { return ++v; }
-};
-
-//////////////////////////////////
-template <typename T>
-struct unary_operator<pre_decr_op, T> {
-
- typedef T& result_type;
- static result_type eval(T& v)
- { return --v; }
-};
-
-//////////////////////////////////
-template <typename T>
-struct unary_operator<post_incr_op, T> {
-
- typedef T const result_type;
- static result_type eval(T& v)
- { T t(v); ++v; return t; }
-};
-
-//////////////////////////////////
-template <typename T>
-struct unary_operator<post_decr_op, T> {
-
- typedef T const result_type;
- static result_type eval(T& v)
- { T t(v); --v; return t; }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// rank<T>
-//
-// rank<T> class has a static int constant 'value' that defines the
-// absolute rank of a type. rank<T> is used to choose the result
-// type of binary operators such as +. The type with the higher
-// rank wins and is used as the operator's return type. T1 generic
-// user defined type has a very high rank and always wins when
-// compared against a user defined type. If this is not desireable,
-// one can write a rank specialization for the type.
-//
-// Take note that ranks 0..9999 are reserved for the framework.
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename T>
-struct rank { static int const value = INT_MAX; };
-
-template <> struct rank<void> { static int const value = 0; };
-template <> struct rank<bool> { static int const value = 10; };
-
-template <> struct rank<char> { static int const value = 20; };
-template <> struct rank<signed char> { static int const value = 20; };
-template <> struct rank<unsigned char> { static int const value = 30; };
-#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
-template <> struct rank<wchar_t> { static int const value = 40; };
-#endif // !defined(BOOST_NO_INTRINSIC_WCHAR_T)
-
-template <> struct rank<short> { static int const value = 50; };
-template <> struct rank<unsigned short> { static int const value = 60; };
-
-template <> struct rank<int> { static int const value = 70; };
-template <> struct rank<unsigned int> { static int const value = 80; };
-
-template <> struct rank<long> { static int const value = 90; };
-template <> struct rank<unsigned long> { static int const value = 100; };
-
-#ifdef BOOST_HAS_LONG_LONG
-template <> struct rank< ::boost::long_long_type> { static int const value = 110; };
-template <> struct rank< ::boost::ulong_long_type> { static int const value = 120; };
-#endif
-
-template <> struct rank<float> { static int const value = 130; };
-template <> struct rank<double> { static int const value = 140; };
-template <> struct rank<long double> { static int const value = 150; };
-
-template <typename T> struct rank<T*>
-{ static int const value = 160; };
-
-template <typename T> struct rank<T* const>
-{ static int const value = 160; };
-
-template <typename T, int N> struct rank<T[N]>
-{ static int const value = 160; };
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// higher_rank<T0, T1>
-//
-// Chooses the type (T0 or T1) with the higher rank.
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename T0, typename T1>
-struct higher_rank {
- typedef typename boost::mpl::if_c<
- rank<T0>::value < rank<T1>::value,
- T1, T0>::type type;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// binary_operator<TagT, T0, T1>
-//
-// The binary_operator class implements most of the C++ binary
-// operators. Each specialization is basically a simple static eval
-// function plus a result_type typedef that determines the return
-// type of the eval function.
-//
-// TagT is one of the binary operator tags above T0 and T1 are the
-// (arguments') data types involved in the operation.
-//
-// Only the behavior of C/C++ built-in types are taken into account
-// in the specializations provided below. For user-defined types,
-// these specializations may still be used provided that the
-// operator overloads of such types adhere to the standard behavior
-// of built-in types.
-//
-// T1 separate special_ops.hpp file implements more stl savvy
-// specializations. Other more specialized unary_operator
-// implementations may be defined by the client for specific
-// unary operator tags/data types.
-//
-// All binary_operator except the logical_and_op and logical_or_op
-// have an eval static function that carries out the actual operation.
-// The logical_and_op and logical_or_op d are special because these
-// two operators are short-circuit evaluated.
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename TagT, typename T0, typename T1>
-struct binary_operator;
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<assign_op, T0, T1> {
-
- typedef T0& result_type;
- static result_type eval(T0& lhs, T1 const& rhs)
- { return lhs = rhs; }
-};
-
-//////////////////////////////////
-template <typename T1>
-struct binary_operator<index_op, nil_t, T1> {
-
- // G++ eager template instantiation
- // somehow requires this.
- typedef nil_t result_type;
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<index_op, T0*, T1> {
-
- typedef T0& result_type;
- static result_type eval(T0* ptr, T1 const& index)
- { return ptr[index]; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<index_op, T0* const, T1> {
-
- typedef T0& result_type;
- static result_type eval(T0* const ptr, T1 const& index)
- { return ptr[index]; }
-};
-
-//////////////////////////////////
-template <typename T0, int N, typename T1>
-struct binary_operator<index_op, T0[N], T1> {
-
- typedef T0& result_type;
- static result_type eval(T0* ptr, T1 const& index)
- { return ptr[index]; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<plus_assign_op, T0, T1> {
-
- typedef T0& result_type;
- static result_type eval(T0& lhs, T1 const& rhs)
- { return lhs += rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<minus_assign_op, T0, T1> {
-
- typedef T0& result_type;
- static result_type eval(T0& lhs, T1 const& rhs)
- { return lhs -= rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<times_assign_op, T0, T1> {
-
- typedef T0& result_type;
- static result_type eval(T0& lhs, T1 const& rhs)
- { return lhs *= rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<divide_assign_op, T0, T1> {
-
- typedef T0& result_type;
- static result_type eval(T0& lhs, T1 const& rhs)
- { return lhs /= rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<mod_assign_op, T0, T1> {
-
- typedef T0& result_type;
- static result_type eval(T0& lhs, T1 const& rhs)
- { return lhs %= rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<and_assign_op, T0, T1> {
-
- typedef T0& result_type;
- static result_type eval(T0& lhs, T1 const& rhs)
- { return lhs &= rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<or_assign_op, T0, T1> {
-
- typedef T0& result_type;
- static result_type eval(T0& lhs, T1 const& rhs)
- { return lhs |= rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<xor_assign_op, T0, T1> {
-
- typedef T0& result_type;
- static result_type eval(T0& lhs, T1 const& rhs)
- { return lhs ^= rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<shift_l_assign_op, T0, T1> {
-
- typedef T0& result_type;
- static result_type eval(T0& lhs, T1 const& rhs)
- { return lhs <<= rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<shift_r_assign_op, T0, T1> {
-
- typedef T0& result_type;
- static result_type eval(T0& lhs, T1 const& rhs)
- { return lhs >>= rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<plus_op, T0, T1> {
-
- typedef typename higher_rank<T0, T1>::type const result_type;
- static result_type eval(T0 const& lhs, T1 const& rhs)
- { return lhs + rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<minus_op, T0, T1> {
-
- typedef typename higher_rank<T0, T1>::type const result_type;
- static result_type eval(T0 const& lhs, T1 const& rhs)
- { return lhs - rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<times_op, T0, T1> {
-
- typedef typename higher_rank<T0, T1>::type const result_type;
- static result_type eval(T0 const& lhs, T1 const& rhs)
- { return lhs * rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<divide_op, T0, T1> {
-
- typedef typename higher_rank<T0, T1>::type const result_type;
- static result_type eval(T0 const& lhs, T1 const& rhs)
- { return lhs / rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<mod_op, T0, T1> {
-
- typedef typename higher_rank<T0, T1>::type const result_type;
- static result_type eval(T0 const& lhs, T1 const& rhs)
- { return lhs % rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<and_op, T0, T1> {
-
- typedef typename higher_rank<T0, T1>::type const result_type;
- static result_type eval(T0 const& lhs, T1 const& rhs)
- { return lhs & rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<or_op, T0, T1> {
-
- typedef typename higher_rank<T0, T1>::type const result_type;
- static result_type eval(T0 const& lhs, T1 const& rhs)
- { return lhs | rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<xor_op, T0, T1> {
-
- typedef typename higher_rank<T0, T1>::type const result_type;
- static result_type eval(T0 const& lhs, T1 const& rhs)
- { return lhs ^ rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<shift_l_op, T0, T1> {
-
- typedef T0 const result_type;
- static result_type eval(T0 const& lhs, T1 const& rhs)
- { return lhs << rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<shift_r_op, T0, T1> {
-
- typedef T0 const result_type;
- static result_type eval(T0 const& lhs, T1 const& rhs)
- { return lhs >> rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<eq_op, T0, T1> {
-
- typedef bool result_type;
- static result_type eval(T0 const& lhs, T1 const& rhs)
- { return lhs == rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<not_eq_op, T0, T1> {
-
- typedef bool result_type;
- static result_type eval(T0 const& lhs, T1 const& rhs)
- { return lhs != rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<lt_op, T0, T1> {
-
- typedef bool result_type;
- static result_type eval(T0 const& lhs, T1 const& rhs)
- { return lhs < rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<lt_eq_op, T0, T1> {
-
- typedef bool result_type;
- static result_type eval(T0 const& lhs, T1 const& rhs)
- { return lhs <= rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<gt_op, T0, T1> {
-
- typedef bool result_type;
- static result_type eval(T0 const& lhs, T1 const& rhs)
- { return lhs > rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<gt_eq_op, T0, T1> {
-
- typedef bool result_type;
- static result_type eval(T0 const& lhs, T1 const& rhs)
- { return lhs >= rhs; }
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<logical_and_op, T0, T1> {
-
- typedef bool result_type;
- // no eval function, see comment above.
-};
-
-//////////////////////////////////
-template <typename T0, typename T1>
-struct binary_operator<logical_or_op, T0, T1> {
-
- typedef bool result_type;
- // no eval function, see comment above.
-};
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// negative lazy operator (prefix -)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct negative_op {
-
- template <typename T0>
- struct result {
-
- typedef typename unary_operator<negative_op, T0>::result_type type;
- };
-
- template <typename T0>
- typename unary_operator<negative_op, T0>::result_type
- operator()(T0& _0) const
- { return unary_operator<negative_op, T0>::eval(_0); }
-};
-
-//////////////////////////////////
-template <typename BaseT>
-inline typename impl::make_unary<negative_op, BaseT>::type
-operator-(actor<BaseT> const& _0)
-{
- return impl::make_unary<negative_op, BaseT>::construct(_0);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// positive lazy operator (prefix +)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct positive_op {
-
- template <typename T0>
- struct result {
-
- typedef typename unary_operator<positive_op, T0>::result_type type;
- };
-
- template <typename T0>
- typename unary_operator<positive_op, T0>::result_type
- operator()(T0& _0) const
- { return unary_operator<positive_op, T0>::eval(_0); }
-};
-
-//////////////////////////////////
-template <typename BaseT>
-inline typename impl::make_unary<positive_op, BaseT>::type
-operator+(actor<BaseT> const& _0)
-{
- return impl::make_unary<positive_op, BaseT>::construct(_0);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// logical not lazy operator (prefix !)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct logical_not_op {
-
- template <typename T0>
- struct result {
-
- typedef typename unary_operator<logical_not_op, T0>::result_type type;
- };
-
- template <typename T0>
- typename unary_operator<logical_not_op, T0>::result_type
- operator()(T0& _0) const
- { return unary_operator<logical_not_op, T0>::eval(_0); }
-};
-
-//////////////////////////////////
-template <typename BaseT>
-inline typename impl::make_unary<logical_not_op, BaseT>::type
-operator!(actor<BaseT> const& _0)
-{
- return impl::make_unary<logical_not_op, BaseT>::construct(_0);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// invert lazy operator (prefix ~)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct invert_op {
-
- template <typename T0>
- struct result {
-
- typedef typename unary_operator<invert_op, T0>::result_type type;
- };
-
- template <typename T0>
- typename unary_operator<invert_op, T0>::result_type
- operator()(T0& _0) const
- { return unary_operator<invert_op, T0>::eval(_0); }
-};
-
-//////////////////////////////////
-template <typename BaseT>
-inline typename impl::make_unary<invert_op, BaseT>::type
-operator~(actor<BaseT> const& _0)
-{
- return impl::make_unary<invert_op, BaseT>::construct(_0);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// reference lazy operator (prefix &)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct reference_op {
-
- template <typename T0>
- struct result {
-
- typedef typename unary_operator<reference_op, T0>::result_type type;
- };
-
- template <typename T0>
- typename unary_operator<reference_op, T0>::result_type
- operator()(T0& _0) const
- { return unary_operator<reference_op, T0>::eval(_0); }
-};
-
-//////////////////////////////////
-template <typename BaseT>
-inline typename impl::make_unary<reference_op, BaseT>::type
-operator&(actor<BaseT> const& _0)
-{
- return impl::make_unary<reference_op, BaseT>::construct(_0);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// dereference lazy operator (prefix *)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct dereference_op {
-
- template <typename T0>
- struct result {
-
- typedef typename unary_operator<dereference_op, T0>::result_type type;
- };
-
- template <typename T0>
- typename unary_operator<dereference_op, T0>::result_type
- operator()(T0& _0) const
- { return unary_operator<dereference_op, T0>::eval(_0); }
-};
-
-//////////////////////////////////
-template <typename BaseT>
-inline typename impl::make_unary<dereference_op, BaseT>::type
-operator*(actor<BaseT> const& _0)
-{
- return impl::make_unary<dereference_op, BaseT>::construct(_0);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// pre increment lazy operator (prefix ++)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct pre_incr_op {
-
- template <typename T0>
- struct result {
-
- typedef typename unary_operator<pre_incr_op, T0>::result_type type;
- };
-
- template <typename T0>
- typename unary_operator<pre_incr_op, T0>::result_type
- operator()(T0& _0) const
- { return unary_operator<pre_incr_op, T0>::eval(_0); }
-};
-
-//////////////////////////////////
-template <typename BaseT>
-inline typename impl::make_unary<pre_incr_op, BaseT>::type
-operator++(actor<BaseT> const& _0)
-{
- return impl::make_unary<pre_incr_op, BaseT>::construct(_0);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// pre decrement lazy operator (prefix --)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct pre_decr_op {
-
- template <typename T0>
- struct result {
-
- typedef typename unary_operator<pre_decr_op, T0>::result_type type;
- };
-
- template <typename T0>
- typename unary_operator<pre_decr_op, T0>::result_type
- operator()(T0& _0) const
- { return unary_operator<pre_decr_op, T0>::eval(_0); }
-};
-
-//////////////////////////////////
-template <typename BaseT>
-inline typename impl::make_unary<pre_decr_op, BaseT>::type
-operator--(actor<BaseT> const& _0)
-{
- return impl::make_unary<pre_decr_op, BaseT>::construct(_0);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// post increment lazy operator (postfix ++)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct post_incr_op {
-
- template <typename T0>
- struct result {
-
- typedef typename unary_operator<post_incr_op, T0>::result_type type;
- };
-
- template <typename T0>
- typename unary_operator<post_incr_op, T0>::result_type
- operator()(T0& _0) const
- { return unary_operator<post_incr_op, T0>::eval(_0); }
-};
-
-//////////////////////////////////
-template <typename BaseT>
-inline typename impl::make_unary<post_incr_op, BaseT>::type
-operator++(actor<BaseT> const& _0, int)
-{
- return impl::make_unary<post_incr_op, BaseT>::construct(_0);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// post decrement lazy operator (postfix --)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct post_decr_op {
-
- template <typename T0>
- struct result {
-
- typedef typename unary_operator<post_decr_op, T0>::result_type type;
- };
-
- template <typename T0>
- typename unary_operator<post_decr_op, T0>::result_type
- operator()(T0& _0) const
- { return unary_operator<post_decr_op, T0>::eval(_0); }
-};
-
-//////////////////////////////////
-template <typename BaseT>
-inline typename impl::make_unary<post_decr_op, BaseT>::type
-operator--(actor<BaseT> const& _0, int)
-{
- return impl::make_unary<post_decr_op, BaseT>::construct(_0);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// assignment lazy operator (infix =)
-// The acual lazy operator is a member of the actor class.
-//
-///////////////////////////////////////////////////////////////////////////////
-struct assign_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<assign_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<assign_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<assign_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT>
-template <typename B>
-inline typename impl::make_binary1<assign_op, BaseT, B>::type
-actor<BaseT>::operator=(B const& _1) const
-{
- return impl::make_binary1<assign_op, BaseT, B>::construct(*this, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// index lazy operator (array index [])
-// The acual lazy operator is a member of the actor class.
-//
-///////////////////////////////////////////////////////////////////////////////
-struct index_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<index_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<index_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<index_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT>
-template <typename B>
-inline typename impl::make_binary1<index_op, BaseT, B>::type
-actor<BaseT>::operator[](B const& _1) const
-{
- return impl::make_binary1<index_op, BaseT, B>::construct(*this, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// plus assign lazy operator (infix +=)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct plus_assign_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<plus_assign_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<plus_assign_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<plus_assign_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<plus_assign_op, BaseT, T1>::type
-operator+=(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<plus_assign_op, BaseT, T1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// minus assign lazy operator (infix -=)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct minus_assign_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<minus_assign_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<minus_assign_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<minus_assign_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<minus_assign_op, BaseT, T1>::type
-operator-=(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<minus_assign_op, BaseT, T1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// times assign lazy operator (infix *=)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct times_assign_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<times_assign_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<times_assign_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<times_assign_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<times_assign_op, BaseT, T1>::type
-operator*=(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<times_assign_op, BaseT, T1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// divide assign lazy operator (infix /=)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct divide_assign_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<divide_assign_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<divide_assign_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<divide_assign_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<divide_assign_op, BaseT, T1>::type
-operator/=(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<divide_assign_op, BaseT, T1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// mod assign lazy operator (infix %=)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct mod_assign_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<mod_assign_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<mod_assign_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<mod_assign_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<mod_assign_op, BaseT, T1>::type
-operator%=(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<mod_assign_op, BaseT, T1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// and assign lazy operator (infix &=)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct and_assign_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<and_assign_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<and_assign_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<and_assign_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<and_assign_op, BaseT, T1>::type
-operator&=(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<and_assign_op, BaseT, T1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// or assign lazy operator (infix |=)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct or_assign_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<or_assign_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<or_assign_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<or_assign_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<or_assign_op, BaseT, T1>::type
-operator|=(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<or_assign_op, BaseT, T1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// xor assign lazy operator (infix ^=)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct xor_assign_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<xor_assign_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<xor_assign_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<xor_assign_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<xor_assign_op, BaseT, T1>::type
-operator^=(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<xor_assign_op, BaseT, T1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// shift left assign lazy operator (infix <<=)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct shift_l_assign_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<shift_l_assign_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<shift_l_assign_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<shift_l_assign_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<shift_l_assign_op, BaseT, T1>::type
-operator<<=(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<shift_l_assign_op, BaseT, T1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// shift right assign lazy operator (infix >>=)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct shift_r_assign_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<shift_r_assign_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<shift_r_assign_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<shift_r_assign_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<shift_r_assign_op, BaseT, T1>::type
-operator>>=(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<shift_r_assign_op, BaseT, T1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// plus lazy operator (infix +)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct plus_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<plus_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<plus_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<plus_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<plus_op, BaseT, T1>::type
-operator+(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<plus_op, BaseT, T1>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename T0, typename BaseT>
-inline typename impl::make_binary2<plus_op, T0, BaseT>::type
-operator+(T0 CREF _0, actor<BaseT> const& _1)
-{
- return impl::make_binary2<plus_op, T0, BaseT>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename BaseT0, typename BaseT1>
-inline typename impl::make_binary3<plus_op, BaseT0, BaseT1>::type
-operator+(actor<BaseT0> const& _0, actor<BaseT1> const& _1)
-{
- return impl::make_binary3<plus_op, BaseT0, BaseT1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// minus lazy operator (infix -)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct minus_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<minus_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<minus_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<minus_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<minus_op, BaseT, T1>::type
-operator-(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<minus_op, BaseT, T1>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename T0, typename BaseT>
-inline typename impl::make_binary2<minus_op, T0, BaseT>::type
-operator-(T0 CREF _0, actor<BaseT> const& _1)
-{
- return impl::make_binary2<minus_op, T0, BaseT>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename BaseT0, typename BaseT1>
-inline typename impl::make_binary3<minus_op, BaseT0, BaseT1>::type
-operator-(actor<BaseT0> const& _0, actor<BaseT1> const& _1)
-{
- return impl::make_binary3<minus_op, BaseT0, BaseT1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// times lazy operator (infix *)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct times_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<times_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<times_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<times_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<times_op, BaseT, T1>::type
-operator*(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<times_op, BaseT, T1>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename T0, typename BaseT>
-inline typename impl::make_binary2<times_op, T0, BaseT>::type
-operator*(T0 CREF _0, actor<BaseT> const& _1)
-{
- return impl::make_binary2<times_op, T0, BaseT>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename BaseT0, typename BaseT1>
-inline typename impl::make_binary3<times_op, BaseT0, BaseT1>::type
-operator*(actor<BaseT0> const& _0, actor<BaseT1> const& _1)
-{
- return impl::make_binary3<times_op, BaseT0, BaseT1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// divide lazy operator (infix /)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct divide_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<divide_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<divide_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<divide_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<divide_op, BaseT, T1>::type
-operator/(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<divide_op, BaseT, T1>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename T0, typename BaseT>
-inline typename impl::make_binary2<divide_op, T0, BaseT>::type
-operator/(T0 CREF _0, actor<BaseT> const& _1)
-{
- return impl::make_binary2<divide_op, T0, BaseT>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename BaseT0, typename BaseT1>
-inline typename impl::make_binary3<divide_op, BaseT0, BaseT1>::type
-operator/(actor<BaseT0> const& _0, actor<BaseT1> const& _1)
-{
- return impl::make_binary3<divide_op, BaseT0, BaseT1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// mod lazy operator (infix %)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct mod_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<mod_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<mod_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<mod_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<mod_op, BaseT, T1>::type
-operator%(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<mod_op, BaseT, T1>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename T0, typename BaseT>
-inline typename impl::make_binary2<mod_op, T0, BaseT>::type
-operator%(T0 CREF _0, actor<BaseT> const& _1)
-{
- return impl::make_binary2<mod_op, T0, BaseT>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename BaseT0, typename BaseT1>
-inline typename impl::make_binary3<mod_op, BaseT0, BaseT1>::type
-operator%(actor<BaseT0> const& _0, actor<BaseT1> const& _1)
-{
- return impl::make_binary3<mod_op, BaseT0, BaseT1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// and lazy operator (infix &)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct and_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<and_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<and_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<and_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<and_op, BaseT, T1>::type
-operator&(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<and_op, BaseT, T1>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename T0, typename BaseT>
-inline typename impl::make_binary2<and_op, T0, BaseT>::type
-operator&(T0 CREF _0, actor<BaseT> const& _1)
-{
- return impl::make_binary2<and_op, T0, BaseT>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename BaseT0, typename BaseT1>
-inline typename impl::make_binary3<and_op, BaseT0, BaseT1>::type
-operator&(actor<BaseT0> const& _0, actor<BaseT1> const& _1)
-{
- return impl::make_binary3<and_op, BaseT0, BaseT1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// or lazy operator (infix |)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct or_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<or_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<or_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<or_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<or_op, BaseT, T1>::type
-operator|(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<or_op, BaseT, T1>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename T0, typename BaseT>
-inline typename impl::make_binary2<or_op, T0, BaseT>::type
-operator|(T0 CREF _0, actor<BaseT> const& _1)
-{
- return impl::make_binary2<or_op, T0, BaseT>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename BaseT0, typename BaseT1>
-inline typename impl::make_binary3<or_op, BaseT0, BaseT1>::type
-operator|(actor<BaseT0> const& _0, actor<BaseT1> const& _1)
-{
- return impl::make_binary3<or_op, BaseT0, BaseT1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// xor lazy operator (infix ^)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct xor_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<xor_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<xor_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<xor_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<xor_op, BaseT, T1>::type
-operator^(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<xor_op, BaseT, T1>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename T0, typename BaseT>
-inline typename impl::make_binary2<xor_op, T0, BaseT>::type
-operator^(T0 CREF _0, actor<BaseT> const& _1)
-{
- return impl::make_binary2<xor_op, T0, BaseT>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename BaseT0, typename BaseT1>
-inline typename impl::make_binary3<xor_op, BaseT0, BaseT1>::type
-operator^(actor<BaseT0> const& _0, actor<BaseT1> const& _1)
-{
- return impl::make_binary3<xor_op, BaseT0, BaseT1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// shift left lazy operator (infix <<)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct shift_l_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<shift_l_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<shift_l_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<shift_l_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<shift_l_op, BaseT, T1>::type
-operator<<(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<shift_l_op, BaseT, T1>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename T0, typename BaseT>
-inline typename impl::make_binary2<shift_l_op, T0, BaseT>::type
-operator<<(T0 CREF _0, actor<BaseT> const& _1)
-{
- return impl::make_binary2<shift_l_op, T0, BaseT>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename BaseT0, typename BaseT1>
-inline typename impl::make_binary3<shift_l_op, BaseT0, BaseT1>::type
-operator<<(actor<BaseT0> const& _0, actor<BaseT1> const& _1)
-{
- return impl::make_binary3<shift_l_op, BaseT0, BaseT1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// shift right lazy operator (infix >>)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct shift_r_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<shift_r_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<shift_r_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<shift_r_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<shift_r_op, BaseT, T1>::type
-operator>>(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<shift_r_op, BaseT, T1>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename T0, typename BaseT>
-inline typename impl::make_binary2<shift_r_op, T0, BaseT>::type
-operator>>(T0 CREF _0, actor<BaseT> const& _1)
-{
- return impl::make_binary2<shift_r_op, T0, BaseT>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename BaseT0, typename BaseT1>
-inline typename impl::make_binary3<shift_r_op, BaseT0, BaseT1>::type
-operator>>(actor<BaseT0> const& _0, actor<BaseT1> const& _1)
-{
- return impl::make_binary3<shift_r_op, BaseT0, BaseT1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// equal lazy operator (infix ==)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct eq_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<eq_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<eq_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<eq_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<eq_op, BaseT, T1>::type
-operator==(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<eq_op, BaseT, T1>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename T0, typename BaseT>
-inline typename impl::make_binary2<eq_op, T0, BaseT>::type
-operator==(T0 CREF _0, actor<BaseT> const& _1)
-{
- return impl::make_binary2<eq_op, T0, BaseT>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename BaseT0, typename BaseT1>
-inline typename impl::make_binary3<eq_op, BaseT0, BaseT1>::type
-operator==(actor<BaseT0> const& _0, actor<BaseT1> const& _1)
-{
- return impl::make_binary3<eq_op, BaseT0, BaseT1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// not equal lazy operator (infix !=)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct not_eq_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<not_eq_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<not_eq_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<not_eq_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<not_eq_op, BaseT, T1>::type
-operator!=(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<not_eq_op, BaseT, T1>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename T0, typename BaseT>
-inline typename impl::make_binary2<not_eq_op, T0, BaseT>::type
-operator!=(T0 CREF _0, actor<BaseT> const& _1)
-{
- return impl::make_binary2<not_eq_op, T0, BaseT>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename BaseT0, typename BaseT1>
-inline typename impl::make_binary3<not_eq_op, BaseT0, BaseT1>::type
-operator!=(actor<BaseT0> const& _0, actor<BaseT1> const& _1)
-{
- return impl::make_binary3<not_eq_op, BaseT0, BaseT1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// less than lazy operator (infix <)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct lt_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<lt_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<lt_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<lt_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<lt_op, BaseT, T1>::type
-operator<(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<lt_op, BaseT, T1>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename T0, typename BaseT>
-inline typename impl::make_binary2<lt_op, T0, BaseT>::type
-operator<(T0 CREF _0, actor<BaseT> const& _1)
-{
- return impl::make_binary2<lt_op, T0, BaseT>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename BaseT0, typename BaseT1>
-inline typename impl::make_binary3<lt_op, BaseT0, BaseT1>::type
-operator<(actor<BaseT0> const& _0, actor<BaseT1> const& _1)
-{
- return impl::make_binary3<lt_op, BaseT0, BaseT1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// less than equal lazy operator (infix <=)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct lt_eq_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<lt_eq_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<lt_eq_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<lt_eq_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<lt_eq_op, BaseT, T1>::type
-operator<=(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<lt_eq_op, BaseT, T1>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename T0, typename BaseT>
-inline typename impl::make_binary2<lt_eq_op, T0, BaseT>::type
-operator<=(T0 CREF _0, actor<BaseT> const& _1)
-{
- return impl::make_binary2<lt_eq_op, T0, BaseT>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename BaseT0, typename BaseT1>
-inline typename impl::make_binary3<lt_eq_op, BaseT0, BaseT1>::type
-operator<=(actor<BaseT0> const& _0, actor<BaseT1> const& _1)
-{
- return impl::make_binary3<lt_eq_op, BaseT0, BaseT1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// greater than lazy operator (infix >)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct gt_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<gt_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<gt_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<gt_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<gt_op, BaseT, T1>::type
-operator>(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<gt_op, BaseT, T1>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename T0, typename BaseT>
-inline typename impl::make_binary2<gt_op, T0, BaseT>::type
-operator>(T0 CREF _0, actor<BaseT> const& _1)
-{
- return impl::make_binary2<gt_op, T0, BaseT>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename BaseT0, typename BaseT1>
-inline typename impl::make_binary3<gt_op, BaseT0, BaseT1>::type
-operator>(actor<BaseT0> const& _0, actor<BaseT1> const& _1)
-{
- return impl::make_binary3<gt_op, BaseT0, BaseT1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// greater than equal lazy operator (infix >=)
-//
-///////////////////////////////////////////////////////////////////////////////
-struct gt_eq_op {
-
- template <typename T0, typename T1>
- struct result {
-
- typedef typename binary_operator<gt_eq_op, T0, T1>
- ::result_type type;
- };
-
- template <typename T0, typename T1>
- typename binary_operator<gt_eq_op, T0, T1>::result_type
- operator()(T0& _0, T1& _1) const
- { return binary_operator<gt_eq_op, T0, T1>::eval(_0, _1); }
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline typename impl::make_binary1<gt_eq_op, BaseT, T1>::type
-operator>=(actor<BaseT> const& _0, T1 CREF _1)
-{
- return impl::make_binary1<gt_eq_op, BaseT, T1>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename T0, typename BaseT>
-inline typename impl::make_binary2<gt_eq_op, T0, BaseT>::type
-operator>=(T0 CREF _0, actor<BaseT> const& _1)
-{
- return impl::make_binary2<gt_eq_op, T0, BaseT>::construct(_0, _1);
-}
-
-//////////////////////////////////
-template <typename BaseT0, typename BaseT1>
-inline typename impl::make_binary3<gt_eq_op, BaseT0, BaseT1>::type
-operator>=(actor<BaseT0> const& _0, actor<BaseT1> const& _1)
-{
- return impl::make_binary3<gt_eq_op, BaseT0, BaseT1>::construct(_0, _1);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// logical and lazy operator (infix &&)
-//
-// The logical_and_composite class and its corresponding generators are
-// provided to allow short-circuit evaluation of the operator's
-// operands.
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename A0, typename A1>
-struct logical_and_composite {
-
- typedef logical_and_composite<A0, A1> self_t;
-
- template <typename TupleT>
- struct result {
-
- typedef typename binary_operator<logical_and_op,
- typename actor_result<A0, TupleT>::plain_type,
- typename actor_result<A1, TupleT>::plain_type
- >::result_type type;
- };
-
- logical_and_composite(A0 const& _0, A1 const& _1)
- : a0(_0), a1(_1) {}
-
- template <typename TupleT>
- typename actor_result<self_t, TupleT>::type
- eval(TupleT const& args) const
- {
- return a0.eval(args) && a1.eval(args);
- }
-
- A0 a0; A1 a1; // actors
-};
-
-#if !(defined(__ICL) && __ICL <= 500)
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline actor<logical_and_composite
-<actor<BaseT>, typename as_actor<T1>::type> >
-operator&&(actor<BaseT> const& _0, T1 CREF _1)
-{
- return logical_and_composite
- <actor<BaseT>, typename as_actor<T1>::type>
- (_0, as_actor<T1>::convert(_1));
-}
-
-//////////////////////////////////
-template <typename T0, typename BaseT>
-inline actor<logical_and_composite
-<typename as_actor<T0>::type, actor<BaseT> > >
-operator&&(T0 CREF _0, actor<BaseT> const& _1)
-{
- return logical_and_composite
- <typename as_actor<T0>::type, actor<BaseT> >
- (as_actor<T0>::convert(_0), _1);
-}
-
-//////////////////////////////////
-template <typename BaseT0, typename BaseT1>
-inline actor<logical_and_composite
-<actor<BaseT0>, actor<BaseT1> > >
-operator&&(actor<BaseT0> const& _0, actor<BaseT1> const& _1)
-{
- return logical_and_composite
- <actor<BaseT0>, actor<BaseT1> >
- (_0, _1);
-}
-#else
-//////////////////////////////////
-template <typename T0, typename T1>
-inline actor<logical_and_composite
-<typename as_actor<T0>::type, typename as_actor<T1>::type> >
-operator&&(T0 CREF _0, T1 CREF _1)
-{
- return logical_and_composite
- <typename as_actor<T0>::type, typename as_actor<T1>::type>
- (as_actor<T0>::convert(_0), as_actor<T1>::convert(_1));
-}
-#endif // !(__ICL && __ICL <= 500)
-
-///////////////////////////////////////////////////////////////////////////////
-//
-// logical or lazy operator (infix ||)
-//
-// The logical_or_composite class and its corresponding generators are
-// provided to allow short-circuit evaluation of the operator's
-// operands.
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename A0, typename A1>
-struct logical_or_composite {
-
- typedef logical_or_composite<A0, A1> self_t;
-
- template <typename TupleT>
- struct result {
-
- typedef typename binary_operator<logical_or_op,
- typename actor_result<A0, TupleT>::plain_type,
- typename actor_result<A1, TupleT>::plain_type
- >::result_type type;
- };
-
- logical_or_composite(A0 const& _0, A1 const& _1)
- : a0(_0), a1(_1) {}
-
- template <typename TupleT>
- typename actor_result<self_t, TupleT>::type
- eval(TupleT const& args) const
- {
- return a0.eval(args) || a1.eval(args);
- }
-
- A0 a0; A1 a1; // actors
-};
-
-//////////////////////////////////
-template <typename BaseT, typename T1>
-inline actor<logical_or_composite
-<actor<BaseT>, typename as_actor<T1>::type> >
-operator||(actor<BaseT> const& _0, T1 CREF _1)
-{
- return logical_or_composite
- <actor<BaseT>, typename as_actor<T1>::type>
- (_0, as_actor<T1>::convert(_1));
-}
-
-//////////////////////////////////
-template <typename T0, typename BaseT>
-inline actor<logical_or_composite
-<typename as_actor<T0>::type, actor<BaseT> > >
-operator||(T0 CREF _0, actor<BaseT> const& _1)
-{
- return logical_or_composite
- <typename as_actor<T0>::type, actor<BaseT> >
- (as_actor<T0>::convert(_0), _1);
-}
-
-//////////////////////////////////
-template <typename BaseT0, typename BaseT1>
-inline actor<logical_or_composite
-<actor<BaseT0>, actor<BaseT1> > >
-operator||(actor<BaseT0> const& _0, actor<BaseT1> const& _1)
-{
- return logical_or_composite
- <actor<BaseT0>, actor<BaseT1> >
- (_0, _1);
-}
-
-} // namespace phoenix
-
-#undef CREF
-#endif
projects / ceph.git / blobdiff