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

xst_unary_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_unary_adaptor.h
00034 
00035 #ifndef _XST_UNARY_ADAPTOR_H_INCLUDED_
00036 #define _XST_UNARY_ADAPTOR_H_INCLUDED_
00037 
00038 namespace cttl_impl {
00039 
00040 // U -> U<E,A>, where U := xst_unary_adaptor< ExprT, PolicyAdaptorT >
00041 
00056 template< typename ExprT, typename PolicyAdaptorT >
00057 class xst_unary_adaptor : public xtl_op_base_unary< ExprT > {
00058 
00059 public:
00060     enum {
00062         primitive_id_ = primitive_id_unary_adaptor,
00063 
00065         operator_id_ = PolicyAdaptorT::operator_id_,
00066 
00068         capacity_ = ExprT::capacity_
00069     };
00070 
00071 
00073     typedef typename xst_unary_operator_traits<
00074         typename ExprT::value_T,
00075         typename ExprT::dereferenced_value_T,
00076         operator_id_
00077     >::value_type value_T;
00078 
00080     typedef value_T value_type;
00081 
00083     typedef typename ExprT::dereferenced_value_T dereferenced_value_T; // always carried over as is
00084 
00086     xst_unary_adaptor( ExprT const& expr_ )
00087     : xtl_op_base_unary< ExprT >( expr_ )
00088     {
00089     }
00090 
00092     xst_unary_adaptor( xst_unary_adaptor< ExprT, PolicyAdaptorT > const& other_ )
00093     : xtl_op_base_unary< ExprT >( other_.m_expr )
00094     {
00095     }
00096 
00098     void evaluate()
00099     {
00100         CTTL_TRACE_DEPOSIT_JUSTIFY();
00101         CTTL_TRACE_DEPOSIT_DELAYED_CHAR( '\n' );
00102         PolicyAdaptorT::top( this->m_expr );
00103     }
00104 
00124     template< typename UniverseT >
00125     size_t match( UniverseT& edge_ )
00126     {
00127         CTTL_TRACE_LEVEL_MATCH( 'u' );
00128         CTTL_TRACE_DEPOSIT_JUSTIFY();
00129         CTTL_TRACE_DEPOSIT_DELAYED_CHAR( '\n' );
00130         return PolicyAdaptorT::match( this->m_expr, edge_ );
00131     }
00132 
00134     value_T top() const
00135     {
00136         return PolicyAdaptorT::top( this->m_expr );
00137     }
00138 
00140     template< typename SubscriptLambdaT >
00141     value_T top( SubscriptLambdaT ) const
00142     {
00143         return top();
00144     }
00145 
00147     value_T& lvalue_ref()
00148     {
00149         return PolicyAdaptorT::lvalue_ref( this->m_expr );
00150     }
00151 
00153     dereferenced_value_T&
00154     dereferenced_value()
00155     {
00156         return PolicyAdaptorT::dereferenced_lvalue( this->m_expr );
00157     }
00158 
00159 
00161     void prefix_side_effects()
00162     {
00163         PolicyAdaptorT::prefix_side_effects( this->m_expr );
00164     }
00165 
00167     void postfix_side_effects()
00168     {
00169         PolicyAdaptorT::postfix_side_effects( this->m_expr );
00170     }
00171 
00173 // Overloaded operators
00175 
00176 // Do not modify section of code between begin_generated_code
00177 // and end_generated_code comments. This section of code is
00178 // maintained by gumus scripts.
00179 
00180 //begin_generated_code
00181 // generated by gmu/lambda/gmu_common.h:626
00182 // on Thu Nov 02 13:01:33 2006.
00183 // generated by gmu/lambda/gmu_common.h:177
00185 // Assignment = operators begin
00187 
00189 // Assignment = abbreviations
00191 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:8
00206     template< typename RhsValueT >
00207     xst_binary_adaptor<
00208         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00209         xst_lambda_wrap< xst_scalar< RhsValueT > >,
00210         xst_assignment_policy<
00211             1, // xst_scalar capacity
00212             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00213             primitive_id_unary_adaptor
00214         >
00215     >
00216     operator= ( RhsValueT const& value_ )
00217     {
00218         typedef xst_binary_adaptor<
00219             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00220             xst_lambda_wrap< xst_scalar< RhsValueT > >,
00221             xst_assignment_policy<
00222                 1, // xst_scalar capacity
00223                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00224                 primitive_id_unary_adaptor
00225             >
00226         > xst_adaptor_T;
00227 
00228         return xst_adaptor_T(
00229             *this,
00230             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
00231             );
00232     }
00233 
00234 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:51
00249     template< typename RhsValueT >
00250     xst_binary_adaptor<
00251         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00252         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
00253         xst_assignment_policy<
00254             1, // xst_scalar capacity
00255             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00256             primitive_id_unary_adaptor
00257         >
00258     >
00259     operator= ( RhsValueT* pvalue_ )
00260     {
00261         typedef xst_binary_adaptor<
00262             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00263             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
00264             xst_assignment_policy<
00265                 1, // xst_scalar capacity
00266                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00267                 primitive_id_unary_adaptor
00268             >
00269         > xst_adaptor_T;
00270 
00271         return xst_adaptor_T(
00272             *this,
00273             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
00274             );
00275     }
00276 
00278 // Assignment = specializations
00280 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:97
00295     template< typename LambdaT >
00296     xst_binary_adaptor<
00297         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00298         xst_lambda_wrap< typename LambdaT::reference_T >,
00299         xst_assignment_policy<
00300             LambdaT::capacity_,
00301             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00302             primitive_id_unary_adaptor
00303         >
00304     >
00305     operator= ( xst_lambda_wrap< LambdaT > const& lambda_ )
00306     {
00307         typedef xst_binary_adaptor<
00308             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00309             xst_lambda_wrap< typename LambdaT::reference_T >,
00310             xst_assignment_policy<
00311                 LambdaT::capacity_,
00312                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00313                 primitive_id_unary_adaptor
00314             >
00315         > xst_adaptor_T;
00316 
00317         return xst_adaptor_T( *this, lambda_.make_reference() );
00318     }
00319 
00320 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:137
00336     template< typename LambdaT >
00337     xst_binary_adaptor<
00338         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00339         xst_unary_adaptor< LambdaT, PolicyAdaptorT >,
00340         xst_assignment_policy<
00341             xst_unary_adaptor< LambdaT, PolicyAdaptorT >::capacity_,
00342             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00343             primitive_id_unary_adaptor
00344         >
00345     >
00346     operator= ( xst_unary_adaptor< LambdaT, PolicyAdaptorT > const& lambda_ )
00347     {
00348         typedef xst_binary_adaptor<
00349             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00350             xst_unary_adaptor< LambdaT, PolicyAdaptorT >,
00351             xst_assignment_policy<
00352                 xst_unary_adaptor< LambdaT, PolicyAdaptorT >::capacity_,
00353                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00354                 primitive_id_unary_adaptor
00355             >
00356         > xst_adaptor_T;
00357 
00358         return xst_adaptor_T( *this, lambda_ );
00359     }
00360 
00361 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:178
00381     template< typename LambdaT, typename OtherPolicyAdaptorT >
00382     xst_binary_adaptor<
00383         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00384         xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >,
00385         xst_assignment_policy<
00386             xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >::capacity_,
00387             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00388             primitive_id_unary_adaptor
00389         >
00390     >
00391     operator= ( xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT > const& lambda_ )
00392     {
00393         typedef xst_binary_adaptor<
00394             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00395             xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >,
00396             xst_assignment_policy<
00397                 xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >::capacity_,
00398                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00399                 primitive_id_unary_adaptor
00400             >
00401         > xst_adaptor_T;
00402 
00403         return xst_adaptor_T( *this, lambda_ );
00404     }
00405 
00406 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:223
00430     template< typename LambdaLhsT, typename LambdaRhsT, typename BinaryPolicyAdaptorT >
00431     xst_binary_adaptor<
00432         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00433         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
00434         xst_assignment_policy<
00435             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
00436             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00437             primitive_id_unary_adaptor
00438         >
00439     >
00440     operator= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const& lambda_ )
00441     {
00442         typedef xst_binary_adaptor<
00443             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00444             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
00445             xst_assignment_policy<
00446                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
00447                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00448                 primitive_id_unary_adaptor
00449             >
00450         > xst_adaptor_T;
00451 
00452         return xst_adaptor_T( *this, lambda_ );
00453     }
00454 
00456 // Assignment = abbreviations
00458 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:275
00474     template< typename StackValueT >
00475     xst_binary_adaptor<
00476         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00477         xst_lambda_wrap< xst_scalar< StackValueT > >,
00478         xst_assignment_policy<
00479             1, // xst_scalar capacity
00480             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00481             primitive_id_unary_adaptor
00482         >
00483     >
00484     operator= ( std::stack< StackValueT > const& stack_ )
00485     {
00486         typedef xst_binary_adaptor<
00487             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00488             xst_lambda_wrap< xst_scalar< StackValueT > >,
00489             xst_assignment_policy<
00490                 1, // xst_scalar capacity
00491                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00492                 primitive_id_unary_adaptor
00493             >
00494         > xst_adaptor_T;
00495 
00496         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
00497         return xst_adaptor_T(
00498             *this,
00499             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
00500             );
00501     }
00502 
00503 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:320
00519     template< typename StackValueT >
00520     xst_binary_adaptor<
00521         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00522         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
00523         xst_assignment_policy<
00524             1, // xst_stack capacity
00525             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00526             primitive_id_unary_adaptor
00527         >
00528     >
00529     operator= ( std::stack< StackValueT >* pstack_ )
00530     {
00531         typedef xst_binary_adaptor<
00532             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00533             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
00534             xst_assignment_policy<
00535                 1, // xst_stack capacity
00536                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00537                 primitive_id_unary_adaptor
00538             >
00539         > xst_adaptor_T;
00540 
00541         return xst_adaptor_T(
00542             *this,
00543             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
00544             );
00545     }
00546 
00548 // Assignment = operators end
00550 
00551 // generated by gmu/lambda/gmu_common.h:177
00553 // Assignment *= operators begin
00555 
00557 // Assignment *= abbreviations
00559 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:8
00574     template< typename RhsValueT >
00575     xst_binary_adaptor<
00576         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00577         xst_lambda_wrap< xst_scalar< RhsValueT > >,
00578         xst_multiplication_assignment_policy<
00579             1, // xst_scalar capacity
00580             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00581             primitive_id_unary_adaptor
00582         >
00583     >
00584     operator*= ( RhsValueT const& value_ )
00585     {
00586         typedef xst_binary_adaptor<
00587             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00588             xst_lambda_wrap< xst_scalar< RhsValueT > >,
00589             xst_multiplication_assignment_policy<
00590                 1, // xst_scalar capacity
00591                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00592                 primitive_id_unary_adaptor
00593             >
00594         > xst_adaptor_T;
00595 
00596         return xst_adaptor_T(
00597             *this,
00598             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
00599             );
00600     }
00601 
00602 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:51
00617     template< typename RhsValueT >
00618     xst_binary_adaptor<
00619         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00620         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
00621         xst_multiplication_assignment_policy<
00622             1, // xst_scalar capacity
00623             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00624             primitive_id_unary_adaptor
00625         >
00626     >
00627     operator*= ( RhsValueT* pvalue_ )
00628     {
00629         typedef xst_binary_adaptor<
00630             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00631             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
00632             xst_multiplication_assignment_policy<
00633                 1, // xst_scalar capacity
00634                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00635                 primitive_id_unary_adaptor
00636             >
00637         > xst_adaptor_T;
00638 
00639         return xst_adaptor_T(
00640             *this,
00641             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
00642             );
00643     }
00644 
00646 // Assignment *= specializations
00648 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:97
00663     template< typename LambdaT >
00664     xst_binary_adaptor<
00665         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00666         xst_lambda_wrap< typename LambdaT::reference_T >,
00667         xst_multiplication_assignment_policy<
00668             LambdaT::capacity_,
00669             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00670             primitive_id_unary_adaptor
00671         >
00672     >
00673     operator*= ( xst_lambda_wrap< LambdaT > const& lambda_ )
00674     {
00675         typedef xst_binary_adaptor<
00676             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00677             xst_lambda_wrap< typename LambdaT::reference_T >,
00678             xst_multiplication_assignment_policy<
00679                 LambdaT::capacity_,
00680                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00681                 primitive_id_unary_adaptor
00682             >
00683         > xst_adaptor_T;
00684 
00685         return xst_adaptor_T( *this, lambda_.make_reference() );
00686     }
00687 
00688 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:137
00704     template< typename LambdaT >
00705     xst_binary_adaptor<
00706         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00707         xst_unary_adaptor< LambdaT, PolicyAdaptorT >,
00708         xst_multiplication_assignment_policy<
00709             xst_unary_adaptor< LambdaT, PolicyAdaptorT >::capacity_,
00710             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00711             primitive_id_unary_adaptor
00712         >
00713     >
00714     operator*= ( xst_unary_adaptor< LambdaT, PolicyAdaptorT > const& lambda_ )
00715     {
00716         typedef xst_binary_adaptor<
00717             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00718             xst_unary_adaptor< LambdaT, PolicyAdaptorT >,
00719             xst_multiplication_assignment_policy<
00720                 xst_unary_adaptor< LambdaT, PolicyAdaptorT >::capacity_,
00721                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00722                 primitive_id_unary_adaptor
00723             >
00724         > xst_adaptor_T;
00725 
00726         return xst_adaptor_T( *this, lambda_ );
00727     }
00728 
00729 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:178
00749     template< typename LambdaT, typename OtherPolicyAdaptorT >
00750     xst_binary_adaptor<
00751         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00752         xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >,
00753         xst_multiplication_assignment_policy<
00754             xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >::capacity_,
00755             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00756             primitive_id_unary_adaptor
00757         >
00758     >
00759     operator*= ( xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT > const& lambda_ )
00760     {
00761         typedef xst_binary_adaptor<
00762             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00763             xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >,
00764             xst_multiplication_assignment_policy<
00765                 xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >::capacity_,
00766                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00767                 primitive_id_unary_adaptor
00768             >
00769         > xst_adaptor_T;
00770 
00771         return xst_adaptor_T( *this, lambda_ );
00772     }
00773 
00774 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:223
00798     template< typename LambdaLhsT, typename LambdaRhsT, typename BinaryPolicyAdaptorT >
00799     xst_binary_adaptor<
00800         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00801         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
00802         xst_multiplication_assignment_policy<
00803             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
00804             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00805             primitive_id_unary_adaptor
00806         >
00807     >
00808     operator*= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const& lambda_ )
00809     {
00810         typedef xst_binary_adaptor<
00811             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00812             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
00813             xst_multiplication_assignment_policy<
00814                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
00815                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00816                 primitive_id_unary_adaptor
00817             >
00818         > xst_adaptor_T;
00819 
00820         return xst_adaptor_T( *this, lambda_ );
00821     }
00822 
00824 // Assignment *= abbreviations
00826 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:275
00842     template< typename StackValueT >
00843     xst_binary_adaptor<
00844         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00845         xst_lambda_wrap< xst_scalar< StackValueT > >,
00846         xst_multiplication_assignment_policy<
00847             1, // xst_scalar capacity
00848             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00849             primitive_id_unary_adaptor
00850         >
00851     >
00852     operator*= ( std::stack< StackValueT > const& stack_ )
00853     {
00854         typedef xst_binary_adaptor<
00855             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00856             xst_lambda_wrap< xst_scalar< StackValueT > >,
00857             xst_multiplication_assignment_policy<
00858                 1, // xst_scalar capacity
00859                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00860                 primitive_id_unary_adaptor
00861             >
00862         > xst_adaptor_T;
00863 
00864         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
00865         return xst_adaptor_T(
00866             *this,
00867             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
00868             );
00869     }
00870 
00871 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:320
00887     template< typename StackValueT >
00888     xst_binary_adaptor<
00889         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00890         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
00891         xst_multiplication_assignment_policy<
00892             1, // xst_stack capacity
00893             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00894             primitive_id_unary_adaptor
00895         >
00896     >
00897     operator*= ( std::stack< StackValueT >* pstack_ )
00898     {
00899         typedef xst_binary_adaptor<
00900             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00901             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
00902             xst_multiplication_assignment_policy<
00903                 1, // xst_stack capacity
00904                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00905                 primitive_id_unary_adaptor
00906             >
00907         > xst_adaptor_T;
00908 
00909         return xst_adaptor_T(
00910             *this,
00911             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
00912             );
00913     }
00914 
00916 // Assignment *= operators end
00918 
00919 // generated by gmu/lambda/gmu_common.h:177
00921 // Assignment /= operators begin
00923 
00925 // Assignment /= abbreviations
00927 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:8
00942     template< typename RhsValueT >
00943     xst_binary_adaptor<
00944         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00945         xst_lambda_wrap< xst_scalar< RhsValueT > >,
00946         xst_division_assignment_policy<
00947             1, // xst_scalar capacity
00948             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00949             primitive_id_unary_adaptor
00950         >
00951     >
00952     operator/= ( RhsValueT const& value_ )
00953     {
00954         typedef xst_binary_adaptor<
00955             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00956             xst_lambda_wrap< xst_scalar< RhsValueT > >,
00957             xst_division_assignment_policy<
00958                 1, // xst_scalar capacity
00959                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00960                 primitive_id_unary_adaptor
00961             >
00962         > xst_adaptor_T;
00963 
00964         return xst_adaptor_T(
00965             *this,
00966             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
00967             );
00968     }
00969 
00970 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:51
00985     template< typename RhsValueT >
00986     xst_binary_adaptor<
00987         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00988         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
00989         xst_division_assignment_policy<
00990             1, // xst_scalar capacity
00991             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
00992             primitive_id_unary_adaptor
00993         >
00994     >
00995     operator/= ( RhsValueT* pvalue_ )
00996     {
00997         typedef xst_binary_adaptor<
00998             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
00999             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
01000             xst_division_assignment_policy<
01001                 1, // xst_scalar capacity
01002                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01003                 primitive_id_unary_adaptor
01004             >
01005         > xst_adaptor_T;
01006 
01007         return xst_adaptor_T(
01008             *this,
01009             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
01010             );
01011     }
01012 
01014 // Assignment /= specializations
01016 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:97
01031     template< typename LambdaT >
01032     xst_binary_adaptor<
01033         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01034         xst_lambda_wrap< typename LambdaT::reference_T >,
01035         xst_division_assignment_policy<
01036             LambdaT::capacity_,
01037             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01038             primitive_id_unary_adaptor
01039         >
01040     >
01041     operator/= ( xst_lambda_wrap< LambdaT > const& lambda_ )
01042     {
01043         typedef xst_binary_adaptor<
01044             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01045             xst_lambda_wrap< typename LambdaT::reference_T >,
01046             xst_division_assignment_policy<
01047                 LambdaT::capacity_,
01048                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01049                 primitive_id_unary_adaptor
01050             >
01051         > xst_adaptor_T;
01052 
01053         return xst_adaptor_T( *this, lambda_.make_reference() );
01054     }
01055 
01056 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:137
01072     template< typename LambdaT >
01073     xst_binary_adaptor<
01074         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01075         xst_unary_adaptor< LambdaT, PolicyAdaptorT >,
01076         xst_division_assignment_policy<
01077             xst_unary_adaptor< LambdaT, PolicyAdaptorT >::capacity_,
01078             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01079             primitive_id_unary_adaptor
01080         >
01081     >
01082     operator/= ( xst_unary_adaptor< LambdaT, PolicyAdaptorT > const& lambda_ )
01083     {
01084         typedef xst_binary_adaptor<
01085             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01086             xst_unary_adaptor< LambdaT, PolicyAdaptorT >,
01087             xst_division_assignment_policy<
01088                 xst_unary_adaptor< LambdaT, PolicyAdaptorT >::capacity_,
01089                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01090                 primitive_id_unary_adaptor
01091             >
01092         > xst_adaptor_T;
01093 
01094         return xst_adaptor_T( *this, lambda_ );
01095     }
01096 
01097 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:178
01117     template< typename LambdaT, typename OtherPolicyAdaptorT >
01118     xst_binary_adaptor<
01119         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01120         xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >,
01121         xst_division_assignment_policy<
01122             xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >::capacity_,
01123             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01124             primitive_id_unary_adaptor
01125         >
01126     >
01127     operator/= ( xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT > const& lambda_ )
01128     {
01129         typedef xst_binary_adaptor<
01130             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01131             xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >,
01132             xst_division_assignment_policy<
01133                 xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >::capacity_,
01134                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01135                 primitive_id_unary_adaptor
01136             >
01137         > xst_adaptor_T;
01138 
01139         return xst_adaptor_T( *this, lambda_ );
01140     }
01141 
01142 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:223
01166     template< typename LambdaLhsT, typename LambdaRhsT, typename BinaryPolicyAdaptorT >
01167     xst_binary_adaptor<
01168         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01169         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
01170         xst_division_assignment_policy<
01171             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
01172             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01173             primitive_id_unary_adaptor
01174         >
01175     >
01176     operator/= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const& lambda_ )
01177     {
01178         typedef xst_binary_adaptor<
01179             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01180             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
01181             xst_division_assignment_policy<
01182                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
01183                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01184                 primitive_id_unary_adaptor
01185             >
01186         > xst_adaptor_T;
01187 
01188         return xst_adaptor_T( *this, lambda_ );
01189     }
01190 
01192 // Assignment /= abbreviations
01194 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:275
01210     template< typename StackValueT >
01211     xst_binary_adaptor<
01212         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01213         xst_lambda_wrap< xst_scalar< StackValueT > >,
01214         xst_division_assignment_policy<
01215             1, // xst_scalar capacity
01216             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01217             primitive_id_unary_adaptor
01218         >
01219     >
01220     operator/= ( std::stack< StackValueT > const& stack_ )
01221     {
01222         typedef xst_binary_adaptor<
01223             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01224             xst_lambda_wrap< xst_scalar< StackValueT > >,
01225             xst_division_assignment_policy<
01226                 1, // xst_scalar capacity
01227                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01228                 primitive_id_unary_adaptor
01229             >
01230         > xst_adaptor_T;
01231 
01232         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
01233         return xst_adaptor_T(
01234             *this,
01235             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
01236             );
01237     }
01238 
01239 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:320
01255     template< typename StackValueT >
01256     xst_binary_adaptor<
01257         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01258         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
01259         xst_division_assignment_policy<
01260             1, // xst_stack capacity
01261             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01262             primitive_id_unary_adaptor
01263         >
01264     >
01265     operator/= ( std::stack< StackValueT >* pstack_ )
01266     {
01267         typedef xst_binary_adaptor<
01268             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01269             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
01270             xst_division_assignment_policy<
01271                 1, // xst_stack capacity
01272                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01273                 primitive_id_unary_adaptor
01274             >
01275         > xst_adaptor_T;
01276 
01277         return xst_adaptor_T(
01278             *this,
01279             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
01280             );
01281     }
01282 
01284 // Assignment /= operators end
01286 
01287 // generated by gmu/lambda/gmu_common.h:177
01289 // Assignment %= operators begin
01291 
01293 // Assignment %= abbreviations
01295 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:8
01310     template< typename RhsValueT >
01311     xst_binary_adaptor<
01312         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01313         xst_lambda_wrap< xst_scalar< RhsValueT > >,
01314         xst_modulus_assignment_policy<
01315             1, // xst_scalar capacity
01316             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01317             primitive_id_unary_adaptor
01318         >
01319     >
01320     operator%= ( RhsValueT const& value_ )
01321     {
01322         typedef xst_binary_adaptor<
01323             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01324             xst_lambda_wrap< xst_scalar< RhsValueT > >,
01325             xst_modulus_assignment_policy<
01326                 1, // xst_scalar capacity
01327                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01328                 primitive_id_unary_adaptor
01329             >
01330         > xst_adaptor_T;
01331 
01332         return xst_adaptor_T(
01333             *this,
01334             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
01335             );
01336     }
01337 
01338 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:51
01353     template< typename RhsValueT >
01354     xst_binary_adaptor<
01355         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01356         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
01357         xst_modulus_assignment_policy<
01358             1, // xst_scalar capacity
01359             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01360             primitive_id_unary_adaptor
01361         >
01362     >
01363     operator%= ( RhsValueT* pvalue_ )
01364     {
01365         typedef xst_binary_adaptor<
01366             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01367             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
01368             xst_modulus_assignment_policy<
01369                 1, // xst_scalar capacity
01370                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01371                 primitive_id_unary_adaptor
01372             >
01373         > xst_adaptor_T;
01374 
01375         return xst_adaptor_T(
01376             *this,
01377             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
01378             );
01379     }
01380 
01382 // Assignment %= specializations
01384 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:97
01399     template< typename LambdaT >
01400     xst_binary_adaptor<
01401         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01402         xst_lambda_wrap< typename LambdaT::reference_T >,
01403         xst_modulus_assignment_policy<
01404             LambdaT::capacity_,
01405             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01406             primitive_id_unary_adaptor
01407         >
01408     >
01409     operator%= ( xst_lambda_wrap< LambdaT > const& lambda_ )
01410     {
01411         typedef xst_binary_adaptor<
01412             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01413             xst_lambda_wrap< typename LambdaT::reference_T >,
01414             xst_modulus_assignment_policy<
01415                 LambdaT::capacity_,
01416                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01417                 primitive_id_unary_adaptor
01418             >
01419         > xst_adaptor_T;
01420 
01421         return xst_adaptor_T( *this, lambda_.make_reference() );
01422     }
01423 
01424 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:137
01440     template< typename LambdaT >
01441     xst_binary_adaptor<
01442         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01443         xst_unary_adaptor< LambdaT, PolicyAdaptorT >,
01444         xst_modulus_assignment_policy<
01445             xst_unary_adaptor< LambdaT, PolicyAdaptorT >::capacity_,
01446             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01447             primitive_id_unary_adaptor
01448         >
01449     >
01450     operator%= ( xst_unary_adaptor< LambdaT, PolicyAdaptorT > const& lambda_ )
01451     {
01452         typedef xst_binary_adaptor<
01453             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01454             xst_unary_adaptor< LambdaT, PolicyAdaptorT >,
01455             xst_modulus_assignment_policy<
01456                 xst_unary_adaptor< LambdaT, PolicyAdaptorT >::capacity_,
01457                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01458                 primitive_id_unary_adaptor
01459             >
01460         > xst_adaptor_T;
01461 
01462         return xst_adaptor_T( *this, lambda_ );
01463     }
01464 
01465 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:178
01485     template< typename LambdaT, typename OtherPolicyAdaptorT >
01486     xst_binary_adaptor<
01487         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01488         xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >,
01489         xst_modulus_assignment_policy<
01490             xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >::capacity_,
01491             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01492             primitive_id_unary_adaptor
01493         >
01494     >
01495     operator%= ( xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT > const& lambda_ )
01496     {
01497         typedef xst_binary_adaptor<
01498             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01499             xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >,
01500             xst_modulus_assignment_policy<
01501                 xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >::capacity_,
01502                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01503                 primitive_id_unary_adaptor
01504             >
01505         > xst_adaptor_T;
01506 
01507         return xst_adaptor_T( *this, lambda_ );
01508     }
01509 
01510 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:223
01534     template< typename LambdaLhsT, typename LambdaRhsT, typename BinaryPolicyAdaptorT >
01535     xst_binary_adaptor<
01536         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01537         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
01538         xst_modulus_assignment_policy<
01539             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
01540             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01541             primitive_id_unary_adaptor
01542         >
01543     >
01544     operator%= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const& lambda_ )
01545     {
01546         typedef xst_binary_adaptor<
01547             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01548             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
01549             xst_modulus_assignment_policy<
01550                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
01551                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01552                 primitive_id_unary_adaptor
01553             >
01554         > xst_adaptor_T;
01555 
01556         return xst_adaptor_T( *this, lambda_ );
01557     }
01558 
01560 // Assignment %= abbreviations
01562 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:275
01578     template< typename StackValueT >
01579     xst_binary_adaptor<
01580         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01581         xst_lambda_wrap< xst_scalar< StackValueT > >,
01582         xst_modulus_assignment_policy<
01583             1, // xst_scalar capacity
01584             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01585             primitive_id_unary_adaptor
01586         >
01587     >
01588     operator%= ( std::stack< StackValueT > const& stack_ )
01589     {
01590         typedef xst_binary_adaptor<
01591             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01592             xst_lambda_wrap< xst_scalar< StackValueT > >,
01593             xst_modulus_assignment_policy<
01594                 1, // xst_scalar capacity
01595                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01596                 primitive_id_unary_adaptor
01597             >
01598         > xst_adaptor_T;
01599 
01600         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
01601         return xst_adaptor_T(
01602             *this,
01603             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
01604             );
01605     }
01606 
01607 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:320
01623     template< typename StackValueT >
01624     xst_binary_adaptor<
01625         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01626         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
01627         xst_modulus_assignment_policy<
01628             1, // xst_stack capacity
01629             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01630             primitive_id_unary_adaptor
01631         >
01632     >
01633     operator%= ( std::stack< StackValueT >* pstack_ )
01634     {
01635         typedef xst_binary_adaptor<
01636             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01637             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
01638             xst_modulus_assignment_policy<
01639                 1, // xst_stack capacity
01640                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01641                 primitive_id_unary_adaptor
01642             >
01643         > xst_adaptor_T;
01644 
01645         return xst_adaptor_T(
01646             *this,
01647             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
01648             );
01649     }
01650 
01652 // Assignment %= operators end
01654 
01655 // generated by gmu/lambda/gmu_common.h:177
01657 // Assignment += operators begin
01659 
01661 // Assignment += abbreviations
01663 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:8
01678     template< typename RhsValueT >
01679     xst_binary_adaptor<
01680         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01681         xst_lambda_wrap< xst_scalar< RhsValueT > >,
01682         xst_addition_assignment_policy<
01683             1, // xst_scalar capacity
01684             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01685             primitive_id_unary_adaptor
01686         >
01687     >
01688     operator+= ( RhsValueT const& value_ )
01689     {
01690         typedef xst_binary_adaptor<
01691             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01692             xst_lambda_wrap< xst_scalar< RhsValueT > >,
01693             xst_addition_assignment_policy<
01694                 1, // xst_scalar capacity
01695                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01696                 primitive_id_unary_adaptor
01697             >
01698         > xst_adaptor_T;
01699 
01700         return xst_adaptor_T(
01701             *this,
01702             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
01703             );
01704     }
01705 
01706 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:51
01721     template< typename RhsValueT >
01722     xst_binary_adaptor<
01723         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01724         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
01725         xst_addition_assignment_policy<
01726             1, // xst_scalar capacity
01727             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01728             primitive_id_unary_adaptor
01729         >
01730     >
01731     operator+= ( RhsValueT* pvalue_ )
01732     {
01733         typedef xst_binary_adaptor<
01734             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01735             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
01736             xst_addition_assignment_policy<
01737                 1, // xst_scalar capacity
01738                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01739                 primitive_id_unary_adaptor
01740             >
01741         > xst_adaptor_T;
01742 
01743         return xst_adaptor_T(
01744             *this,
01745             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
01746             );
01747     }
01748 
01750 // Assignment += specializations
01752 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:97
01767     template< typename LambdaT >
01768     xst_binary_adaptor<
01769         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01770         xst_lambda_wrap< typename LambdaT::reference_T >,
01771         xst_addition_assignment_policy<
01772             LambdaT::capacity_,
01773             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01774             primitive_id_unary_adaptor
01775         >
01776     >
01777     operator+= ( xst_lambda_wrap< LambdaT > const& lambda_ )
01778     {
01779         typedef xst_binary_adaptor<
01780             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01781             xst_lambda_wrap< typename LambdaT::reference_T >,
01782             xst_addition_assignment_policy<
01783                 LambdaT::capacity_,
01784                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01785                 primitive_id_unary_adaptor
01786             >
01787         > xst_adaptor_T;
01788 
01789         return xst_adaptor_T( *this, lambda_.make_reference() );
01790     }
01791 
01792 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:137
01808     template< typename LambdaT >
01809     xst_binary_adaptor<
01810         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01811         xst_unary_adaptor< LambdaT, PolicyAdaptorT >,
01812         xst_addition_assignment_policy<
01813             xst_unary_adaptor< LambdaT, PolicyAdaptorT >::capacity_,
01814             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01815             primitive_id_unary_adaptor
01816         >
01817     >
01818     operator+= ( xst_unary_adaptor< LambdaT, PolicyAdaptorT > const& lambda_ )
01819     {
01820         typedef xst_binary_adaptor<
01821             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01822             xst_unary_adaptor< LambdaT, PolicyAdaptorT >,
01823             xst_addition_assignment_policy<
01824                 xst_unary_adaptor< LambdaT, PolicyAdaptorT >::capacity_,
01825                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01826                 primitive_id_unary_adaptor
01827             >
01828         > xst_adaptor_T;
01829 
01830         return xst_adaptor_T( *this, lambda_ );
01831     }
01832 
01833 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:178
01853     template< typename LambdaT, typename OtherPolicyAdaptorT >
01854     xst_binary_adaptor<
01855         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01856         xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >,
01857         xst_addition_assignment_policy<
01858             xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >::capacity_,
01859             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01860             primitive_id_unary_adaptor
01861         >
01862     >
01863     operator+= ( xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT > const& lambda_ )
01864     {
01865         typedef xst_binary_adaptor<
01866             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01867             xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >,
01868             xst_addition_assignment_policy<
01869                 xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >::capacity_,
01870                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01871                 primitive_id_unary_adaptor
01872             >
01873         > xst_adaptor_T;
01874 
01875         return xst_adaptor_T( *this, lambda_ );
01876     }
01877 
01878 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:223
01902     template< typename LambdaLhsT, typename LambdaRhsT, typename BinaryPolicyAdaptorT >
01903     xst_binary_adaptor<
01904         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01905         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
01906         xst_addition_assignment_policy<
01907             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
01908             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01909             primitive_id_unary_adaptor
01910         >
01911     >
01912     operator+= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const& lambda_ )
01913     {
01914         typedef xst_binary_adaptor<
01915             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01916             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
01917             xst_addition_assignment_policy<
01918                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
01919                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01920                 primitive_id_unary_adaptor
01921             >
01922         > xst_adaptor_T;
01923 
01924         return xst_adaptor_T( *this, lambda_ );
01925     }
01926 
01928 // Assignment += abbreviations
01930 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:275
01946     template< typename StackValueT >
01947     xst_binary_adaptor<
01948         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01949         xst_lambda_wrap< xst_scalar< StackValueT > >,
01950         xst_addition_assignment_policy<
01951             1, // xst_scalar capacity
01952             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01953             primitive_id_unary_adaptor
01954         >
01955     >
01956     operator+= ( std::stack< StackValueT > const& stack_ )
01957     {
01958         typedef xst_binary_adaptor<
01959             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01960             xst_lambda_wrap< xst_scalar< StackValueT > >,
01961             xst_addition_assignment_policy<
01962                 1, // xst_scalar capacity
01963                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01964                 primitive_id_unary_adaptor
01965             >
01966         > xst_adaptor_T;
01967 
01968         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
01969         return xst_adaptor_T(
01970             *this,
01971             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
01972             );
01973     }
01974 
01975 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:320
01991     template< typename StackValueT >
01992     xst_binary_adaptor<
01993         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
01994         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
01995         xst_addition_assignment_policy<
01996             1, // xst_stack capacity
01997             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
01998             primitive_id_unary_adaptor
01999         >
02000     >
02001     operator+= ( std::stack< StackValueT >* pstack_ )
02002     {
02003         typedef xst_binary_adaptor<
02004             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02005             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
02006             xst_addition_assignment_policy<
02007                 1, // xst_stack capacity
02008                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02009                 primitive_id_unary_adaptor
02010             >
02011         > xst_adaptor_T;
02012 
02013         return xst_adaptor_T(
02014             *this,
02015             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
02016             );
02017     }
02018 
02020 // Assignment += operators end
02022 
02023 // generated by gmu/lambda/gmu_common.h:177
02025 // Assignment -= operators begin
02027 
02029 // Assignment -= abbreviations
02031 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:8
02046     template< typename RhsValueT >
02047     xst_binary_adaptor<
02048         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02049         xst_lambda_wrap< xst_scalar< RhsValueT > >,
02050         xst_subtraction_assignment_policy<
02051             1, // xst_scalar capacity
02052             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02053             primitive_id_unary_adaptor
02054         >
02055     >
02056     operator-= ( RhsValueT const& value_ )
02057     {
02058         typedef xst_binary_adaptor<
02059             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02060             xst_lambda_wrap< xst_scalar< RhsValueT > >,
02061             xst_subtraction_assignment_policy<
02062                 1, // xst_scalar capacity
02063                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02064                 primitive_id_unary_adaptor
02065             >
02066         > xst_adaptor_T;
02067 
02068         return xst_adaptor_T(
02069             *this,
02070             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
02071             );
02072     }
02073 
02074 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:51
02089     template< typename RhsValueT >
02090     xst_binary_adaptor<
02091         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02092         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
02093         xst_subtraction_assignment_policy<
02094             1, // xst_scalar capacity
02095             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02096             primitive_id_unary_adaptor
02097         >
02098     >
02099     operator-= ( RhsValueT* pvalue_ )
02100     {
02101         typedef xst_binary_adaptor<
02102             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02103             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
02104             xst_subtraction_assignment_policy<
02105                 1, // xst_scalar capacity
02106                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02107                 primitive_id_unary_adaptor
02108             >
02109         > xst_adaptor_T;
02110 
02111         return xst_adaptor_T(
02112             *this,
02113             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
02114             );
02115     }
02116 
02118 // Assignment -= specializations
02120 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:97
02135     template< typename LambdaT >
02136     xst_binary_adaptor<
02137         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02138         xst_lambda_wrap< typename LambdaT::reference_T >,
02139         xst_subtraction_assignment_policy<
02140             LambdaT::capacity_,
02141             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02142             primitive_id_unary_adaptor
02143         >
02144     >
02145     operator-= ( xst_lambda_wrap< LambdaT > const& lambda_ )
02146     {
02147         typedef xst_binary_adaptor<
02148             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02149             xst_lambda_wrap< typename LambdaT::reference_T >,
02150             xst_subtraction_assignment_policy<
02151                 LambdaT::capacity_,
02152                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02153                 primitive_id_unary_adaptor
02154             >
02155         > xst_adaptor_T;
02156 
02157         return xst_adaptor_T( *this, lambda_.make_reference() );
02158     }
02159 
02160 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:137
02176     template< typename LambdaT >
02177     xst_binary_adaptor<
02178         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02179         xst_unary_adaptor< LambdaT, PolicyAdaptorT >,
02180         xst_subtraction_assignment_policy<
02181             xst_unary_adaptor< LambdaT, PolicyAdaptorT >::capacity_,
02182             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02183             primitive_id_unary_adaptor
02184         >
02185     >
02186     operator-= ( xst_unary_adaptor< LambdaT, PolicyAdaptorT > const& lambda_ )
02187     {
02188         typedef xst_binary_adaptor<
02189             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02190             xst_unary_adaptor< LambdaT, PolicyAdaptorT >,
02191             xst_subtraction_assignment_policy<
02192                 xst_unary_adaptor< LambdaT, PolicyAdaptorT >::capacity_,
02193                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02194                 primitive_id_unary_adaptor
02195             >
02196         > xst_adaptor_T;
02197 
02198         return xst_adaptor_T( *this, lambda_ );
02199     }
02200 
02201 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:178
02221     template< typename LambdaT, typename OtherPolicyAdaptorT >
02222     xst_binary_adaptor<
02223         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02224         xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >,
02225         xst_subtraction_assignment_policy<
02226             xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >::capacity_,
02227             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02228             primitive_id_unary_adaptor
02229         >
02230     >
02231     operator-= ( xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT > const& lambda_ )
02232     {
02233         typedef xst_binary_adaptor<
02234             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02235             xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >,
02236             xst_subtraction_assignment_policy<
02237                 xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >::capacity_,
02238                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02239                 primitive_id_unary_adaptor
02240             >
02241         > xst_adaptor_T;
02242 
02243         return xst_adaptor_T( *this, lambda_ );
02244     }
02245 
02246 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:223
02270     template< typename LambdaLhsT, typename LambdaRhsT, typename BinaryPolicyAdaptorT >
02271     xst_binary_adaptor<
02272         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02273         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
02274         xst_subtraction_assignment_policy<
02275             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
02276             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02277             primitive_id_unary_adaptor
02278         >
02279     >
02280     operator-= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const& lambda_ )
02281     {
02282         typedef xst_binary_adaptor<
02283             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02284             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
02285             xst_subtraction_assignment_policy<
02286                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
02287                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02288                 primitive_id_unary_adaptor
02289             >
02290         > xst_adaptor_T;
02291 
02292         return xst_adaptor_T( *this, lambda_ );
02293     }
02294 
02296 // Assignment -= abbreviations
02298 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:275
02314     template< typename StackValueT >
02315     xst_binary_adaptor<
02316         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02317         xst_lambda_wrap< xst_scalar< StackValueT > >,
02318         xst_subtraction_assignment_policy<
02319             1, // xst_scalar capacity
02320             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02321             primitive_id_unary_adaptor
02322         >
02323     >
02324     operator-= ( std::stack< StackValueT > const& stack_ )
02325     {
02326         typedef xst_binary_adaptor<
02327             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02328             xst_lambda_wrap< xst_scalar< StackValueT > >,
02329             xst_subtraction_assignment_policy<
02330                 1, // xst_scalar capacity
02331                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02332                 primitive_id_unary_adaptor
02333             >
02334         > xst_adaptor_T;
02335 
02336         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
02337         return xst_adaptor_T(
02338             *this,
02339             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
02340             );
02341     }
02342 
02343 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:320
02359     template< typename StackValueT >
02360     xst_binary_adaptor<
02361         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02362         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
02363         xst_subtraction_assignment_policy<
02364             1, // xst_stack capacity
02365             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02366             primitive_id_unary_adaptor
02367         >
02368     >
02369     operator-= ( std::stack< StackValueT >* pstack_ )
02370     {
02371         typedef xst_binary_adaptor<
02372             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02373             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
02374             xst_subtraction_assignment_policy<
02375                 1, // xst_stack capacity
02376                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02377                 primitive_id_unary_adaptor
02378             >
02379         > xst_adaptor_T;
02380 
02381         return xst_adaptor_T(
02382             *this,
02383             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
02384             );
02385     }
02386 
02388 // Assignment -= operators end
02390 
02391 // generated by gmu/lambda/gmu_common.h:177
02393 // Assignment <<= operators begin
02395 
02397 // Assignment <<= abbreviations
02399 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:8
02414     template< typename RhsValueT >
02415     xst_binary_adaptor<
02416         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02417         xst_lambda_wrap< xst_scalar< RhsValueT > >,
02418         xst_left_shift_assignment_policy<
02419             1, // xst_scalar capacity
02420             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02421             primitive_id_unary_adaptor
02422         >
02423     >
02424     operator<<= ( RhsValueT const& value_ )
02425     {
02426         typedef xst_binary_adaptor<
02427             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02428             xst_lambda_wrap< xst_scalar< RhsValueT > >,
02429             xst_left_shift_assignment_policy<
02430                 1, // xst_scalar capacity
02431                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02432                 primitive_id_unary_adaptor
02433             >
02434         > xst_adaptor_T;
02435 
02436         return xst_adaptor_T(
02437             *this,
02438             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
02439             );
02440     }
02441 
02442 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:51
02457     template< typename RhsValueT >
02458     xst_binary_adaptor<
02459         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02460         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
02461         xst_left_shift_assignment_policy<
02462             1, // xst_scalar capacity
02463             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02464             primitive_id_unary_adaptor
02465         >
02466     >
02467     operator<<= ( RhsValueT* pvalue_ )
02468     {
02469         typedef xst_binary_adaptor<
02470             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02471             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
02472             xst_left_shift_assignment_policy<
02473                 1, // xst_scalar capacity
02474                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02475                 primitive_id_unary_adaptor
02476             >
02477         > xst_adaptor_T;
02478 
02479         return xst_adaptor_T(
02480             *this,
02481             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
02482             );
02483     }
02484 
02486 // Assignment <<= specializations
02488 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:97
02503     template< typename LambdaT >
02504     xst_binary_adaptor<
02505         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02506         xst_lambda_wrap< typename LambdaT::reference_T >,
02507         xst_left_shift_assignment_policy<
02508             LambdaT::capacity_,
02509             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02510             primitive_id_unary_adaptor
02511         >
02512     >
02513     operator<<= ( xst_lambda_wrap< LambdaT > const& lambda_ )
02514     {
02515         typedef xst_binary_adaptor<
02516             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02517             xst_lambda_wrap< typename LambdaT::reference_T >,
02518             xst_left_shift_assignment_policy<
02519                 LambdaT::capacity_,
02520                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02521                 primitive_id_unary_adaptor
02522             >
02523         > xst_adaptor_T;
02524 
02525         return xst_adaptor_T( *this, lambda_.make_reference() );
02526     }
02527 
02528 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:137
02544     template< typename LambdaT >
02545     xst_binary_adaptor<
02546         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02547         xst_unary_adaptor< LambdaT, PolicyAdaptorT >,
02548         xst_left_shift_assignment_policy<
02549             xst_unary_adaptor< LambdaT, PolicyAdaptorT >::capacity_,
02550             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02551             primitive_id_unary_adaptor
02552         >
02553     >
02554     operator<<= ( xst_unary_adaptor< LambdaT, PolicyAdaptorT > const& lambda_ )
02555     {
02556         typedef xst_binary_adaptor<
02557             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02558             xst_unary_adaptor< LambdaT, PolicyAdaptorT >,
02559             xst_left_shift_assignment_policy<
02560                 xst_unary_adaptor< LambdaT, PolicyAdaptorT >::capacity_,
02561                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02562                 primitive_id_unary_adaptor
02563             >
02564         > xst_adaptor_T;
02565 
02566         return xst_adaptor_T( *this, lambda_ );
02567     }
02568 
02569 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:178
02589     template< typename LambdaT, typename OtherPolicyAdaptorT >
02590     xst_binary_adaptor<
02591         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02592         xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >,
02593         xst_left_shift_assignment_policy<
02594             xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >::capacity_,
02595             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02596             primitive_id_unary_adaptor
02597         >
02598     >
02599     operator<<= ( xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT > const& lambda_ )
02600     {
02601         typedef xst_binary_adaptor<
02602             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02603             xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >,
02604             xst_left_shift_assignment_policy<
02605                 xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >::capacity_,
02606                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02607                 primitive_id_unary_adaptor
02608             >
02609         > xst_adaptor_T;
02610 
02611         return xst_adaptor_T( *this, lambda_ );
02612     }
02613 
02614 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:223
02638     template< typename LambdaLhsT, typename LambdaRhsT, typename BinaryPolicyAdaptorT >
02639     xst_binary_adaptor<
02640         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02641         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
02642         xst_left_shift_assignment_policy<
02643             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
02644             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02645             primitive_id_unary_adaptor
02646         >
02647     >
02648     operator<<= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const& lambda_ )
02649     {
02650         typedef xst_binary_adaptor<
02651             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02652             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
02653             xst_left_shift_assignment_policy<
02654                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
02655                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02656                 primitive_id_unary_adaptor
02657             >
02658         > xst_adaptor_T;
02659 
02660         return xst_adaptor_T( *this, lambda_ );
02661     }
02662 
02664 // Assignment <<= abbreviations
02666 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:275
02682     template< typename StackValueT >
02683     xst_binary_adaptor<
02684         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02685         xst_lambda_wrap< xst_scalar< StackValueT > >,
02686         xst_left_shift_assignment_policy<
02687             1, // xst_scalar capacity
02688             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02689             primitive_id_unary_adaptor
02690         >
02691     >
02692     operator<<= ( std::stack< StackValueT > const& stack_ )
02693     {
02694         typedef xst_binary_adaptor<
02695             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02696             xst_lambda_wrap< xst_scalar< StackValueT > >,
02697             xst_left_shift_assignment_policy<
02698                 1, // xst_scalar capacity
02699                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02700                 primitive_id_unary_adaptor
02701             >
02702         > xst_adaptor_T;
02703 
02704         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
02705         return xst_adaptor_T(
02706             *this,
02707             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
02708             );
02709     }
02710 
02711 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:320
02727     template< typename StackValueT >
02728     xst_binary_adaptor<
02729         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02730         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
02731         xst_left_shift_assignment_policy<
02732             1, // xst_stack capacity
02733             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02734             primitive_id_unary_adaptor
02735         >
02736     >
02737     operator<<= ( std::stack< StackValueT >* pstack_ )
02738     {
02739         typedef xst_binary_adaptor<
02740             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02741             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
02742             xst_left_shift_assignment_policy<
02743                 1, // xst_stack capacity
02744                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02745                 primitive_id_unary_adaptor
02746             >
02747         > xst_adaptor_T;
02748 
02749         return xst_adaptor_T(
02750             *this,
02751             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
02752             );
02753     }
02754 
02756 // Assignment <<= operators end
02758 
02759 // generated by gmu/lambda/gmu_common.h:177
02761 // Assignment >>= operators begin
02763 
02765 // Assignment >>= abbreviations
02767 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:8
02782     template< typename RhsValueT >
02783     xst_binary_adaptor<
02784         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02785         xst_lambda_wrap< xst_scalar< RhsValueT > >,
02786         xst_right_shift_assignment_policy<
02787             1, // xst_scalar capacity
02788             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02789             primitive_id_unary_adaptor
02790         >
02791     >
02792     operator>>= ( RhsValueT const& value_ )
02793     {
02794         typedef xst_binary_adaptor<
02795             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02796             xst_lambda_wrap< xst_scalar< RhsValueT > >,
02797             xst_right_shift_assignment_policy<
02798                 1, // xst_scalar capacity
02799                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02800                 primitive_id_unary_adaptor
02801             >
02802         > xst_adaptor_T;
02803 
02804         return xst_adaptor_T(
02805             *this,
02806             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
02807             );
02808     }
02809 
02810 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:51
02825     template< typename RhsValueT >
02826     xst_binary_adaptor<
02827         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02828         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
02829         xst_right_shift_assignment_policy<
02830             1, // xst_scalar capacity
02831             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02832             primitive_id_unary_adaptor
02833         >
02834     >
02835     operator>>= ( RhsValueT* pvalue_ )
02836     {
02837         typedef xst_binary_adaptor<
02838             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02839             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
02840             xst_right_shift_assignment_policy<
02841                 1, // xst_scalar capacity
02842                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02843                 primitive_id_unary_adaptor
02844             >
02845         > xst_adaptor_T;
02846 
02847         return xst_adaptor_T(
02848             *this,
02849             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
02850             );
02851     }
02852 
02854 // Assignment >>= specializations
02856 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:97
02871     template< typename LambdaT >
02872     xst_binary_adaptor<
02873         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02874         xst_lambda_wrap< typename LambdaT::reference_T >,
02875         xst_right_shift_assignment_policy<
02876             LambdaT::capacity_,
02877             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02878             primitive_id_unary_adaptor
02879         >
02880     >
02881     operator>>= ( xst_lambda_wrap< LambdaT > const& lambda_ )
02882     {
02883         typedef xst_binary_adaptor<
02884             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02885             xst_lambda_wrap< typename LambdaT::reference_T >,
02886             xst_right_shift_assignment_policy<
02887                 LambdaT::capacity_,
02888                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02889                 primitive_id_unary_adaptor
02890             >
02891         > xst_adaptor_T;
02892 
02893         return xst_adaptor_T( *this, lambda_.make_reference() );
02894     }
02895 
02896 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:137
02912     template< typename LambdaT >
02913     xst_binary_adaptor<
02914         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02915         xst_unary_adaptor< LambdaT, PolicyAdaptorT >,
02916         xst_right_shift_assignment_policy<
02917             xst_unary_adaptor< LambdaT, PolicyAdaptorT >::capacity_,
02918             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02919             primitive_id_unary_adaptor
02920         >
02921     >
02922     operator>>= ( xst_unary_adaptor< LambdaT, PolicyAdaptorT > const& lambda_ )
02923     {
02924         typedef xst_binary_adaptor<
02925             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02926             xst_unary_adaptor< LambdaT, PolicyAdaptorT >,
02927             xst_right_shift_assignment_policy<
02928                 xst_unary_adaptor< LambdaT, PolicyAdaptorT >::capacity_,
02929                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02930                 primitive_id_unary_adaptor
02931             >
02932         > xst_adaptor_T;
02933 
02934         return xst_adaptor_T( *this, lambda_ );
02935     }
02936 
02937 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:178
02957     template< typename LambdaT, typename OtherPolicyAdaptorT >
02958     xst_binary_adaptor<
02959         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02960         xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >,
02961         xst_right_shift_assignment_policy<
02962             xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >::capacity_,
02963             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02964             primitive_id_unary_adaptor
02965         >
02966     >
02967     operator>>= ( xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT > const& lambda_ )
02968     {
02969         typedef xst_binary_adaptor<
02970             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
02971             xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >,
02972             xst_right_shift_assignment_policy<
02973                 xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >::capacity_,
02974                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
02975                 primitive_id_unary_adaptor
02976             >
02977         > xst_adaptor_T;
02978 
02979         return xst_adaptor_T( *this, lambda_ );
02980     }
02981 
02982 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:223
03006     template< typename LambdaLhsT, typename LambdaRhsT, typename BinaryPolicyAdaptorT >
03007     xst_binary_adaptor<
03008         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03009         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
03010         xst_right_shift_assignment_policy<
03011             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
03012             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03013             primitive_id_unary_adaptor
03014         >
03015     >
03016     operator>>= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const& lambda_ )
03017     {
03018         typedef xst_binary_adaptor<
03019             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03020             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
03021             xst_right_shift_assignment_policy<
03022                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
03023                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03024                 primitive_id_unary_adaptor
03025             >
03026         > xst_adaptor_T;
03027 
03028         return xst_adaptor_T( *this, lambda_ );
03029     }
03030 
03032 // Assignment >>= abbreviations
03034 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:275
03050     template< typename StackValueT >
03051     xst_binary_adaptor<
03052         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03053         xst_lambda_wrap< xst_scalar< StackValueT > >,
03054         xst_right_shift_assignment_policy<
03055             1, // xst_scalar capacity
03056             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03057             primitive_id_unary_adaptor
03058         >
03059     >
03060     operator>>= ( std::stack< StackValueT > const& stack_ )
03061     {
03062         typedef xst_binary_adaptor<
03063             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03064             xst_lambda_wrap< xst_scalar< StackValueT > >,
03065             xst_right_shift_assignment_policy<
03066                 1, // xst_scalar capacity
03067                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03068                 primitive_id_unary_adaptor
03069             >
03070         > xst_adaptor_T;
03071 
03072         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
03073         return xst_adaptor_T(
03074             *this,
03075             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
03076             );
03077     }
03078 
03079 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:320
03095     template< typename StackValueT >
03096     xst_binary_adaptor<
03097         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03098         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
03099         xst_right_shift_assignment_policy<
03100             1, // xst_stack capacity
03101             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03102             primitive_id_unary_adaptor
03103         >
03104     >
03105     operator>>= ( std::stack< StackValueT >* pstack_ )
03106     {
03107         typedef xst_binary_adaptor<
03108             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03109             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
03110             xst_right_shift_assignment_policy<
03111                 1, // xst_stack capacity
03112                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03113                 primitive_id_unary_adaptor
03114             >
03115         > xst_adaptor_T;
03116 
03117         return xst_adaptor_T(
03118             *this,
03119             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
03120             );
03121     }
03122 
03124 // Assignment >>= operators end
03126 
03127 // generated by gmu/lambda/gmu_common.h:177
03129 // Assignment &= operators begin
03131 
03133 // Assignment &= abbreviations
03135 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:8
03150     template< typename RhsValueT >
03151     xst_binary_adaptor<
03152         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03153         xst_lambda_wrap< xst_scalar< RhsValueT > >,
03154         xst_bitwise_and_assignment_policy<
03155             1, // xst_scalar capacity
03156             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03157             primitive_id_unary_adaptor
03158         >
03159     >
03160     operator&= ( RhsValueT const& value_ )
03161     {
03162         typedef xst_binary_adaptor<
03163             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03164             xst_lambda_wrap< xst_scalar< RhsValueT > >,
03165             xst_bitwise_and_assignment_policy<
03166                 1, // xst_scalar capacity
03167                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03168                 primitive_id_unary_adaptor
03169             >
03170         > xst_adaptor_T;
03171 
03172         return xst_adaptor_T(
03173             *this,
03174             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
03175             );
03176     }
03177 
03178 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:51
03193     template< typename RhsValueT >
03194     xst_binary_adaptor<
03195         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03196         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
03197         xst_bitwise_and_assignment_policy<
03198             1, // xst_scalar capacity
03199             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03200             primitive_id_unary_adaptor
03201         >
03202     >
03203     operator&= ( RhsValueT* pvalue_ )
03204     {
03205         typedef xst_binary_adaptor<
03206             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03207             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
03208             xst_bitwise_and_assignment_policy<
03209                 1, // xst_scalar capacity
03210                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03211                 primitive_id_unary_adaptor
03212             >
03213         > xst_adaptor_T;
03214 
03215         return xst_adaptor_T(
03216             *this,
03217             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
03218             );
03219     }
03220 
03222 // Assignment &= specializations
03224 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:97
03239     template< typename LambdaT >
03240     xst_binary_adaptor<
03241         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03242         xst_lambda_wrap< typename LambdaT::reference_T >,
03243         xst_bitwise_and_assignment_policy<
03244             LambdaT::capacity_,
03245             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03246             primitive_id_unary_adaptor
03247         >
03248     >
03249     operator&= ( xst_lambda_wrap< LambdaT > const& lambda_ )
03250     {
03251         typedef xst_binary_adaptor<
03252             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03253             xst_lambda_wrap< typename LambdaT::reference_T >,
03254             xst_bitwise_and_assignment_policy<
03255                 LambdaT::capacity_,
03256                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03257                 primitive_id_unary_adaptor
03258             >
03259         > xst_adaptor_T;
03260 
03261         return xst_adaptor_T( *this, lambda_.make_reference() );
03262     }
03263 
03264 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:137
03280     template< typename LambdaT >
03281     xst_binary_adaptor<
03282         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03283         xst_unary_adaptor< LambdaT, PolicyAdaptorT >,
03284         xst_bitwise_and_assignment_policy<
03285             xst_unary_adaptor< LambdaT, PolicyAdaptorT >::capacity_,
03286             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03287             primitive_id_unary_adaptor
03288         >
03289     >
03290     operator&= ( xst_unary_adaptor< LambdaT, PolicyAdaptorT > const& lambda_ )
03291     {
03292         typedef xst_binary_adaptor<
03293             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03294             xst_unary_adaptor< LambdaT, PolicyAdaptorT >,
03295             xst_bitwise_and_assignment_policy<
03296                 xst_unary_adaptor< LambdaT, PolicyAdaptorT >::capacity_,
03297                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03298                 primitive_id_unary_adaptor
03299             >
03300         > xst_adaptor_T;
03301 
03302         return xst_adaptor_T( *this, lambda_ );
03303     }
03304 
03305 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:178
03325     template< typename LambdaT, typename OtherPolicyAdaptorT >
03326     xst_binary_adaptor<
03327         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03328         xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >,
03329         xst_bitwise_and_assignment_policy<
03330             xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >::capacity_,
03331             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03332             primitive_id_unary_adaptor
03333         >
03334     >
03335     operator&= ( xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT > const& lambda_ )
03336     {
03337         typedef xst_binary_adaptor<
03338             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03339             xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >,
03340             xst_bitwise_and_assignment_policy<
03341                 xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >::capacity_,
03342                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03343                 primitive_id_unary_adaptor
03344             >
03345         > xst_adaptor_T;
03346 
03347         return xst_adaptor_T( *this, lambda_ );
03348     }
03349 
03350 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:223
03374     template< typename LambdaLhsT, typename LambdaRhsT, typename BinaryPolicyAdaptorT >
03375     xst_binary_adaptor<
03376         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03377         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
03378         xst_bitwise_and_assignment_policy<
03379             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
03380             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03381             primitive_id_unary_adaptor
03382         >
03383     >
03384     operator&= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const& lambda_ )
03385     {
03386         typedef xst_binary_adaptor<
03387             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03388             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
03389             xst_bitwise_and_assignment_policy<
03390                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
03391                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03392                 primitive_id_unary_adaptor
03393             >
03394         > xst_adaptor_T;
03395 
03396         return xst_adaptor_T( *this, lambda_ );
03397     }
03398 
03400 // Assignment &= abbreviations
03402 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:275
03418     template< typename StackValueT >
03419     xst_binary_adaptor<
03420         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03421         xst_lambda_wrap< xst_scalar< StackValueT > >,
03422         xst_bitwise_and_assignment_policy<
03423             1, // xst_scalar capacity
03424             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03425             primitive_id_unary_adaptor
03426         >
03427     >
03428     operator&= ( std::stack< StackValueT > const& stack_ )
03429     {
03430         typedef xst_binary_adaptor<
03431             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03432             xst_lambda_wrap< xst_scalar< StackValueT > >,
03433             xst_bitwise_and_assignment_policy<
03434                 1, // xst_scalar capacity
03435                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03436                 primitive_id_unary_adaptor
03437             >
03438         > xst_adaptor_T;
03439 
03440         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
03441         return xst_adaptor_T(
03442             *this,
03443             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
03444             );
03445     }
03446 
03447 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:320
03463     template< typename StackValueT >
03464     xst_binary_adaptor<
03465         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03466         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
03467         xst_bitwise_and_assignment_policy<
03468             1, // xst_stack capacity
03469             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03470             primitive_id_unary_adaptor
03471         >
03472     >
03473     operator&= ( std::stack< StackValueT >* pstack_ )
03474     {
03475         typedef xst_binary_adaptor<
03476             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03477             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
03478             xst_bitwise_and_assignment_policy<
03479                 1, // xst_stack capacity
03480                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03481                 primitive_id_unary_adaptor
03482             >
03483         > xst_adaptor_T;
03484 
03485         return xst_adaptor_T(
03486             *this,
03487             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
03488             );
03489     }
03490 
03492 // Assignment &= operators end
03494 
03495 // generated by gmu/lambda/gmu_common.h:177
03497 // Assignment |= operators begin
03499 
03501 // Assignment |= abbreviations
03503 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:8
03518     template< typename RhsValueT >
03519     xst_binary_adaptor<
03520         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03521         xst_lambda_wrap< xst_scalar< RhsValueT > >,
03522         xst_bitwise_ior_assignment_policy<
03523             1, // xst_scalar capacity
03524             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03525             primitive_id_unary_adaptor
03526         >
03527     >
03528     operator|= ( RhsValueT const& value_ )
03529     {
03530         typedef xst_binary_adaptor<
03531             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03532             xst_lambda_wrap< xst_scalar< RhsValueT > >,
03533             xst_bitwise_ior_assignment_policy<
03534                 1, // xst_scalar capacity
03535                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03536                 primitive_id_unary_adaptor
03537             >
03538         > xst_adaptor_T;
03539 
03540         return xst_adaptor_T(
03541             *this,
03542             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
03543             );
03544     }
03545 
03546 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:51
03561     template< typename RhsValueT >
03562     xst_binary_adaptor<
03563         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03564         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
03565         xst_bitwise_ior_assignment_policy<
03566             1, // xst_scalar capacity
03567             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03568             primitive_id_unary_adaptor
03569         >
03570     >
03571     operator|= ( RhsValueT* pvalue_ )
03572     {
03573         typedef xst_binary_adaptor<
03574             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03575             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
03576             xst_bitwise_ior_assignment_policy<
03577                 1, // xst_scalar capacity
03578                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03579                 primitive_id_unary_adaptor
03580             >
03581         > xst_adaptor_T;
03582 
03583         return xst_adaptor_T(
03584             *this,
03585             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
03586             );
03587     }
03588 
03590 // Assignment |= specializations
03592 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:97
03607     template< typename LambdaT >
03608     xst_binary_adaptor<
03609         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03610         xst_lambda_wrap< typename LambdaT::reference_T >,
03611         xst_bitwise_ior_assignment_policy<
03612             LambdaT::capacity_,
03613             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03614             primitive_id_unary_adaptor
03615         >
03616     >
03617     operator|= ( xst_lambda_wrap< LambdaT > const& lambda_ )
03618     {
03619         typedef xst_binary_adaptor<
03620             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03621             xst_lambda_wrap< typename LambdaT::reference_T >,
03622             xst_bitwise_ior_assignment_policy<
03623                 LambdaT::capacity_,
03624                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03625                 primitive_id_unary_adaptor
03626             >
03627         > xst_adaptor_T;
03628 
03629         return xst_adaptor_T( *this, lambda_.make_reference() );
03630     }
03631 
03632 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:137
03648     template< typename LambdaT >
03649     xst_binary_adaptor<
03650         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03651         xst_unary_adaptor< LambdaT, PolicyAdaptorT >,
03652         xst_bitwise_ior_assignment_policy<
03653             xst_unary_adaptor< LambdaT, PolicyAdaptorT >::capacity_,
03654             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03655             primitive_id_unary_adaptor
03656         >
03657     >
03658     operator|= ( xst_unary_adaptor< LambdaT, PolicyAdaptorT > const& lambda_ )
03659     {
03660         typedef xst_binary_adaptor<
03661             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03662             xst_unary_adaptor< LambdaT, PolicyAdaptorT >,
03663             xst_bitwise_ior_assignment_policy<
03664                 xst_unary_adaptor< LambdaT, PolicyAdaptorT >::capacity_,
03665                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03666                 primitive_id_unary_adaptor
03667             >
03668         > xst_adaptor_T;
03669 
03670         return xst_adaptor_T( *this, lambda_ );
03671     }
03672 
03673 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:178
03693     template< typename LambdaT, typename OtherPolicyAdaptorT >
03694     xst_binary_adaptor<
03695         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03696         xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >,
03697         xst_bitwise_ior_assignment_policy<
03698             xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >::capacity_,
03699             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03700             primitive_id_unary_adaptor
03701         >
03702     >
03703     operator|= ( xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT > const& lambda_ )
03704     {
03705         typedef xst_binary_adaptor<
03706             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03707             xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >,
03708             xst_bitwise_ior_assignment_policy<
03709                 xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >::capacity_,
03710                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03711                 primitive_id_unary_adaptor
03712             >
03713         > xst_adaptor_T;
03714 
03715         return xst_adaptor_T( *this, lambda_ );
03716     }
03717 
03718 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:223
03742     template< typename LambdaLhsT, typename LambdaRhsT, typename BinaryPolicyAdaptorT >
03743     xst_binary_adaptor<
03744         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03745         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
03746         xst_bitwise_ior_assignment_policy<
03747             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
03748             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03749             primitive_id_unary_adaptor
03750         >
03751     >
03752     operator|= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const& lambda_ )
03753     {
03754         typedef xst_binary_adaptor<
03755             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03756             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
03757             xst_bitwise_ior_assignment_policy<
03758                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
03759                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03760                 primitive_id_unary_adaptor
03761             >
03762         > xst_adaptor_T;
03763 
03764         return xst_adaptor_T( *this, lambda_ );
03765     }
03766 
03768 // Assignment |= abbreviations
03770 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:275
03786     template< typename StackValueT >
03787     xst_binary_adaptor<
03788         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03789         xst_lambda_wrap< xst_scalar< StackValueT > >,
03790         xst_bitwise_ior_assignment_policy<
03791             1, // xst_scalar capacity
03792             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03793             primitive_id_unary_adaptor
03794         >
03795     >
03796     operator|= ( std::stack< StackValueT > const& stack_ )
03797     {
03798         typedef xst_binary_adaptor<
03799             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03800             xst_lambda_wrap< xst_scalar< StackValueT > >,
03801             xst_bitwise_ior_assignment_policy<
03802                 1, // xst_scalar capacity
03803                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03804                 primitive_id_unary_adaptor
03805             >
03806         > xst_adaptor_T;
03807 
03808         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
03809         return xst_adaptor_T(
03810             *this,
03811             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
03812             );
03813     }
03814 
03815 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:320
03831     template< typename StackValueT >
03832     xst_binary_adaptor<
03833         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03834         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
03835         xst_bitwise_ior_assignment_policy<
03836             1, // xst_stack capacity
03837             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03838             primitive_id_unary_adaptor
03839         >
03840     >
03841     operator|= ( std::stack< StackValueT >* pstack_ )
03842     {
03843         typedef xst_binary_adaptor<
03844             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03845             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
03846             xst_bitwise_ior_assignment_policy<
03847                 1, // xst_stack capacity
03848                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03849                 primitive_id_unary_adaptor
03850             >
03851         > xst_adaptor_T;
03852 
03853         return xst_adaptor_T(
03854             *this,
03855             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
03856             );
03857     }
03858 
03860 // Assignment |= operators end
03862 
03863 // generated by gmu/lambda/gmu_common.h:177
03865 // Assignment ^= operators begin
03867 
03869 // Assignment ^= abbreviations
03871 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:8
03886     template< typename RhsValueT >
03887     xst_binary_adaptor<
03888         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03889         xst_lambda_wrap< xst_scalar< RhsValueT > >,
03890         xst_bitwise_xor_assignment_policy<
03891             1, // xst_scalar capacity
03892             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03893             primitive_id_unary_adaptor
03894         >
03895     >
03896     operator^= ( RhsValueT const& value_ )
03897     {
03898         typedef xst_binary_adaptor<
03899             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03900             xst_lambda_wrap< xst_scalar< RhsValueT > >,
03901             xst_bitwise_xor_assignment_policy<
03902                 1, // xst_scalar capacity
03903                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03904                 primitive_id_unary_adaptor
03905             >
03906         > xst_adaptor_T;
03907 
03908         return xst_adaptor_T(
03909             *this,
03910             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
03911             );
03912     }
03913 
03914 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:51
03929     template< typename RhsValueT >
03930     xst_binary_adaptor<
03931         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03932         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
03933         xst_bitwise_xor_assignment_policy<
03934             1, // xst_scalar capacity
03935             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03936             primitive_id_unary_adaptor
03937         >
03938     >
03939     operator^= ( RhsValueT* pvalue_ )
03940     {
03941         typedef xst_binary_adaptor<
03942             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03943             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
03944             xst_bitwise_xor_assignment_policy<
03945                 1, // xst_scalar capacity
03946                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03947                 primitive_id_unary_adaptor
03948             >
03949         > xst_adaptor_T;
03950 
03951         return xst_adaptor_T(
03952             *this,
03953             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
03954             );
03955     }
03956 
03958 // Assignment ^= specializations
03960 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:97
03975     template< typename LambdaT >
03976     xst_binary_adaptor<
03977         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03978         xst_lambda_wrap< typename LambdaT::reference_T >,
03979         xst_bitwise_xor_assignment_policy<
03980             LambdaT::capacity_,
03981             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03982             primitive_id_unary_adaptor
03983         >
03984     >
03985     operator^= ( xst_lambda_wrap< LambdaT > const& lambda_ )
03986     {
03987         typedef xst_binary_adaptor<
03988             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
03989             xst_lambda_wrap< typename LambdaT::reference_T >,
03990             xst_bitwise_xor_assignment_policy<
03991                 LambdaT::capacity_,
03992                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
03993                 primitive_id_unary_adaptor
03994             >
03995         > xst_adaptor_T;
03996 
03997         return xst_adaptor_T( *this, lambda_.make_reference() );
03998     }
03999 
04000 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:137
04016     template< typename LambdaT >
04017     xst_binary_adaptor<
04018         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
04019         xst_unary_adaptor< LambdaT, PolicyAdaptorT >,
04020         xst_bitwise_xor_assignment_policy<
04021             xst_unary_adaptor< LambdaT, PolicyAdaptorT >::capacity_,
04022             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
04023             primitive_id_unary_adaptor
04024         >
04025     >
04026     operator^= ( xst_unary_adaptor< LambdaT, PolicyAdaptorT > const& lambda_ )
04027     {
04028         typedef xst_binary_adaptor<
04029             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
04030             xst_unary_adaptor< LambdaT, PolicyAdaptorT >,
04031             xst_bitwise_xor_assignment_policy<
04032                 xst_unary_adaptor< LambdaT, PolicyAdaptorT >::capacity_,
04033                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
04034                 primitive_id_unary_adaptor
04035             >
04036         > xst_adaptor_T;
04037 
04038         return xst_adaptor_T( *this, lambda_ );
04039     }
04040 
04041 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:178
04061     template< typename LambdaT, typename OtherPolicyAdaptorT >
04062     xst_binary_adaptor<
04063         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
04064         xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >,
04065         xst_bitwise_xor_assignment_policy<
04066             xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >::capacity_,
04067             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
04068             primitive_id_unary_adaptor
04069         >
04070     >
04071     operator^= ( xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT > const& lambda_ )
04072     {
04073         typedef xst_binary_adaptor<
04074             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
04075             xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >,
04076             xst_bitwise_xor_assignment_policy<
04077                 xst_unary_adaptor< LambdaT, OtherPolicyAdaptorT >::capacity_,
04078                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
04079                 primitive_id_unary_adaptor
04080             >
04081         > xst_adaptor_T;
04082 
04083         return xst_adaptor_T( *this, lambda_ );
04084     }
04085 
04086 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:223
04110     template< typename LambdaLhsT, typename LambdaRhsT, typename BinaryPolicyAdaptorT >
04111     xst_binary_adaptor<
04112         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
04113         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
04114         xst_bitwise_xor_assignment_policy<
04115             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
04116             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
04117             primitive_id_unary_adaptor
04118         >
04119     >
04120     operator^= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT > const& lambda_ )
04121     {
04122         typedef xst_binary_adaptor<
04123             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
04124             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >,
04125             xst_bitwise_xor_assignment_policy<
04126                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, BinaryPolicyAdaptorT >::capacity_,
04127                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
04128                 primitive_id_unary_adaptor
04129             >
04130         > xst_adaptor_T;
04131 
04132         return xst_adaptor_T( *this, lambda_ );
04133     }
04134 
04136 // Assignment ^= abbreviations
04138 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:275
04154     template< typename StackValueT >
04155     xst_binary_adaptor<
04156         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
04157         xst_lambda_wrap< xst_scalar< StackValueT > >,
04158         xst_bitwise_xor_assignment_policy<
04159             1, // xst_scalar capacity
04160             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
04161             primitive_id_unary_adaptor
04162         >
04163     >
04164     operator^= ( std::stack< StackValueT > const& stack_ )
04165     {
04166         typedef xst_binary_adaptor<
04167             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
04168             xst_lambda_wrap< xst_scalar< StackValueT > >,
04169             xst_bitwise_xor_assignment_policy<
04170                 1, // xst_scalar capacity
04171                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
04172                 primitive_id_unary_adaptor
04173             >
04174         > xst_adaptor_T;
04175 
04176         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
04177         return xst_adaptor_T(
04178             *this,
04179             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
04180             );
04181     }
04182 
04183 // generated by gmu/lambda/operators/assign/unary_adaptor_assign_funcs.h:320
04199     template< typename StackValueT >
04200     xst_binary_adaptor<
04201         xst_unary_adaptor< ExprT, PolicyAdaptorT >,
04202         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
04203         xst_bitwise_xor_assignment_policy<
04204             1, // xst_stack capacity
04205             xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
04206             primitive_id_unary_adaptor
04207         >
04208     >
04209     operator^= ( std::stack< StackValueT >* pstack_ )
04210     {
04211         typedef xst_binary_adaptor<
04212             xst_unary_adaptor< ExprT, PolicyAdaptorT >,
04213             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
04214             xst_bitwise_xor_assignment_policy<
04215                 1, // xst_stack capacity
04216                 xst_unary_adaptor< ExprT, PolicyAdaptorT >::capacity_,
04217                 primitive_id_unary_adaptor
04218             >
04219         > xst_adaptor_T;
04220 
04221         return xst_adaptor_T(
04222             *this,
04223             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
04224             );
04225     }
04226 
04228 // Assignment ^= operators end
04230 
04231 //end_generated_code
04232 
04233 };  // xst_unary_adaptor
04234 
04235 
04236 }   // namespace cttl_impl
04237 
04238 
04239 #endif //_XST_UNARY_ADAPTOR_H_INCLUDED_
Generated on Thu Nov 2 17:48:25 2006 for CTTL Lambda Expression by  doxygen 1.3.9.1