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< S