Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages
lambda

xst_binary_adaptor.h

Go to the documentation of this file.
00001 
00002 // Common Text Transformation Library
00003 // Copyright (C) 1997-2006 by Igor Kholodov. 
00004 //
00005 // This library is free software; you can redistribute it and/or
00006 // modify it under the terms of the GNU Lesser General Public
00007 // License as published by the Free Software Foundation; either
00008 // version 2.1 of the License, or (at your option) any later version.
00009 //
00010 // This library is distributed in the hope that it will be useful,
00011 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00012 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00013 // Lesser General Public License for more details.
00014 //
00015 // You should have received a copy of the GNU Lesser General Public
00016 // License along with this library; if not, write to the
00017 // Free Software Foundation, Inc.,
00018 // 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
00019 //
00020 // mailto:cttl@users.sourceforge.net
00021 // http://sourceforge.net/projects/cttl/
00023 
00033 // xst_adaptor.h
00034 
00035 #ifndef _XST_BINARY_ADAPTOR_H_INCLUDED_
00036 #define _XST_BINARY_ADAPTOR_H_INCLUDED_
00037 
00038 namespace cttl_impl {
00039 
00040 // forward declare lambda primitive required by assignment operators
00041 template< typename LambdaT > struct xst_lambda_wrap;
00042 template< typename ExprT, typename PolicyAdaptorT > class xst_unary_adaptor;
00043 
00044 // forward declare lambda primitives required by abbreviated assignment operators
00045 template< typename ValueT > struct xst_scalar;
00046 template< typename ValueT > struct xst_stack;
00047 
00048 // forward declare all assignment policies
00049 template< int RhsCapacityT, int LhsCapacityT, int PrimitiveIdT > struct xst_assignment_policy;
00050 template< int RhsCapacityT, int LhsCapacityT, int PrimitiveIdT > struct xst_multiplication_assignment_policy;
00051 template< int RhsCapacityT, int LhsCapacityT, int PrimitiveIdT > struct xst_division_assignment_policy;
00052 template< int RhsCapacityT, int LhsCapacityT, int PrimitiveIdT > struct xst_modulus_assignment_policy;
00053 template< int RhsCapacityT, int LhsCapacityT, int PrimitiveIdT > struct xst_addition_assignment_policy;
00054 template< int RhsCapacityT, int LhsCapacityT, int PrimitiveIdT > struct xst_subtraction_assignment_policy;
00055 template< int RhsCapacityT, int LhsCapacityT, int PrimitiveIdT > struct xst_left_shift_assignment_policy;
00056 template< int RhsCapacityT, int LhsCapacityT, int PrimitiveIdT > struct xst_right_shift_assignment_policy;
00057 template< int RhsCapacityT, int LhsCapacityT, int PrimitiveIdT > struct xst_bitwise_and_assignment_policy;
00058 template< int RhsCapacityT, int LhsCapacityT, int PrimitiveIdT > struct xst_bitwise_ior_assignment_policy;
00059 template< int RhsCapacityT, int LhsCapacityT, int PrimitiveIdT > struct xst_bitwise_xor_assignment_policy;
00060 
00061 // B -> B<L,R,A>, where B := xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >
00062 
00079 template< typename LhsT, typename RhsT, typename PolicyAdaptorT >
00080 class xst_binary_adaptor : public xtl_op_base_binary< LhsT, RhsT > {
00081 
00082 public:
00083 
00084     enum {
00086         primitive_id_ = primitive_id_binary_adaptor,
00087 
00089         operator_id_ = PolicyAdaptorT::operator_id_,
00090 
00092         capacity_ = 1
00093     };
00094 
00095 
00097     typedef typename xst_binary_operator_traits<
00098         typename RhsT::value_T,
00099         typename LhsT::value_T,
00100         operator_id_
00101     >::value_type value_T;
00102 
00104     typedef value_T value_type;
00105 
00107     typedef typename LhsT::dereferenced_value_T dereferenced_value_T;
00108 
00110     xst_binary_adaptor( LhsT const& lhs_, RhsT const& rhs_ )
00111     : xtl_op_base_binary< LhsT, RhsT >( lhs_, rhs_ )
00112     {
00113     }
00114 
00116     xst_binary_adaptor( xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT > const& other_ )
00117     : xtl_op_base_binary< LhsT, RhsT >( other_.m_expr_lhs, other_.m_expr_rhs )
00118     {
00119     }
00120 
00122     void evaluate()
00123     {
00124         CTTL_TRACE_DEPOSIT_JUSTIFY();
00125         CTTL_TRACE_DEPOSIT_DELAYED_CHAR( '\n' );
00126         PolicyAdaptorT::top( this->m_expr_lhs, this->m_expr_rhs );
00127     }
00128 
00148     template< typename UniverseT >
00149     size_t match( UniverseT& edge_ )
00150     {
00151         CTTL_TRACE_LEVEL_MATCH( 'b' );
00152         CTTL_TRACE_DEPOSIT_JUSTIFY();
00153         CTTL_TRACE_DEPOSIT_DELAYED_CHAR( '\n' );
00154         return PolicyAdaptorT::match( this->m_expr_lhs, this->m_expr_rhs, edge_ );
00155     }
00156         
00158     value_T top() const
00159     {
00160         return PolicyAdaptorT::top( this->m_expr_lhs, this->m_expr_rhs );
00161     }
00162 
00164     template< typename SubscriptLambdaT >
00165     value_T top( SubscriptLambdaT ) const
00166     {
00167         return top();
00168     }
00169 
00171     template< typename SubscriptLambdaT >
00172     value_T& top( SubscriptLambdaT )
00173     {
00174         prefix_side_effects();
00175         value_T& tmp_value_ref = lvalue_ref();
00176         postfix_side_effects();
00177         return tmp_value_ref;
00178     }
00179 
00181     value_T& lvalue_ref()
00182     {
00183         return PolicyAdaptorT::lvalue_ref( this->m_expr_lhs, this->m_expr_rhs );
00184     }
00185 
00187     void prefix_side_effects()
00188     {
00189         PolicyAdaptorT::prefix_side_effects( this->m_expr_lhs, this->m_expr_rhs );
00190     }
00191 
00193     void postfix_side_effects()
00194     {
00195         PolicyAdaptorT::postfix_side_effects( this->m_expr_lhs );
00196     }
00197 
00199 // Overloaded operators
00201 
00202 // Do not modify section of code between begin_generated_code
00203 // and end_generated_code comments. This section of code is
00204 // maintained by gumus scripts.
00205 
00206 //begin_generated_code
00207 // generated by gmu/lambda/gmu_common.h:704
00208 // on Thu Nov 02 13:01:33 2006.
00209 // generated by gmu/lambda/gmu_common.h:187
00211 // Assignment = operators begin
00213 
00215 // Assignment = abbreviations
00217 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:8
00232     template< typename RhsValueT >
00233     xst_binary_adaptor<
00234         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00235         xst_lambda_wrap< xst_scalar< RhsValueT > >,
00236         xst_assignment_policy<
00237             1, // xst_scalar capacity
00238             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00239             primitive_id_unary_adaptor
00240         >
00241     >
00242     operator= ( RhsValueT const& value_ )
00243     {
00244         typedef xst_binary_adaptor<
00245             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00246             xst_lambda_wrap< xst_scalar< RhsValueT > >,
00247             xst_assignment_policy<
00248                 1, // xst_scalar capacity
00249                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00250                 primitive_id_unary_adaptor
00251             >
00252         > xst_adaptor_T;
00253 
00254         return xst_adaptor_T(
00255             *this,
00256             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
00257             );
00258     }
00259 
00260 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:51
00275     template< typename RhsValueT >
00276     xst_binary_adaptor<
00277         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00278         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
00279         xst_assignment_policy<
00280             1, // xst_scalar capacity
00281             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00282             primitive_id_unary_adaptor
00283         >
00284     >
00285     operator= ( RhsValueT* pvalue_ )
00286     {
00287         typedef xst_binary_adaptor<
00288             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00289             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
00290             xst_assignment_policy<
00291                 1, // xst_scalar capacity
00292                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00293                 primitive_id_unary_adaptor
00294             >
00295         > xst_adaptor_T;
00296 
00297         return xst_adaptor_T(
00298             *this,
00299             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
00300             );
00301     }
00302 
00303 
00305 // Assignment = specializations
00307 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:98
00322     template< typename LambdaT >
00323     xst_binary_adaptor<
00324         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00325         xst_lambda_wrap< typename LambdaT::reference_T >,
00326         xst_assignment_policy<
00327             LambdaT::capacity_,
00328             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00329             primitive_id_unary_adaptor
00330         >
00331     >
00332     operator= ( xst_lambda_wrap< LambdaT > const& lambda_ )
00333     {
00334         typedef xst_binary_adaptor<
00335             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00336             xst_lambda_wrap< typename LambdaT::reference_T >,
00337             xst_assignment_policy<
00338                 LambdaT::capacity_,
00339                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00340                 primitive_id_unary_adaptor
00341             >
00342         > xst_adaptor_T;
00343 
00344         return xst_adaptor_T( *this, lambda_.make_reference() );
00345     }
00346 
00347 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:138
00367     template< typename LambdaT, typename UnaryPolicyAdaptorT >
00368     xst_binary_adaptor<
00369         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00370         xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
00371         xst_assignment_policy<
00372             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
00373             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00374             primitive_id_unary_adaptor
00375         >
00376     >
00377     operator= ( xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const& lambda_ )
00378     {
00379         typedef xst_binary_adaptor<
00380             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00381             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
00382             xst_assignment_policy<
00383                 xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
00384                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00385                 primitive_id_unary_adaptor
00386             >
00387         > xst_adaptor_T;
00388 
00389         return xst_adaptor_T( *this, lambda_ );
00390     }
00391 
00392 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:183
00416     template< typename LambdaLhsT, typename LambdaRhsT, typename BinaryPolicyAdaptorT >
00417     xst_binary_adaptor<
00418         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00419         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
00420         xst_assignment_policy<
00421             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
00422             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00423             primitive_id_unary_adaptor
00424         >
00425     >
00426     operator= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const& lambda_ )
00427     {
00428         typedef xst_binary_adaptor<
00429             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00430             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
00431             xst_assignment_policy<
00432                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
00433                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00434                 primitive_id_unary_adaptor
00435             >
00436         > xst_adaptor_T;
00437 
00438         return xst_adaptor_T( *this, lambda_ );
00439     }
00440 
00442 // More = assignment abbreviations
00444 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:235
00460     template< typename StackValueT >
00461     xst_binary_adaptor<
00462         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00463         xst_lambda_wrap< xst_scalar< StackValueT > >,
00464         xst_assignment_policy<
00465             1, // xst_scalar capacity
00466             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00467             primitive_id_unary_adaptor
00468         >
00469     >
00470     operator= ( std::stack< StackValueT > const& stack_ )
00471     {
00472         typedef xst_binary_adaptor<
00473             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00474             xst_lambda_wrap< xst_scalar< StackValueT > >,
00475             xst_assignment_policy<
00476                 1, // xst_scalar capacity
00477                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00478                 primitive_id_unary_adaptor
00479             >
00480         > xst_adaptor_T;
00481 
00482         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
00483         return xst_adaptor_T(
00484             *this,
00485             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
00486             );
00487     }
00488 
00489 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:280
00505     template< typename StackValueT >
00506     xst_binary_adaptor<
00507         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00508         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
00509         xst_assignment_policy<
00510             1, // xst_stack capacity
00511             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00512             primitive_id_unary_adaptor
00513         >
00514     >
00515     operator= ( std::stack< StackValueT >* pstack_ )
00516     {
00517         typedef xst_binary_adaptor<
00518             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00519             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
00520             xst_assignment_policy<
00521                 1, // xst_stack capacity
00522                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00523                 primitive_id_unary_adaptor
00524             >
00525         > xst_adaptor_T;
00526 
00527         return xst_adaptor_T(
00528             *this,
00529             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
00530             );
00531     }
00532 
00534 // Assignment = operators end
00536 
00537 // generated by gmu/lambda/gmu_common.h:187
00539 // Assignment *= operators begin
00541 
00543 // Assignment *= abbreviations
00545 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:8
00560     template< typename RhsValueT >
00561     xst_binary_adaptor<
00562         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00563         xst_lambda_wrap< xst_scalar< RhsValueT > >,
00564         xst_multiplication_assignment_policy<
00565             1, // xst_scalar capacity
00566             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00567             primitive_id_unary_adaptor
00568         >
00569     >
00570     operator*= ( RhsValueT const& value_ )
00571     {
00572         typedef xst_binary_adaptor<
00573             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00574             xst_lambda_wrap< xst_scalar< RhsValueT > >,
00575             xst_multiplication_assignment_policy<
00576                 1, // xst_scalar capacity
00577                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00578                 primitive_id_unary_adaptor
00579             >
00580         > xst_adaptor_T;
00581 
00582         return xst_adaptor_T(
00583             *this,
00584             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
00585             );
00586     }
00587 
00588 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:51
00603     template< typename RhsValueT >
00604     xst_binary_adaptor<
00605         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00606         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
00607         xst_multiplication_assignment_policy<
00608             1, // xst_scalar capacity
00609             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00610             primitive_id_unary_adaptor
00611         >
00612     >
00613     operator*= ( RhsValueT* pvalue_ )
00614     {
00615         typedef xst_binary_adaptor<
00616             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00617             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
00618             xst_multiplication_assignment_policy<
00619                 1, // xst_scalar capacity
00620                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00621                 primitive_id_unary_adaptor
00622             >
00623         > xst_adaptor_T;
00624 
00625         return xst_adaptor_T(
00626             *this,
00627             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
00628             );
00629     }
00630 
00631 
00633 // Assignment *= specializations
00635 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:98
00650     template< typename LambdaT >
00651     xst_binary_adaptor<
00652         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00653         xst_lambda_wrap< typename LambdaT::reference_T >,
00654         xst_multiplication_assignment_policy<
00655             LambdaT::capacity_,
00656             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00657             primitive_id_unary_adaptor
00658         >
00659     >
00660     operator*= ( xst_lambda_wrap< LambdaT > const& lambda_ )
00661     {
00662         typedef xst_binary_adaptor<
00663             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00664             xst_lambda_wrap< typename LambdaT::reference_T >,
00665             xst_multiplication_assignment_policy<
00666                 LambdaT::capacity_,
00667                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00668                 primitive_id_unary_adaptor
00669             >
00670         > xst_adaptor_T;
00671 
00672         return xst_adaptor_T( *this, lambda_.make_reference() );
00673     }
00674 
00675 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:138
00695     template< typename LambdaT, typename UnaryPolicyAdaptorT >
00696     xst_binary_adaptor<
00697         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00698         xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
00699         xst_multiplication_assignment_policy<
00700             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
00701             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00702             primitive_id_unary_adaptor
00703         >
00704     >
00705     operator*= ( xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const& lambda_ )
00706     {
00707         typedef xst_binary_adaptor<
00708             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00709             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
00710             xst_multiplication_assignment_policy<
00711                 xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
00712                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00713                 primitive_id_unary_adaptor
00714             >
00715         > xst_adaptor_T;
00716 
00717         return xst_adaptor_T( *this, lambda_ );
00718     }
00719 
00720 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:183
00744     template< typename LambdaLhsT, typename LambdaRhsT, typename BinaryPolicyAdaptorT >
00745     xst_binary_adaptor<
00746         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00747         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
00748         xst_multiplication_assignment_policy<
00749             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
00750             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00751             primitive_id_unary_adaptor
00752         >
00753     >
00754     operator*= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const& lambda_ )
00755     {
00756         typedef xst_binary_adaptor<
00757             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00758             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
00759             xst_multiplication_assignment_policy<
00760                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
00761                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00762                 primitive_id_unary_adaptor
00763             >
00764         > xst_adaptor_T;
00765 
00766         return xst_adaptor_T( *this, lambda_ );
00767     }
00768 
00770 // More *= assignment abbreviations
00772 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:235
00788     template< typename StackValueT >
00789     xst_binary_adaptor<
00790         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00791         xst_lambda_wrap< xst_scalar< StackValueT > >,
00792         xst_multiplication_assignment_policy<
00793             1, // xst_scalar capacity
00794             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00795             primitive_id_unary_adaptor
00796         >
00797     >
00798     operator*= ( std::stack< StackValueT > const& stack_ )
00799     {
00800         typedef xst_binary_adaptor<
00801             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00802             xst_lambda_wrap< xst_scalar< StackValueT > >,
00803             xst_multiplication_assignment_policy<
00804                 1, // xst_scalar capacity
00805                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00806                 primitive_id_unary_adaptor
00807             >
00808         > xst_adaptor_T;
00809 
00810         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
00811         return xst_adaptor_T(
00812             *this,
00813             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
00814             );
00815     }
00816 
00817 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:280
00833     template< typename StackValueT >
00834     xst_binary_adaptor<
00835         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00836         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
00837         xst_multiplication_assignment_policy<
00838             1, // xst_stack capacity
00839             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00840             primitive_id_unary_adaptor
00841         >
00842     >
00843     operator*= ( std::stack< StackValueT >* pstack_ )
00844     {
00845         typedef xst_binary_adaptor<
00846             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00847             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
00848             xst_multiplication_assignment_policy<
00849                 1, // xst_stack capacity
00850                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00851                 primitive_id_unary_adaptor
00852             >
00853         > xst_adaptor_T;
00854 
00855         return xst_adaptor_T(
00856             *this,
00857             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
00858             );
00859     }
00860 
00862 // Assignment *= operators end
00864 
00865 // generated by gmu/lambda/gmu_common.h:187
00867 // Assignment /= operators begin
00869 
00871 // Assignment /= abbreviations
00873 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:8
00888     template< typename RhsValueT >
00889     xst_binary_adaptor<
00890         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00891         xst_lambda_wrap< xst_scalar< RhsValueT > >,
00892         xst_division_assignment_policy<
00893             1, // xst_scalar capacity
00894             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00895             primitive_id_unary_adaptor
00896         >
00897     >
00898     operator/= ( RhsValueT const& value_ )
00899     {
00900         typedef xst_binary_adaptor<
00901             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00902             xst_lambda_wrap< xst_scalar< RhsValueT > >,
00903             xst_division_assignment_policy<
00904                 1, // xst_scalar capacity
00905                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00906                 primitive_id_unary_adaptor
00907             >
00908         > xst_adaptor_T;
00909 
00910         return xst_adaptor_T(
00911             *this,
00912             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
00913             );
00914     }
00915 
00916 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:51
00931     template< typename RhsValueT >
00932     xst_binary_adaptor<
00933         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00934         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
00935         xst_division_assignment_policy<
00936             1, // xst_scalar capacity
00937             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00938             primitive_id_unary_adaptor
00939         >
00940     >
00941     operator/= ( RhsValueT* pvalue_ )
00942     {
00943         typedef xst_binary_adaptor<
00944             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00945             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
00946             xst_division_assignment_policy<
00947                 1, // xst_scalar capacity
00948                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00949                 primitive_id_unary_adaptor
00950             >
00951         > xst_adaptor_T;
00952 
00953         return xst_adaptor_T(
00954             *this,
00955             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
00956             );
00957     }
00958 
00959 
00961 // Assignment /= specializations
00963 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:98
00978     template< typename LambdaT >
00979     xst_binary_adaptor<
00980         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00981         xst_lambda_wrap< typename LambdaT::reference_T >,
00982         xst_division_assignment_policy<
00983             LambdaT::capacity_,
00984             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00985             primitive_id_unary_adaptor
00986         >
00987     >
00988     operator/= ( xst_lambda_wrap< LambdaT > const& lambda_ )
00989     {
00990         typedef xst_binary_adaptor<
00991             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
00992             xst_lambda_wrap< typename LambdaT::reference_T >,
00993             xst_division_assignment_policy<
00994                 LambdaT::capacity_,
00995                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
00996                 primitive_id_unary_adaptor
00997             >
00998         > xst_adaptor_T;
00999 
01000         return xst_adaptor_T( *this, lambda_.make_reference() );
01001     }
01002 
01003 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:138
01023     template< typename LambdaT, typename UnaryPolicyAdaptorT >
01024     xst_binary_adaptor<
01025         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01026         xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
01027         xst_division_assignment_policy<
01028             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
01029             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01030             primitive_id_unary_adaptor
01031         >
01032     >
01033     operator/= ( xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const& lambda_ )
01034     {
01035         typedef xst_binary_adaptor<
01036             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01037             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
01038             xst_division_assignment_policy<
01039                 xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
01040                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01041                 primitive_id_unary_adaptor
01042             >
01043         > xst_adaptor_T;
01044 
01045         return xst_adaptor_T( *this, lambda_ );
01046     }
01047 
01048 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:183
01072     template< typename LambdaLhsT, typename LambdaRhsT, typename BinaryPolicyAdaptorT >
01073     xst_binary_adaptor<
01074         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01075         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
01076         xst_division_assignment_policy<
01077             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
01078             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01079             primitive_id_unary_adaptor
01080         >
01081     >
01082     operator/= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const& lambda_ )
01083     {
01084         typedef xst_binary_adaptor<
01085             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01086             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
01087             xst_division_assignment_policy<
01088                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
01089                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01090                 primitive_id_unary_adaptor
01091             >
01092         > xst_adaptor_T;
01093 
01094         return xst_adaptor_T( *this, lambda_ );
01095     }
01096 
01098 // More /= assignment abbreviations
01100 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:235
01116     template< typename StackValueT >
01117     xst_binary_adaptor<
01118         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01119         xst_lambda_wrap< xst_scalar< StackValueT > >,
01120         xst_division_assignment_policy<
01121             1, // xst_scalar capacity
01122             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01123             primitive_id_unary_adaptor
01124         >
01125     >
01126     operator/= ( std::stack< StackValueT > const& stack_ )
01127     {
01128         typedef xst_binary_adaptor<
01129             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01130             xst_lambda_wrap< xst_scalar< StackValueT > >,
01131             xst_division_assignment_policy<
01132                 1, // xst_scalar capacity
01133                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01134                 primitive_id_unary_adaptor
01135             >
01136         > xst_adaptor_T;
01137 
01138         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
01139         return xst_adaptor_T(
01140             *this,
01141             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
01142             );
01143     }
01144 
01145 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:280
01161     template< typename StackValueT >
01162     xst_binary_adaptor<
01163         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01164         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
01165         xst_division_assignment_policy<
01166             1, // xst_stack capacity
01167             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01168             primitive_id_unary_adaptor
01169         >
01170     >
01171     operator/= ( std::stack< StackValueT >* pstack_ )
01172     {
01173         typedef xst_binary_adaptor<
01174             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01175             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
01176             xst_division_assignment_policy<
01177                 1, // xst_stack capacity
01178                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01179                 primitive_id_unary_adaptor
01180             >
01181         > xst_adaptor_T;
01182 
01183         return xst_adaptor_T(
01184             *this,
01185             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
01186             );
01187     }
01188 
01190 // Assignment /= operators end
01192 
01193 // generated by gmu/lambda/gmu_common.h:187
01195 // Assignment %= operators begin
01197 
01199 // Assignment %= abbreviations
01201 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:8
01216     template< typename RhsValueT >
01217     xst_binary_adaptor<
01218         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01219         xst_lambda_wrap< xst_scalar< RhsValueT > >,
01220         xst_modulus_assignment_policy<
01221             1, // xst_scalar capacity
01222             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01223             primitive_id_unary_adaptor
01224         >
01225     >
01226     operator%= ( RhsValueT const& value_ )
01227     {
01228         typedef xst_binary_adaptor<
01229             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01230             xst_lambda_wrap< xst_scalar< RhsValueT > >,
01231             xst_modulus_assignment_policy<
01232                 1, // xst_scalar capacity
01233                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01234                 primitive_id_unary_adaptor
01235             >
01236         > xst_adaptor_T;
01237 
01238         return xst_adaptor_T(
01239             *this,
01240             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
01241             );
01242     }
01243 
01244 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:51
01259     template< typename RhsValueT >
01260     xst_binary_adaptor<
01261         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01262         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
01263         xst_modulus_assignment_policy<
01264             1, // xst_scalar capacity
01265             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01266             primitive_id_unary_adaptor
01267         >
01268     >
01269     operator%= ( RhsValueT* pvalue_ )
01270     {
01271         typedef xst_binary_adaptor<
01272             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01273             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
01274             xst_modulus_assignment_policy<
01275                 1, // xst_scalar capacity
01276                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01277                 primitive_id_unary_adaptor
01278             >
01279         > xst_adaptor_T;
01280 
01281         return xst_adaptor_T(
01282             *this,
01283             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
01284             );
01285     }
01286 
01287 
01289 // Assignment %= specializations
01291 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:98
01306     template< typename LambdaT >
01307     xst_binary_adaptor<
01308         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01309         xst_lambda_wrap< typename LambdaT::reference_T >,
01310         xst_modulus_assignment_policy<
01311             LambdaT::capacity_,
01312             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01313             primitive_id_unary_adaptor
01314         >
01315     >
01316     operator%= ( xst_lambda_wrap< LambdaT > const& lambda_ )
01317     {
01318         typedef xst_binary_adaptor<
01319             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01320             xst_lambda_wrap< typename LambdaT::reference_T >,
01321             xst_modulus_assignment_policy<
01322                 LambdaT::capacity_,
01323                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01324                 primitive_id_unary_adaptor
01325             >
01326         > xst_adaptor_T;
01327 
01328         return xst_adaptor_T( *this, lambda_.make_reference() );
01329     }
01330 
01331 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:138
01351     template< typename LambdaT, typename UnaryPolicyAdaptorT >
01352     xst_binary_adaptor<
01353         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01354         xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
01355         xst_modulus_assignment_policy<
01356             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
01357             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01358             primitive_id_unary_adaptor
01359         >
01360     >
01361     operator%= ( xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const& lambda_ )
01362     {
01363         typedef xst_binary_adaptor<
01364             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01365             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
01366             xst_modulus_assignment_policy<
01367                 xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
01368                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01369                 primitive_id_unary_adaptor
01370             >
01371         > xst_adaptor_T;
01372 
01373         return xst_adaptor_T( *this, lambda_ );
01374     }
01375 
01376 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:183
01400     template< typename LambdaLhsT, typename LambdaRhsT, typename BinaryPolicyAdaptorT >
01401     xst_binary_adaptor<
01402         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01403         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
01404         xst_modulus_assignment_policy<
01405             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
01406             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01407             primitive_id_unary_adaptor
01408         >
01409     >
01410     operator%= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const& lambda_ )
01411     {
01412         typedef xst_binary_adaptor<
01413             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01414             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
01415             xst_modulus_assignment_policy<
01416                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
01417                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01418                 primitive_id_unary_adaptor
01419             >
01420         > xst_adaptor_T;
01421 
01422         return xst_adaptor_T( *this, lambda_ );
01423     }
01424 
01426 // More %= assignment abbreviations
01428 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:235
01444     template< typename StackValueT >
01445     xst_binary_adaptor<
01446         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01447         xst_lambda_wrap< xst_scalar< StackValueT > >,
01448         xst_modulus_assignment_policy<
01449             1, // xst_scalar capacity
01450             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01451             primitive_id_unary_adaptor
01452         >
01453     >
01454     operator%= ( std::stack< StackValueT > const& stack_ )
01455     {
01456         typedef xst_binary_adaptor<
01457             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01458             xst_lambda_wrap< xst_scalar< StackValueT > >,
01459             xst_modulus_assignment_policy<
01460                 1, // xst_scalar capacity
01461                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01462                 primitive_id_unary_adaptor
01463             >
01464         > xst_adaptor_T;
01465 
01466         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
01467         return xst_adaptor_T(
01468             *this,
01469             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
01470             );
01471     }
01472 
01473 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:280
01489     template< typename StackValueT >
01490     xst_binary_adaptor<
01491         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01492         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
01493         xst_modulus_assignment_policy<
01494             1, // xst_stack capacity
01495             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01496             primitive_id_unary_adaptor
01497         >
01498     >
01499     operator%= ( std::stack< StackValueT >* pstack_ )
01500     {
01501         typedef xst_binary_adaptor<
01502             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01503             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
01504             xst_modulus_assignment_policy<
01505                 1, // xst_stack capacity
01506                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01507                 primitive_id_unary_adaptor
01508             >
01509         > xst_adaptor_T;
01510 
01511         return xst_adaptor_T(
01512             *this,
01513             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
01514             );
01515     }
01516 
01518 // Assignment %= operators end
01520 
01521 // generated by gmu/lambda/gmu_common.h:187
01523 // Assignment += operators begin
01525 
01527 // Assignment += abbreviations
01529 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:8
01544     template< typename RhsValueT >
01545     xst_binary_adaptor<
01546         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01547         xst_lambda_wrap< xst_scalar< RhsValueT > >,
01548         xst_addition_assignment_policy<
01549             1, // xst_scalar capacity
01550             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01551             primitive_id_unary_adaptor
01552         >
01553     >
01554     operator+= ( RhsValueT const& value_ )
01555     {
01556         typedef xst_binary_adaptor<
01557             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01558             xst_lambda_wrap< xst_scalar< RhsValueT > >,
01559             xst_addition_assignment_policy<
01560                 1, // xst_scalar capacity
01561                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01562                 primitive_id_unary_adaptor
01563             >
01564         > xst_adaptor_T;
01565 
01566         return xst_adaptor_T(
01567             *this,
01568             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
01569             );
01570     }
01571 
01572 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:51
01587     template< typename RhsValueT >
01588     xst_binary_adaptor<
01589         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01590         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
01591         xst_addition_assignment_policy<
01592             1, // xst_scalar capacity
01593             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01594             primitive_id_unary_adaptor
01595         >
01596     >
01597     operator+= ( RhsValueT* pvalue_ )
01598     {
01599         typedef xst_binary_adaptor<
01600             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01601             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
01602             xst_addition_assignment_policy<
01603                 1, // xst_scalar capacity
01604                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01605                 primitive_id_unary_adaptor
01606             >
01607         > xst_adaptor_T;
01608 
01609         return xst_adaptor_T(
01610             *this,
01611             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
01612             );
01613     }
01614 
01615 
01617 // Assignment += specializations
01619 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:98
01634     template< typename LambdaT >
01635     xst_binary_adaptor<
01636         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01637         xst_lambda_wrap< typename LambdaT::reference_T >,
01638         xst_addition_assignment_policy<
01639             LambdaT::capacity_,
01640             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01641             primitive_id_unary_adaptor
01642         >
01643     >
01644     operator+= ( xst_lambda_wrap< LambdaT > const& lambda_ )
01645     {
01646         typedef xst_binary_adaptor<
01647             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01648             xst_lambda_wrap< typename LambdaT::reference_T >,
01649             xst_addition_assignment_policy<
01650                 LambdaT::capacity_,
01651                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01652                 primitive_id_unary_adaptor
01653             >
01654         > xst_adaptor_T;
01655 
01656         return xst_adaptor_T( *this, lambda_.make_reference() );
01657     }
01658 
01659 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:138
01679     template< typename LambdaT, typename UnaryPolicyAdaptorT >
01680     xst_binary_adaptor<
01681         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01682         xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
01683         xst_addition_assignment_policy<
01684             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
01685             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01686             primitive_id_unary_adaptor
01687         >
01688     >
01689     operator+= ( xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const& lambda_ )
01690     {
01691         typedef xst_binary_adaptor<
01692             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01693             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
01694             xst_addition_assignment_policy<
01695                 xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
01696                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01697                 primitive_id_unary_adaptor
01698             >
01699         > xst_adaptor_T;
01700 
01701         return xst_adaptor_T( *this, lambda_ );
01702     }
01703 
01704 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:183
01728     template< typename LambdaLhsT, typename LambdaRhsT, typename BinaryPolicyAdaptorT >
01729     xst_binary_adaptor<
01730         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01731         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
01732         xst_addition_assignment_policy<
01733             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
01734             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01735             primitive_id_unary_adaptor
01736         >
01737     >
01738     operator+= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const& lambda_ )
01739     {
01740         typedef xst_binary_adaptor<
01741             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01742             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
01743             xst_addition_assignment_policy<
01744                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
01745                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01746                 primitive_id_unary_adaptor
01747             >
01748         > xst_adaptor_T;
01749 
01750         return xst_adaptor_T( *this, lambda_ );
01751     }
01752 
01754 // More += assignment abbreviations
01756 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:235
01772     template< typename StackValueT >
01773     xst_binary_adaptor<
01774         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01775         xst_lambda_wrap< xst_scalar< StackValueT > >,
01776         xst_addition_assignment_policy<
01777             1, // xst_scalar capacity
01778             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01779             primitive_id_unary_adaptor
01780         >
01781     >
01782     operator+= ( std::stack< StackValueT > const& stack_ )
01783     {
01784         typedef xst_binary_adaptor<
01785             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01786             xst_lambda_wrap< xst_scalar< StackValueT > >,
01787             xst_addition_assignment_policy<
01788                 1, // xst_scalar capacity
01789                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01790                 primitive_id_unary_adaptor
01791             >
01792         > xst_adaptor_T;
01793 
01794         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
01795         return xst_adaptor_T(
01796             *this,
01797             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
01798             );
01799     }
01800 
01801 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:280
01817     template< typename StackValueT >
01818     xst_binary_adaptor<
01819         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01820         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
01821         xst_addition_assignment_policy<
01822             1, // xst_stack capacity
01823             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01824             primitive_id_unary_adaptor
01825         >
01826     >
01827     operator+= ( std::stack< StackValueT >* pstack_ )
01828     {
01829         typedef xst_binary_adaptor<
01830             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01831             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
01832             xst_addition_assignment_policy<
01833                 1, // xst_stack capacity
01834                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01835                 primitive_id_unary_adaptor
01836             >
01837         > xst_adaptor_T;
01838 
01839         return xst_adaptor_T(
01840             *this,
01841             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
01842             );
01843     }
01844 
01846 // Assignment += operators end
01848 
01849 // generated by gmu/lambda/gmu_common.h:187
01851 // Assignment -= operators begin
01853 
01855 // Assignment -= abbreviations
01857 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:8
01872     template< typename RhsValueT >
01873     xst_binary_adaptor<
01874         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01875         xst_lambda_wrap< xst_scalar< RhsValueT > >,
01876         xst_subtraction_assignment_policy<
01877             1, // xst_scalar capacity
01878             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01879             primitive_id_unary_adaptor
01880         >
01881     >
01882     operator-= ( RhsValueT const& value_ )
01883     {
01884         typedef xst_binary_adaptor<
01885             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01886             xst_lambda_wrap< xst_scalar< RhsValueT > >,
01887             xst_subtraction_assignment_policy<
01888                 1, // xst_scalar capacity
01889                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01890                 primitive_id_unary_adaptor
01891             >
01892         > xst_adaptor_T;
01893 
01894         return xst_adaptor_T(
01895             *this,
01896             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
01897             );
01898     }
01899 
01900 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:51
01915     template< typename RhsValueT >
01916     xst_binary_adaptor<
01917         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01918         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
01919         xst_subtraction_assignment_policy<
01920             1, // xst_scalar capacity
01921             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01922             primitive_id_unary_adaptor
01923         >
01924     >
01925     operator-= ( RhsValueT* pvalue_ )
01926     {
01927         typedef xst_binary_adaptor<
01928             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01929             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
01930             xst_subtraction_assignment_policy<
01931                 1, // xst_scalar capacity
01932                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01933                 primitive_id_unary_adaptor
01934             >
01935         > xst_adaptor_T;
01936 
01937         return xst_adaptor_T(
01938             *this,
01939             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
01940             );
01941     }
01942 
01943 
01945 // Assignment -= specializations
01947 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:98
01962     template< typename LambdaT >
01963     xst_binary_adaptor<
01964         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01965         xst_lambda_wrap< typename LambdaT::reference_T >,
01966         xst_subtraction_assignment_policy<
01967             LambdaT::capacity_,
01968             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01969             primitive_id_unary_adaptor
01970         >
01971     >
01972     operator-= ( xst_lambda_wrap< LambdaT > const& lambda_ )
01973     {
01974         typedef xst_binary_adaptor<
01975             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
01976             xst_lambda_wrap< typename LambdaT::reference_T >,
01977             xst_subtraction_assignment_policy<
01978                 LambdaT::capacity_,
01979                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
01980                 primitive_id_unary_adaptor
01981             >
01982         > xst_adaptor_T;
01983 
01984         return xst_adaptor_T( *this, lambda_.make_reference() );
01985     }
01986 
01987 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:138
02007     template< typename LambdaT, typename UnaryPolicyAdaptorT >
02008     xst_binary_adaptor<
02009         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02010         xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
02011         xst_subtraction_assignment_policy<
02012             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
02013             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02014             primitive_id_unary_adaptor
02015         >
02016     >
02017     operator-= ( xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const& lambda_ )
02018     {
02019         typedef xst_binary_adaptor<
02020             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02021             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
02022             xst_subtraction_assignment_policy<
02023                 xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
02024                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02025                 primitive_id_unary_adaptor
02026             >
02027         > xst_adaptor_T;
02028 
02029         return xst_adaptor_T( *this, lambda_ );
02030     }
02031 
02032 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:183
02056     template< typename LambdaLhsT, typename LambdaRhsT, typename BinaryPolicyAdaptorT >
02057     xst_binary_adaptor<
02058         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02059         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
02060         xst_subtraction_assignment_policy<
02061             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
02062             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02063             primitive_id_unary_adaptor
02064         >
02065     >
02066     operator-= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const& lambda_ )
02067     {
02068         typedef xst_binary_adaptor<
02069             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02070             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
02071             xst_subtraction_assignment_policy<
02072                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
02073                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02074                 primitive_id_unary_adaptor
02075             >
02076         > xst_adaptor_T;
02077 
02078         return xst_adaptor_T( *this, lambda_ );
02079     }
02080 
02082 // More -= assignment abbreviations
02084 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:235
02100     template< typename StackValueT >
02101     xst_binary_adaptor<
02102         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02103         xst_lambda_wrap< xst_scalar< StackValueT > >,
02104         xst_subtraction_assignment_policy<
02105             1, // xst_scalar capacity
02106             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02107             primitive_id_unary_adaptor
02108         >
02109     >
02110     operator-= ( std::stack< StackValueT > const& stack_ )
02111     {
02112         typedef xst_binary_adaptor<
02113             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02114             xst_lambda_wrap< xst_scalar< StackValueT > >,
02115             xst_subtraction_assignment_policy<
02116                 1, // xst_scalar capacity
02117                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02118                 primitive_id_unary_adaptor
02119             >
02120         > xst_adaptor_T;
02121 
02122         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
02123         return xst_adaptor_T(
02124             *this,
02125             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
02126             );
02127     }
02128 
02129 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:280
02145     template< typename StackValueT >
02146     xst_binary_adaptor<
02147         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02148         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
02149         xst_subtraction_assignment_policy<
02150             1, // xst_stack capacity
02151             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02152             primitive_id_unary_adaptor
02153         >
02154     >
02155     operator-= ( std::stack< StackValueT >* pstack_ )
02156     {
02157         typedef xst_binary_adaptor<
02158             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02159             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
02160             xst_subtraction_assignment_policy<
02161                 1, // xst_stack capacity
02162                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02163                 primitive_id_unary_adaptor
02164             >
02165         > xst_adaptor_T;
02166 
02167         return xst_adaptor_T(
02168             *this,
02169             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
02170             );
02171     }
02172 
02174 // Assignment -= operators end
02176 
02177 // generated by gmu/lambda/gmu_common.h:187
02179 // Assignment <<= operators begin
02181 
02183 // Assignment <<= abbreviations
02185 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:8
02200     template< typename RhsValueT >
02201     xst_binary_adaptor<
02202         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02203         xst_lambda_wrap< xst_scalar< RhsValueT > >,
02204         xst_left_shift_assignment_policy<
02205             1, // xst_scalar capacity
02206             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02207             primitive_id_unary_adaptor
02208         >
02209     >
02210     operator<<= ( RhsValueT const& value_ )
02211     {
02212         typedef xst_binary_adaptor<
02213             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02214             xst_lambda_wrap< xst_scalar< RhsValueT > >,
02215             xst_left_shift_assignment_policy<
02216                 1, // xst_scalar capacity
02217                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02218                 primitive_id_unary_adaptor
02219             >
02220         > xst_adaptor_T;
02221 
02222         return xst_adaptor_T(
02223             *this,
02224             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
02225             );
02226     }
02227 
02228 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:51
02243     template< typename RhsValueT >
02244     xst_binary_adaptor<
02245         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02246         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
02247         xst_left_shift_assignment_policy<
02248             1, // xst_scalar capacity
02249             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02250             primitive_id_unary_adaptor
02251         >
02252     >
02253     operator<<= ( RhsValueT* pvalue_ )
02254     {
02255         typedef xst_binary_adaptor<
02256             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02257             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
02258             xst_left_shift_assignment_policy<
02259                 1, // xst_scalar capacity
02260                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02261                 primitive_id_unary_adaptor
02262             >
02263         > xst_adaptor_T;
02264 
02265         return xst_adaptor_T(
02266             *this,
02267             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
02268             );
02269     }
02270 
02271 
02273 // Assignment <<= specializations
02275 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:98
02290     template< typename LambdaT >
02291     xst_binary_adaptor<
02292         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02293         xst_lambda_wrap< typename LambdaT::reference_T >,
02294         xst_left_shift_assignment_policy<
02295             LambdaT::capacity_,
02296             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02297             primitive_id_unary_adaptor
02298         >
02299     >
02300     operator<<= ( xst_lambda_wrap< LambdaT > const& lambda_ )
02301     {
02302         typedef xst_binary_adaptor<
02303             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02304             xst_lambda_wrap< typename LambdaT::reference_T >,
02305             xst_left_shift_assignment_policy<
02306                 LambdaT::capacity_,
02307                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02308                 primitive_id_unary_adaptor
02309             >
02310         > xst_adaptor_T;
02311 
02312         return xst_adaptor_T( *this, lambda_.make_reference() );
02313     }
02314 
02315 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:138
02335     template< typename LambdaT, typename UnaryPolicyAdaptorT >
02336     xst_binary_adaptor<
02337         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02338         xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
02339         xst_left_shift_assignment_policy<
02340             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
02341             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02342             primitive_id_unary_adaptor
02343         >
02344     >
02345     operator<<= ( xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const& lambda_ )
02346     {
02347         typedef xst_binary_adaptor<
02348             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02349             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
02350             xst_left_shift_assignment_policy<
02351                 xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
02352                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02353                 primitive_id_unary_adaptor
02354             >
02355         > xst_adaptor_T;
02356 
02357         return xst_adaptor_T( *this, lambda_ );
02358     }
02359 
02360 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:183
02384     template< typename LambdaLhsT, typename LambdaRhsT, typename BinaryPolicyAdaptorT >
02385     xst_binary_adaptor<
02386         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02387         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
02388         xst_left_shift_assignment_policy<
02389             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
02390             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02391             primitive_id_unary_adaptor
02392         >
02393     >
02394     operator<<= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const& lambda_ )
02395     {
02396         typedef xst_binary_adaptor<
02397             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02398             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
02399             xst_left_shift_assignment_policy<
02400                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
02401                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02402                 primitive_id_unary_adaptor
02403             >
02404         > xst_adaptor_T;
02405 
02406         return xst_adaptor_T( *this, lambda_ );
02407     }
02408 
02410 // More <<= assignment abbreviations
02412 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:235
02428     template< typename StackValueT >
02429     xst_binary_adaptor<
02430         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02431         xst_lambda_wrap< xst_scalar< StackValueT > >,
02432         xst_left_shift_assignment_policy<
02433             1, // xst_scalar capacity
02434             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02435             primitive_id_unary_adaptor
02436         >
02437     >
02438     operator<<= ( std::stack< StackValueT > const& stack_ )
02439     {
02440         typedef xst_binary_adaptor<
02441             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02442             xst_lambda_wrap< xst_scalar< StackValueT > >,
02443             xst_left_shift_assignment_policy<
02444                 1, // xst_scalar capacity
02445                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02446                 primitive_id_unary_adaptor
02447             >
02448         > xst_adaptor_T;
02449 
02450         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
02451         return xst_adaptor_T(
02452             *this,
02453             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
02454             );
02455     }
02456 
02457 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:280
02473     template< typename StackValueT >
02474     xst_binary_adaptor<
02475         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02476         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
02477         xst_left_shift_assignment_policy<
02478             1, // xst_stack capacity
02479             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02480             primitive_id_unary_adaptor
02481         >
02482     >
02483     operator<<= ( std::stack< StackValueT >* pstack_ )
02484     {
02485         typedef xst_binary_adaptor<
02486             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02487             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
02488             xst_left_shift_assignment_policy<
02489                 1, // xst_stack capacity
02490                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02491                 primitive_id_unary_adaptor
02492             >
02493         > xst_adaptor_T;
02494 
02495         return xst_adaptor_T(
02496             *this,
02497             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
02498             );
02499     }
02500 
02502 // Assignment <<= operators end
02504 
02505 // generated by gmu/lambda/gmu_common.h:187
02507 // Assignment >>= operators begin
02509 
02511 // Assignment >>= abbreviations
02513 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:8
02528     template< typename RhsValueT >
02529     xst_binary_adaptor<
02530         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02531         xst_lambda_wrap< xst_scalar< RhsValueT > >,
02532         xst_right_shift_assignment_policy<
02533             1, // xst_scalar capacity
02534             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02535             primitive_id_unary_adaptor
02536         >
02537     >
02538     operator>>= ( RhsValueT const& value_ )
02539     {
02540         typedef xst_binary_adaptor<
02541             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02542             xst_lambda_wrap< xst_scalar< RhsValueT > >,
02543             xst_right_shift_assignment_policy<
02544                 1, // xst_scalar capacity
02545                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02546                 primitive_id_unary_adaptor
02547             >
02548         > xst_adaptor_T;
02549 
02550         return xst_adaptor_T(
02551             *this,
02552             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
02553             );
02554     }
02555 
02556 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:51
02571     template< typename RhsValueT >
02572     xst_binary_adaptor<
02573         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02574         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
02575         xst_right_shift_assignment_policy<
02576             1, // xst_scalar capacity
02577             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02578             primitive_id_unary_adaptor
02579         >
02580     >
02581     operator>>= ( RhsValueT* pvalue_ )
02582     {
02583         typedef xst_binary_adaptor<
02584             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02585             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
02586             xst_right_shift_assignment_policy<
02587                 1, // xst_scalar capacity
02588                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02589                 primitive_id_unary_adaptor
02590             >
02591         > xst_adaptor_T;
02592 
02593         return xst_adaptor_T(
02594             *this,
02595             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
02596             );
02597     }
02598 
02599 
02601 // Assignment >>= specializations
02603 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:98
02618     template< typename LambdaT >
02619     xst_binary_adaptor<
02620         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02621         xst_lambda_wrap< typename LambdaT::reference_T >,
02622         xst_right_shift_assignment_policy<
02623             LambdaT::capacity_,
02624             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02625             primitive_id_unary_adaptor
02626         >
02627     >
02628     operator>>= ( xst_lambda_wrap< LambdaT > const& lambda_ )
02629     {
02630         typedef xst_binary_adaptor<
02631             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02632             xst_lambda_wrap< typename LambdaT::reference_T >,
02633             xst_right_shift_assignment_policy<
02634                 LambdaT::capacity_,
02635                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02636                 primitive_id_unary_adaptor
02637             >
02638         > xst_adaptor_T;
02639 
02640         return xst_adaptor_T( *this, lambda_.make_reference() );
02641     }
02642 
02643 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:138
02663     template< typename LambdaT, typename UnaryPolicyAdaptorT >
02664     xst_binary_adaptor<
02665         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02666         xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
02667         xst_right_shift_assignment_policy<
02668             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
02669             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02670             primitive_id_unary_adaptor
02671         >
02672     >
02673     operator>>= ( xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const& lambda_ )
02674     {
02675         typedef xst_binary_adaptor<
02676             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02677             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
02678             xst_right_shift_assignment_policy<
02679                 xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
02680                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02681                 primitive_id_unary_adaptor
02682             >
02683         > xst_adaptor_T;
02684 
02685         return xst_adaptor_T( *this, lambda_ );
02686     }
02687 
02688 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:183
02712     template< typename LambdaLhsT, typename LambdaRhsT, typename BinaryPolicyAdaptorT >
02713     xst_binary_adaptor<
02714         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02715         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
02716         xst_right_shift_assignment_policy<
02717             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
02718             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02719             primitive_id_unary_adaptor
02720         >
02721     >
02722     operator>>= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const& lambda_ )
02723     {
02724         typedef xst_binary_adaptor<
02725             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02726             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
02727             xst_right_shift_assignment_policy<
02728                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
02729                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02730                 primitive_id_unary_adaptor
02731             >
02732         > xst_adaptor_T;
02733 
02734         return xst_adaptor_T( *this, lambda_ );
02735     }
02736 
02738 // More >>= assignment abbreviations
02740 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:235
02756     template< typename StackValueT >
02757     xst_binary_adaptor<
02758         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02759         xst_lambda_wrap< xst_scalar< StackValueT > >,
02760         xst_right_shift_assignment_policy<
02761             1, // xst_scalar capacity
02762             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02763             primitive_id_unary_adaptor
02764         >
02765     >
02766     operator>>= ( std::stack< StackValueT > const& stack_ )
02767     {
02768         typedef xst_binary_adaptor<
02769             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02770             xst_lambda_wrap< xst_scalar< StackValueT > >,
02771             xst_right_shift_assignment_policy<
02772                 1, // xst_scalar capacity
02773                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02774                 primitive_id_unary_adaptor
02775             >
02776         > xst_adaptor_T;
02777 
02778         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
02779         return xst_adaptor_T(
02780             *this,
02781             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
02782             );
02783     }
02784 
02785 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:280
02801     template< typename StackValueT >
02802     xst_binary_adaptor<
02803         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02804         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
02805         xst_right_shift_assignment_policy<
02806             1, // xst_stack capacity
02807             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02808             primitive_id_unary_adaptor
02809         >
02810     >
02811     operator>>= ( std::stack< StackValueT >* pstack_ )
02812     {
02813         typedef xst_binary_adaptor<
02814             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02815             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
02816             xst_right_shift_assignment_policy<
02817                 1, // xst_stack capacity
02818                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02819                 primitive_id_unary_adaptor
02820             >
02821         > xst_adaptor_T;
02822 
02823         return xst_adaptor_T(
02824             *this,
02825             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
02826             );
02827     }
02828 
02830 // Assignment >>= operators end
02832 
02833 // generated by gmu/lambda/gmu_common.h:187
02835 // Assignment &= operators begin
02837 
02839 // Assignment &= abbreviations
02841 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:8
02856     template< typename RhsValueT >
02857     xst_binary_adaptor<
02858         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02859         xst_lambda_wrap< xst_scalar< RhsValueT > >,
02860         xst_bitwise_and_assignment_policy<
02861             1, // xst_scalar capacity
02862             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02863             primitive_id_unary_adaptor
02864         >
02865     >
02866     operator&= ( RhsValueT const& value_ )
02867     {
02868         typedef xst_binary_adaptor<
02869             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02870             xst_lambda_wrap< xst_scalar< RhsValueT > >,
02871             xst_bitwise_and_assignment_policy<
02872                 1, // xst_scalar capacity
02873                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02874                 primitive_id_unary_adaptor
02875             >
02876         > xst_adaptor_T;
02877 
02878         return xst_adaptor_T(
02879             *this,
02880             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
02881             );
02882     }
02883 
02884 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:51
02899     template< typename RhsValueT >
02900     xst_binary_adaptor<
02901         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02902         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
02903         xst_bitwise_and_assignment_policy<
02904             1, // xst_scalar capacity
02905             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02906             primitive_id_unary_adaptor
02907         >
02908     >
02909     operator&= ( RhsValueT* pvalue_ )
02910     {
02911         typedef xst_binary_adaptor<
02912             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02913             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
02914             xst_bitwise_and_assignment_policy<
02915                 1, // xst_scalar capacity
02916                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02917                 primitive_id_unary_adaptor
02918             >
02919         > xst_adaptor_T;
02920 
02921         return xst_adaptor_T(
02922             *this,
02923             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
02924             );
02925     }
02926 
02927 
02929 // Assignment &= specializations
02931 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:98
02946     template< typename LambdaT >
02947     xst_binary_adaptor<
02948         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02949         xst_lambda_wrap< typename LambdaT::reference_T >,
02950         xst_bitwise_and_assignment_policy<
02951             LambdaT::capacity_,
02952             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02953             primitive_id_unary_adaptor
02954         >
02955     >
02956     operator&= ( xst_lambda_wrap< LambdaT > const& lambda_ )
02957     {
02958         typedef xst_binary_adaptor<
02959             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02960             xst_lambda_wrap< typename LambdaT::reference_T >,
02961             xst_bitwise_and_assignment_policy<
02962                 LambdaT::capacity_,
02963                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02964                 primitive_id_unary_adaptor
02965             >
02966         > xst_adaptor_T;
02967 
02968         return xst_adaptor_T( *this, lambda_.make_reference() );
02969     }
02970 
02971 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:138
02991     template< typename LambdaT, typename UnaryPolicyAdaptorT >
02992     xst_binary_adaptor<
02993         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
02994         xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
02995         xst_bitwise_and_assignment_policy<
02996             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
02997             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
02998             primitive_id_unary_adaptor
02999         >
03000     >
03001     operator&= ( xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const& lambda_ )
03002     {
03003         typedef xst_binary_adaptor<
03004             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03005             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
03006             xst_bitwise_and_assignment_policy<
03007                 xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
03008                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03009                 primitive_id_unary_adaptor
03010             >
03011         > xst_adaptor_T;
03012 
03013         return xst_adaptor_T( *this, lambda_ );
03014     }
03015 
03016 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:183
03040     template< typename LambdaLhsT, typename LambdaRhsT, typename BinaryPolicyAdaptorT >
03041     xst_binary_adaptor<
03042         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03043         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
03044         xst_bitwise_and_assignment_policy<
03045             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
03046             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03047             primitive_id_unary_adaptor
03048         >
03049     >
03050     operator&= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const& lambda_ )
03051     {
03052         typedef xst_binary_adaptor<
03053             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03054             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
03055             xst_bitwise_and_assignment_policy<
03056                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
03057                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03058                 primitive_id_unary_adaptor
03059             >
03060         > xst_adaptor_T;
03061 
03062         return xst_adaptor_T( *this, lambda_ );
03063     }
03064 
03066 // More &= assignment abbreviations
03068 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:235
03084     template< typename StackValueT >
03085     xst_binary_adaptor<
03086         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03087         xst_lambda_wrap< xst_scalar< StackValueT > >,
03088         xst_bitwise_and_assignment_policy<
03089             1, // xst_scalar capacity
03090             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03091             primitive_id_unary_adaptor
03092         >
03093     >
03094     operator&= ( std::stack< StackValueT > const& stack_ )
03095     {
03096         typedef xst_binary_adaptor<
03097             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03098             xst_lambda_wrap< xst_scalar< StackValueT > >,
03099             xst_bitwise_and_assignment_policy<
03100                 1, // xst_scalar capacity
03101                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03102                 primitive_id_unary_adaptor
03103             >
03104         > xst_adaptor_T;
03105 
03106         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
03107         return xst_adaptor_T(
03108             *this,
03109             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
03110             );
03111     }
03112 
03113 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:280
03129     template< typename StackValueT >
03130     xst_binary_adaptor<
03131         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03132         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
03133         xst_bitwise_and_assignment_policy<
03134             1, // xst_stack capacity
03135             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03136             primitive_id_unary_adaptor
03137         >
03138     >
03139     operator&= ( std::stack< StackValueT >* pstack_ )
03140     {
03141         typedef xst_binary_adaptor<
03142             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03143             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
03144             xst_bitwise_and_assignment_policy<
03145                 1, // xst_stack capacity
03146                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03147                 primitive_id_unary_adaptor
03148             >
03149         > xst_adaptor_T;
03150 
03151         return xst_adaptor_T(
03152             *this,
03153             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
03154             );
03155     }
03156 
03158 // Assignment &= operators end
03160 
03161 // generated by gmu/lambda/gmu_common.h:187
03163 // Assignment |= operators begin
03165 
03167 // Assignment |= abbreviations
03169 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:8
03184     template< typename RhsValueT >
03185     xst_binary_adaptor<
03186         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03187         xst_lambda_wrap< xst_scalar< RhsValueT > >,
03188         xst_bitwise_ior_assignment_policy<
03189             1, // xst_scalar capacity
03190             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03191             primitive_id_unary_adaptor
03192         >
03193     >
03194     operator|= ( RhsValueT const& value_ )
03195     {
03196         typedef xst_binary_adaptor<
03197             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03198             xst_lambda_wrap< xst_scalar< RhsValueT > >,
03199             xst_bitwise_ior_assignment_policy<
03200                 1, // xst_scalar capacity
03201                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03202                 primitive_id_unary_adaptor
03203             >
03204         > xst_adaptor_T;
03205 
03206         return xst_adaptor_T(
03207             *this,
03208             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
03209             );
03210     }
03211 
03212 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:51
03227     template< typename RhsValueT >
03228     xst_binary_adaptor<
03229         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03230         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
03231         xst_bitwise_ior_assignment_policy<
03232             1, // xst_scalar capacity
03233             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03234             primitive_id_unary_adaptor
03235         >
03236     >
03237     operator|= ( RhsValueT* pvalue_ )
03238     {
03239         typedef xst_binary_adaptor<
03240             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03241             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
03242             xst_bitwise_ior_assignment_policy<
03243                 1, // xst_scalar capacity
03244                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03245                 primitive_id_unary_adaptor
03246             >
03247         > xst_adaptor_T;
03248 
03249         return xst_adaptor_T(
03250             *this,
03251             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
03252             );
03253     }
03254 
03255 
03257 // Assignment |= specializations
03259 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:98
03274     template< typename LambdaT >
03275     xst_binary_adaptor<
03276         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03277         xst_lambda_wrap< typename LambdaT::reference_T >,
03278         xst_bitwise_ior_assignment_policy<
03279             LambdaT::capacity_,
03280             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03281             primitive_id_unary_adaptor
03282         >
03283     >
03284     operator|= ( xst_lambda_wrap< LambdaT > const& lambda_ )
03285     {
03286         typedef xst_binary_adaptor<
03287             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03288             xst_lambda_wrap< typename LambdaT::reference_T >,
03289             xst_bitwise_ior_assignment_policy<
03290                 LambdaT::capacity_,
03291                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03292                 primitive_id_unary_adaptor
03293             >
03294         > xst_adaptor_T;
03295 
03296         return xst_adaptor_T( *this, lambda_.make_reference() );
03297     }
03298 
03299 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:138
03319     template< typename LambdaT, typename UnaryPolicyAdaptorT >
03320     xst_binary_adaptor<
03321         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03322         xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
03323         xst_bitwise_ior_assignment_policy<
03324             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
03325             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03326             primitive_id_unary_adaptor
03327         >
03328     >
03329     operator|= ( xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const& lambda_ )
03330     {
03331         typedef xst_binary_adaptor<
03332             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03333             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
03334             xst_bitwise_ior_assignment_policy<
03335                 xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
03336                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03337                 primitive_id_unary_adaptor
03338             >
03339         > xst_adaptor_T;
03340 
03341         return xst_adaptor_T( *this, lambda_ );
03342     }
03343 
03344 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:183
03368     template< typename LambdaLhsT, typename LambdaRhsT, typename BinaryPolicyAdaptorT >
03369     xst_binary_adaptor<
03370         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03371         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
03372         xst_bitwise_ior_assignment_policy<
03373             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
03374             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03375             primitive_id_unary_adaptor
03376         >
03377     >
03378     operator|= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const& lambda_ )
03379     {
03380         typedef xst_binary_adaptor<
03381             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03382             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
03383             xst_bitwise_ior_assignment_policy<
03384                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
03385                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03386                 primitive_id_unary_adaptor
03387             >
03388         > xst_adaptor_T;
03389 
03390         return xst_adaptor_T( *this, lambda_ );
03391     }
03392 
03394 // More |= assignment abbreviations
03396 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:235
03412     template< typename StackValueT >
03413     xst_binary_adaptor<
03414         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03415         xst_lambda_wrap< xst_scalar< StackValueT > >,
03416         xst_bitwise_ior_assignment_policy<
03417             1, // xst_scalar capacity
03418             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03419             primitive_id_unary_adaptor
03420         >
03421     >
03422     operator|= ( std::stack< StackValueT > const& stack_ )
03423     {
03424         typedef xst_binary_adaptor<
03425             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03426             xst_lambda_wrap< xst_scalar< StackValueT > >,
03427             xst_bitwise_ior_assignment_policy<
03428                 1, // xst_scalar capacity
03429                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03430                 primitive_id_unary_adaptor
03431             >
03432         > xst_adaptor_T;
03433 
03434         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
03435         return xst_adaptor_T(
03436             *this,
03437             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
03438             );
03439     }
03440 
03441 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:280
03457     template< typename StackValueT >
03458     xst_binary_adaptor<
03459         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03460         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
03461         xst_bitwise_ior_assignment_policy<
03462             1, // xst_stack capacity
03463             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03464             primitive_id_unary_adaptor
03465         >
03466     >
03467     operator|= ( std::stack< StackValueT >* pstack_ )
03468     {
03469         typedef xst_binary_adaptor<
03470             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03471             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
03472             xst_bitwise_ior_assignment_policy<
03473                 1, // xst_stack capacity
03474                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03475                 primitive_id_unary_adaptor
03476             >
03477         > xst_adaptor_T;
03478 
03479         return xst_adaptor_T(
03480             *this,
03481             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
03482             );
03483     }
03484 
03486 // Assignment |= operators end
03488 
03489 // generated by gmu/lambda/gmu_common.h:187
03491 // Assignment ^= operators begin
03493 
03495 // Assignment ^= abbreviations
03497 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:8
03512     template< typename RhsValueT >
03513     xst_binary_adaptor<
03514         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03515         xst_lambda_wrap< xst_scalar< RhsValueT > >,
03516         xst_bitwise_xor_assignment_policy<
03517             1, // xst_scalar capacity
03518             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03519             primitive_id_unary_adaptor
03520         >
03521     >
03522     operator^= ( RhsValueT const& value_ )
03523     {
03524         typedef xst_binary_adaptor<
03525             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03526             xst_lambda_wrap< xst_scalar< RhsValueT > >,
03527             xst_bitwise_xor_assignment_policy<
03528                 1, // xst_scalar capacity
03529                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03530                 primitive_id_unary_adaptor
03531             >
03532         > xst_adaptor_T;
03533 
03534         return xst_adaptor_T(
03535             *this,
03536             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
03537             );
03538     }
03539 
03540 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:51
03555     template< typename RhsValueT >
03556     xst_binary_adaptor<
03557         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03558         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
03559         xst_bitwise_xor_assignment_policy<
03560             1, // xst_scalar capacity
03561             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03562             primitive_id_unary_adaptor
03563         >
03564     >
03565     operator^= ( RhsValueT* pvalue_ )
03566     {
03567         typedef xst_binary_adaptor<
03568             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03569             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
03570             xst_bitwise_xor_assignment_policy<
03571                 1, // xst_scalar capacity
03572                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03573                 primitive_id_unary_adaptor
03574             >
03575         > xst_adaptor_T;
03576 
03577         return xst_adaptor_T(
03578             *this,
03579             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
03580             );
03581     }
03582 
03583 
03585 // Assignment ^= specializations
03587 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:98
03602     template< typename LambdaT >
03603     xst_binary_adaptor<
03604         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03605         xst_lambda_wrap< typename LambdaT::reference_T >,
03606         xst_bitwise_xor_assignment_policy<
03607             LambdaT::capacity_,
03608             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03609             primitive_id_unary_adaptor
03610         >
03611     >
03612     operator^= ( xst_lambda_wrap< LambdaT > const& lambda_ )
03613     {
03614         typedef xst_binary_adaptor<
03615             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03616             xst_lambda_wrap< typename LambdaT::reference_T >,
03617             xst_bitwise_xor_assignment_policy<
03618                 LambdaT::capacity_,
03619                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03620                 primitive_id_unary_adaptor
03621             >
03622         > xst_adaptor_T;
03623 
03624         return xst_adaptor_T( *this, lambda_.make_reference() );
03625     }
03626 
03627 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:138
03647     template< typename LambdaT, typename UnaryPolicyAdaptorT >
03648     xst_binary_adaptor<
03649         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03650         xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
03651         xst_bitwise_xor_assignment_policy<
03652             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
03653             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03654             primitive_id_unary_adaptor
03655         >
03656     >
03657     operator^= ( xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT > const& lambda_ )
03658     {
03659         typedef xst_binary_adaptor<
03660             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03661             xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >,
03662             xst_bitwise_xor_assignment_policy<
03663                 xst_unary_adaptor< LambdaT, UnaryPolicyAdaptorT >::capacity_,
03664                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03665                 primitive_id_unary_adaptor
03666             >
03667         > xst_adaptor_T;
03668 
03669         return xst_adaptor_T( *this, lambda_ );
03670     }
03671 
03672 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:183
03696     template< typename LambdaLhsT, typename LambdaRhsT, typename BinaryPolicyAdaptorT >
03697     xst_binary_adaptor<
03698         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03699         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
03700         xst_bitwise_xor_assignment_policy<
03701             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
03702             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03703             primitive_id_unary_adaptor
03704         >
03705     >
03706     operator^= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const& lambda_ )
03707     {
03708         typedef xst_binary_adaptor<
03709             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03710             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
03711             xst_bitwise_xor_assignment_policy<
03712                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
03713                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03714                 primitive_id_unary_adaptor
03715             >
03716         > xst_adaptor_T;
03717 
03718         return xst_adaptor_T( *this, lambda_ );
03719     }
03720 
03722 // More ^= assignment abbreviations
03724 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:235
03740     template< typename StackValueT >
03741     xst_binary_adaptor<
03742         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03743         xst_lambda_wrap< xst_scalar< StackValueT > >,
03744         xst_bitwise_xor_assignment_policy<
03745             1, // xst_scalar capacity
03746             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03747             primitive_id_unary_adaptor
03748         >
03749     >
03750     operator^= ( std::stack< StackValueT > const& stack_ )
03751     {
03752         typedef xst_binary_adaptor<
03753             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03754             xst_lambda_wrap< xst_scalar< StackValueT > >,
03755             xst_bitwise_xor_assignment_policy<
03756                 1, // xst_scalar capacity
03757                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03758                 primitive_id_unary_adaptor
03759             >
03760         > xst_adaptor_T;
03761 
03762         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
03763         return xst_adaptor_T(
03764             *this,
03765             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
03766             );
03767     }
03768 
03769 // generated by gmu/lambda/operators/assign/binary_adaptor_assign_funcs.h:280
03785     template< typename StackValueT >
03786     xst_binary_adaptor<
03787         xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03788         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
03789         xst_bitwise_xor_assignment_policy<
03790             1, // xst_stack capacity
03791             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03792             primitive_id_unary_adaptor
03793         >
03794     >
03795     operator^= ( std::stack< StackValueT >* pstack_ )
03796     {
03797         typedef xst_binary_adaptor<
03798             xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >,
03799             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
03800             xst_bitwise_xor_assignment_policy<
03801                 1, // xst_stack capacity
03802                 xst_binary_adaptor< LhsT, RhsT, PolicyAdaptorT >::capacity_,
03803                 primitive_id_unary_adaptor
03804             >
03805         > xst_adaptor_T;
03806 
03807         return xst_adaptor_T(
03808             *this,
03809             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
03810             );
03811     }
03812 
03814 // Assignment ^= operators end
03816 
03817 //end_generated_code
03818 
03819 };  // xst_binary_adaptor
03820 
03821 }   // namespace cttl_impl
03822 
03823 
03824 #endif //_XST_BINARY_ADAPTOR_H_INCLUDED_
Generated on Thu Nov 2 17:48:22 2006 for CTTL Lambda Expression by  doxygen 1.3.9.1