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

xst_base.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_base.h
00034 
00035 #ifndef _XST_BASE_H_INCLUDED_
00036 #define _XST_BASE_H_INCLUDED_
00037 
00039 #define const_scalar( T ) cttl_impl::xst_lambda_wrap< cttl_impl::xst_const_scalar< T > >( cttl_impl::xst_const_scalar< T >() )
00040 
00041 namespace cttl_impl {
00042 
00043 // Note: assuming all assignment adaptors already forward declared earlier.
00044 
00045 // forward declare subscript policy:
00046 template< int RhsCapacityT, int LhsCapacityT, int PrimitiveIdT > struct xst_subscript_policy;
00047 
00048 // forward declare constant scalar primitive required by stack interface:
00049 template< int ValueT > struct xst_const_scalar;
00050 
00058 template< typename LambdaT >
00059 struct xst_lambda_wrap {
00060 
00061     // allow implementation of lambda compound to access implementation of any lambda primitive
00062     template< typename L, typename R > friend struct xst_pair;
00063 
00064     // allow translators to access implementation of any lambda primitive
00065     template< typename D, typename T > friend struct xst_translator;
00066 
00068     typedef LambdaT lambda_T;
00069 
00071     typedef typename LambdaT::value_T value_T;
00072 
00074     typedef typename LambdaT::dereferenced_value_T dereferenced_value_T;
00075 
00077     typedef typename LambdaT::left_T left_T;
00078 
00080     typedef typename LambdaT::right_T right_T;
00081 
00083     typedef xst_lambda_wrap< typename LambdaT::reference_T > reference_T;
00084 
00085     enum {
00087         const_value_ = LambdaT::const_value_,
00088 
00090         depth_ = LambdaT::depth_,
00091 
00093         capacity_ = LambdaT::capacity_,
00094 
00096         primitive_id_ = LambdaT::primitive_id_
00097     };
00098 
00100     xst_lambda_wrap()
00101     :
00102     m_lambda( LambdaT() )
00103     {
00104     }
00105 
00107     template< typename GenericT >
00108     xst_lambda_wrap( GenericT const& x_ )
00109     :
00110     m_lambda( LambdaT( x_ ) )
00111     {
00112     }
00113 
00115     template< typename GenericT >
00116     xst_lambda_wrap( GenericT* p_ )
00117     :
00118     m_lambda( LambdaT( *p_ ) )
00119     {
00120     }
00121 
00123     xst_lambda_wrap( xst_lambda_wrap< LambdaT > const& other_ )
00124     : m_lambda( other_.m_lambda )
00125     {
00126     }
00127 
00129     reference_T make_reference() const
00130     {
00131         return reference_T( m_lambda.make_reference() );
00132     }
00133 
00135     template< typename SubscriptLambdaT >
00136     dereferenced_value_T& dereferenced_value( xst_lambda_wrap< SubscriptLambdaT > subscript_ )
00137     {
00138         return m_lambda.dereferenced_value( subscript_ );
00139     }
00140 
00142     dereferenced_value_T& dereferenced_value()
00143     {
00144         return dereferenced_value( const_scalar( 0 ) );
00145     }
00146 
00148     left_T& left_lambda()
00149     {
00150         return m_lambda.left_lambda();
00151     }
00152 
00154     left_T const& left_lambda() const
00155     {
00156         return m_lambda.left_lambda();
00157     }
00158 
00160     right_T& right_lambda()
00161     {
00162         return m_lambda.right_lambda();
00163     }
00164 
00166     right_T const& right_lambda() const
00167     {
00168         return m_lambda.right_lambda();
00169     }
00170 
00172     // lambda compound traversal algorithms
00174 
00176     template< typename FunctorT >
00177     void traverse_bottom_up( FunctorT& functor_ )
00178     {
00179         m_lambda.traverse_bottom_up( functor_ );
00180     }
00181     
00183     template< typename FunctorT >
00184     void traverse_top_down( FunctorT& functor_ )
00185     {
00186         m_lambda.traverse_top_down( functor_ );
00187     }
00188     
00190     template< typename FunctorT >
00191     void traverse_bottom_up( FunctorT& functor_ ) const
00192     {
00193         m_lambda.traverse_bottom_up( functor_ );
00194     }
00195     
00197     template< typename FunctorT >
00198     void traverse_top_down( FunctorT& functor_ ) const
00199     {
00200         m_lambda.traverse_top_down( functor_ );
00201     }
00202     
00204     template< typename FunctorT >
00205     void subscript_top_down( FunctorT& functor_ ) const
00206     {
00207         m_lambda.subscript_top_down( functor_ );
00208     }
00209 
00211     template< typename FunctorT >
00212     void subscript_bottom_up( FunctorT& functor_ ) const
00213     {
00214         m_lambda.subscript_bottom_up( functor_ );
00215     }
00216 
00218     // Lambda primitive stack interface support
00220 
00222     template< typename SubscriptLambdaT, typename InputValueT >
00223     void push( xst_lambda_wrap< SubscriptLambdaT > subscript_, InputValueT const& data_ )
00224     {
00225         m_lambda.push( subscript_, data_ );
00226     }
00227 
00229     template< typename InputValueT >
00230     void push( InputValueT const& data_ )
00231     {
00232         push( const_scalar( 0 ), data_ );
00233     }
00234 
00236     template< typename SubscriptLambdaT >
00237     void pop( xst_lambda_wrap< SubscriptLambdaT > subscript_ )
00238     {
00239         m_lambda.pop( subscript_ );
00240     }
00241 
00243     void pop()
00244     {
00245         pop( const_scalar( 0 ) );
00246     }
00247 
00249     template< typename SubscriptLambdaT >
00250     value_T const& top( xst_lambda_wrap< SubscriptLambdaT > subscript_ ) const
00251     {
00252         return m_lambda.top( subscript_ );
00253     }
00254 
00256     value_T const& top() const
00257     {
00258         return top( const_scalar( 0 ) );
00259     }
00260 
00262     template< typename SubscriptLambdaT >
00263     value_T& top( xst_lambda_wrap< SubscriptLambdaT > subscript_ )
00264     {
00265         return m_lambda.top( subscript_ );
00266     }
00267 
00269     value_T& top()
00270     {
00271         return top( const_scalar( 0 ) );
00272     }
00273 
00275     template< typename SubscriptLambdaT >
00276     size_t size( xst_lambda_wrap< SubscriptLambdaT > subscript_ ) const
00277     {
00278         return m_lambda.size( subscript_ );
00279     }
00280 
00282     size_t size() const
00283     {
00284         return size( const_scalar( 0 ) );
00285     }
00286 
00288     template< typename SubscriptLambdaT >
00289     std::stack< value_T >* stack_ptr( SubscriptLambdaT subscript_ )
00290     {
00291         return m_lambda.stack_ptr( subscript_ );
00292     }
00293 
00295     template< typename SubscriptLambdaT >
00296     std::stack< value_T > const* stack_ptr( SubscriptLambdaT subscript_ ) const
00297     {
00298         return m_lambda.stack_ptr( subscript_ );
00299     }
00300 
00302     template< typename SubscriptLambdaT >
00303     void update( SubscriptLambdaT program_ )
00304     {
00305         m_lambda.update( program_ );
00306     }
00307 
00309     template< typename SubscriptLambdaT >
00310     inline
00311     xtl_wrap<
00312         xst_deposit_adaptor<
00313             xst_lambda_wrap< LambdaT >,
00314             xst_lambda_wrap< SubscriptLambdaT >
00315         >
00316     >
00317     deposit( xst_lambda_wrap< SubscriptLambdaT > program_ )
00318     {
00319         typedef
00320             xst_deposit_adaptor<
00321                 xst_lambda_wrap< LambdaT >,
00322                 xst_lambda_wrap< SubscriptLambdaT >
00323         > xst_deposit_adaptor_T;
00324 
00325         return xtl_wrap< xst_deposit_adaptor_T >( xst_deposit_adaptor_T( *this, program_ ) );
00326     }
00327 
00328 #ifdef CTTL_LAMBDA_REFLECTION
00329 
00330     typedef xst_lambda_wrap< typename LambdaT::reflection_T > reflection_T;
00331 
00333     reflection_T reflection() const
00334     {
00335         return reflection_T( m_lambda.reflection() );
00336     }
00337 #endif // CTTL_LAMBDA_REFLECTION
00338 
00339 private:
00341     // Implementation
00343 
00345     LambdaT m_lambda;
00346 
00359     template< int LocationT, typename InputValueT >
00360     void xpush_at_location( InputValueT const& data_ )
00361     {
00362         m_lambda.xpush_at_location< LocationT >( data_ );
00363     }
00364 
00372     template< int LocationT >
00373     void xpop_at_location()
00374     {
00375         m_lambda.xpop_at_location< LocationT >();
00376     }
00377 
00385     template< int LocationT >
00386     value_T const& xtop_at_location() const
00387     {
00388         return m_lambda.xtop_at_location< LocationT >();
00389     }
00390 
00392     template< int LocationT, typename InputValueT >
00393     void xpush_descend( InputValueT const& data_ )
00394     {
00395         m_lambda.xpush_descend< LocationT >( data_ );
00396     }
00397 
00399     template< int LocationT >
00400     void xpop_descend()
00401     {
00402         m_lambda.xpop_descend< LocationT >();
00403     }
00404 
00405 
00407     template< int LocationT >
00408     value_T const& xtop_descend() const
00409     {
00410         return m_lambda.xtop_descend< LocationT >();
00411     }
00412 
00414     // subscript traversal algorithms
00416 
00418     template< typename SubscriptLambdaT, typename FunctorT >
00419     void xsubscript_top_down_subtree_switch( SubscriptLambdaT subscript_, FunctorT& functor_ ) const
00420     {
00421         m_lambda.xsubscript_top_down_subtree_switch( subscript_, functor_ );
00422     }
00423 
00425     template< int LocationT, typename FunctorT >
00426     void xsubscript_top_down_descend( FunctorT& functor_ ) const
00427     {
00428         m_lambda.xsubscript_top_down_descend< LocationT >( functor_ );
00429     }
00430 
00432     template< int LocationT, typename SubscriptLambdaT, typename FunctorT >
00433     void xsubscript_top_down_subtree_descend( SubscriptLambdaT subscript_, FunctorT& functor_ ) const
00434     {
00435         m_lambda.xsubscript_top_down_subtree_descend< LocationT >( subscript_, functor_ );
00436     }
00437 
00439     template< typename SubscriptLambdaT, typename FunctorT >
00440     void xsubscript_bottom_up_subtree_switch( SubscriptLambdaT subscript_, FunctorT& functor_ ) const
00441     {
00442         m_lambda.xsubscript_bottom_up_subtree_switch( subscript_, functor_ );
00443     }
00444 
00446     template< int LocationT, typename FunctorT >
00447     void xsubscript_bottom_up_descend( FunctorT& functor_ ) const
00448     {
00449         m_lambda.xsubscript_bottom_up_descend< LocationT >( functor_ );
00450     }
00451 
00453     template< int LocationT, typename SubscriptLambdaT, typename FunctorT >
00454     void xsubscript_bottom_up_subtree_descend( SubscriptLambdaT subscript_, FunctorT& functor_ ) const
00455     {
00456         m_lambda.xsubscript_bottom_up_subtree_descend< LocationT >( subscript_, functor_ );
00457     }
00458 
00459 
00461     // Lambda primitive stack interface support
00463 
00465     template< typename SubscriptLambdaT, typename InputValueT >
00466     void xpush_sub_split( SubscriptLambdaT subscript_, InputValueT const& data_ )
00467     {
00468         m_lambda.xpush_sub_split( subscript_, data_ );
00469     }
00470 
00472     template< int LocationT, typename SubscriptLambdaT, typename InputValueT >
00473     void xpush_sub_descend( SubscriptLambdaT subscript_, InputValueT const& data_ )
00474     {
00475         m_lambda.xpush_sub_descend< LocationT >( subscript_, data_ );
00476     }
00477 
00479     template< typename SubscriptLambdaT >
00480     void xpop_sub_split( SubscriptLambdaT subscript_ )
00481     {
00482         m_lambda.xpop_sub_split( subscript_ );
00483     }
00484 
00486     template< int LocationT, typename SubscriptLambdaT >
00487     void xpop_sub_descend( SubscriptLambdaT subscript_ )
00488     {
00489         m_lambda.xpop_sub_descend< LocationT >( subscript_ );
00490     }
00491 
00493     template< typename SubscriptLambdaT >
00494     value_T const& xtop_sub_split( SubscriptLambdaT subscript_ ) const
00495     {
00496         return m_lambda.xtop_sub_split( subscript_ );
00497     }
00498 
00500     template< int LocationT, typename SubscriptLambdaT >
00501     value_T const& xtop_sub_descend( SubscriptLambdaT subscript_ ) const
00502     {
00503         return m_lambda.xtop_sub_descend< LocationT >( subscript_ );
00504     }
00505 
00506 
00508     // mutable data access
00510 
00512     template< int LocationT >
00513     value_T& xtop_at_location()
00514     {
00515         return m_lambda.xtop_at_location< LocationT >();
00516     }
00517 
00519     template< int LocationT >
00520     value_T& xtop_descend()
00521     {
00522         return m_lambda.xtop_descend< LocationT >();
00523     }
00524 
00526     template< typename SubscriptLambdaT >
00527     value_T& xtop_sub_split( SubscriptLambdaT subscript_ )
00528     {
00529         return m_lambda.xtop_sub_split( subscript_ );
00530     }
00531 
00533     template< int LocationT, typename SubscriptLambdaT >
00534     value_T& xtop_sub_descend( SubscriptLambdaT subscript_ )
00535     {
00536         return m_lambda.xtop_sub_descend< LocationT >( subscript_ );
00537     }
00538 
00539 
00541     template< int LocationT >
00542     size_t xsize_at_location() const
00543     {
00544         return m_lambda.xsize_at_location< LocationT >();
00545     }
00546 
00548     template< int LocationT >
00549     size_t xsize_descend() const
00550     {
00551         return m_lambda.xsize_descend< LocationT >();
00552     }
00553 
00555     template< typename SubscriptLambdaT >
00556     size_t xsize_sub_split( SubscriptLambdaT subscript_ ) const
00557     {
00558         return m_lambda.xsize_sub_split( subscript_ );
00559     }
00560 
00562     template< int LocationT, typename SubscriptLambdaT >
00563     size_t xsize_sub_descend( SubscriptLambdaT subscript_ ) const
00564     {
00565         return m_lambda.xsize_sub_descend< LocationT >( subscript_ );
00566     }
00567 
00568 
00570     // functions to support mutable access to the location stack
00572 
00574     template< int LocationT >
00575     std::stack< value_T >* xstack_ptr_at_location()
00576     {
00577         return m_lambda.xstack_ptr_at_location< LocationT >();
00578     }
00579 
00581     template< int LocationT >
00582     std::stack< value_T >* xstack_ptr_descend()
00583     {
00584         return m_lambda.xstack_ptr_descend< LocationT >();
00585     }
00586 
00588     template< typename SubscriptLambdaT >
00589     std::stack< value_T >* xstack_ptr_sub_split( SubscriptLambdaT subscript_ )
00590     {
00591         return m_lambda.xstack_ptr_sub_split( subscript_ );
00592     }
00593 
00595     template< int LocationT, typename SubscriptLambdaT >
00596     std::stack< value_T >* xstack_ptr_sub_descend( SubscriptLambdaT subscript_ )
00597     {
00598         return m_lambda.xstack_ptr_sub_descend< LocationT >( subscript_ );
00599     }
00600 
00601 
00603     // functions to support constant access to the location stack
00605 
00607     template< int LocationT >
00608     std::stack< value_T > const* xstack_ptr_at_location() const
00609     {
00610         return m_lambda.xstack_ptr_at_location< LocationT >();
00611     }
00612 
00614     template< int LocationT >
00615     std::stack< value_T > const* xstack_ptr_descend() const
00616     {
00617         return m_lambda.xstack_ptr_descend< LocationT >();
00618     }
00619 
00621     template< typename SubscriptLambdaT >
00622     std::stack< value_T > const* xstack_ptr_sub_split( SubscriptLambdaT subscript_ ) const
00623     {
00624         return m_lambda.xstack_ptr_sub_split( subscript_ );
00625     }
00626 
00628     template< int LocationT, typename SubscriptLambdaT >
00629     std::stack< value_T > const* xstack_ptr_sub_descend( SubscriptLambdaT subscript_ ) const
00630     {
00631         return m_lambda.xstack_ptr_sub_descend< LocationT >( subscript_ );
00632     }
00633 
00634 public:
00636 // Overloaded operators
00638 
00639 // Do not modify section of code delimited by comments contaning
00640 // begin_generated_code/end_generated_code labels. This section of code is
00641 // maintained by gumus scripts.
00642 
00643 //begin_generated_code
00644 // generated by gmu/lambda/gmu_common.h:529
00645 // on Thu Nov 02 13:01:33 2006.
00646 // generated by gmu/lambda/gmu_common.h:157
00648 // Assignment = operators begin
00650 
00652 // Assignment = abbreviations
00654 // generated by gmu/lambda/operators/assign/assign_funcs.h:8
00669     template< typename RhsValueT >
00670     xst_binary_adaptor<
00671         xst_lambda_wrap< typename LambdaT::reference_T >,
00672         xst_lambda_wrap< xst_scalar< RhsValueT > >,
00673         xst_assignment_policy<
00674             1, // xst_scalar capacity
00675             LambdaT::capacity_,
00676             LambdaT::primitive_id_
00677         >
00678     >
00679     operator= ( RhsValueT const& value_ )
00680     {
00681         typedef xst_binary_adaptor<
00682             xst_lambda_wrap< typename LambdaT::reference_T >,
00683             xst_lambda_wrap< xst_scalar< RhsValueT > >,
00684             xst_assignment_policy<
00685                 1, // xst_scalar capacity
00686                 LambdaT::capacity_,
00687                 LambdaT::primitive_id_
00688             >
00689         > xst_adaptor_T;
00690 
00691         return xst_adaptor_T(
00692             make_reference(),
00693             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
00694             );
00695     }
00696 
00697 // generated by gmu/lambda/operators/assign/assign_funcs.h:51
00712     template< typename RhsValueT >
00713     xst_binary_adaptor<
00714         xst_lambda_wrap< typename LambdaT::reference_T >,
00715         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
00716         xst_assignment_policy<
00717             1, // xst_scalar capacity
00718             LambdaT::capacity_,
00719             LambdaT::primitive_id_
00720         >
00721     >
00722     operator= ( RhsValueT* pvalue_ )
00723     {
00724         typedef xst_binary_adaptor<
00725             xst_lambda_wrap< typename LambdaT::reference_T >,
00726             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
00727             xst_assignment_policy<
00728                 1, // xst_scalar capacity
00729                 LambdaT::capacity_,
00730                 LambdaT::primitive_id_
00731             >
00732         > xst_adaptor_T;
00733 
00734         return xst_adaptor_T(
00735             make_reference(),
00736             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
00737             );
00738     }
00739 
00740 
00742 // Assignment = specializations
00744 // generated by gmu/lambda/operators/assign/assign_funcs.h:98
00745 
00760     template< typename OtherLambdaT >
00761     xst_binary_adaptor<
00762         xst_lambda_wrap< typename LambdaT::reference_T >,
00763         xst_lambda_wrap< typename OtherLambdaT::reference_T >,
00764         xst_assignment_policy<
00765             OtherLambdaT::capacity_,
00766             LambdaT::capacity_,
00767             LambdaT::primitive_id_
00768         >
00769     >
00770     operator= ( xst_lambda_wrap< OtherLambdaT > const& lambda_ )
00771     {
00772         typedef xst_binary_adaptor<
00773             xst_lambda_wrap< typename LambdaT::reference_T >,
00774             xst_lambda_wrap< typename OtherLambdaT::reference_T >,
00775             xst_assignment_policy<
00776                 OtherLambdaT::capacity_,
00777                 LambdaT::capacity_,
00778                 LambdaT::primitive_id_
00779             >
00780         > xst_adaptor_T;
00781 
00782         return xst_adaptor_T( make_reference(), lambda_.make_reference() );
00783     }
00784 
00785 // generated by gmu/lambda/operators/assign/assign_funcs.h:139
00797     xst_binary_adaptor<
00798         xst_lambda_wrap< typename LambdaT::reference_T >,
00799         xst_lambda_wrap< typename LambdaT::reference_T >,
00800         xst_assignment_policy<
00801             LambdaT::capacity_,
00802             LambdaT::capacity_,
00803             LambdaT::primitive_id_
00804         >
00805     >
00806     operator= ( xst_lambda_wrap< LambdaT > const& lambda_ )
00807     {
00808         typedef xst_binary_adaptor<
00809             xst_lambda_wrap< typename LambdaT::reference_T >,
00810             xst_lambda_wrap< typename LambdaT::reference_T >,
00811             xst_assignment_policy<
00812                 LambdaT::capacity_,
00813                 LambdaT::capacity_,
00814                 LambdaT::primitive_id_
00815             >
00816         > xst_adaptor_T;
00817 
00818         return xst_adaptor_T( make_reference(), lambda_.make_reference() );
00819     }
00820 
00821 // generated by gmu/lambda/operators/assign/assign_funcs.h:175
00841     template< typename OtherLambdaT, typename PolicyAdaptorT >
00842     xst_binary_adaptor<
00843         xst_lambda_wrap< typename LambdaT::reference_T >,
00844         xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
00845         xst_assignment_policy<
00846             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
00847             LambdaT::capacity_,
00848             LambdaT::primitive_id_
00849         >
00850     >
00851     operator= ( xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT > const& unary_adaptor_ )
00852     {
00853         typedef xst_binary_adaptor<
00854             xst_lambda_wrap< typename LambdaT::reference_T >,
00855             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
00856             xst_assignment_policy<
00857                 xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
00858                 LambdaT::capacity_,
00859                 LambdaT::primitive_id_
00860             >
00861         > xst_adaptor_T;
00862 
00863         return xst_adaptor_T( make_reference(), unary_adaptor_ );
00864     }
00865 
00866 // generated by gmu/lambda/operators/assign/assign_funcs.h:220
00890     template< typename LambdaLhsT, typename LambdaRhsT, typename PolicyAdaptorT >
00891     xst_binary_adaptor<
00892         xst_lambda_wrap< typename LambdaT::reference_T >,
00893         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
00894         xst_assignment_policy<
00895             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
00896             LambdaT::capacity_,
00897             LambdaT::primitive_id_
00898         >
00899     >
00900     operator= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT > const& binary_adaptor_ )
00901     {
00902         typedef xst_binary_adaptor<
00903             xst_lambda_wrap< typename LambdaT::reference_T >,
00904             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
00905             xst_assignment_policy<
00906                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
00907                 LambdaT::capacity_,
00908                 LambdaT::primitive_id_
00909             >
00910         > xst_adaptor_T;
00911 
00912         return xst_adaptor_T( make_reference(), binary_adaptor_ );
00913     }
00914 
00916 // More = assignment abbreviations
00918 // generated by gmu/lambda/operators/assign/assign_funcs.h:272
00934     template< typename StackValueT >
00935     xst_binary_adaptor<
00936         xst_lambda_wrap< typename LambdaT::reference_T >,
00937         xst_lambda_wrap< xst_scalar< StackValueT > >,
00938         xst_assignment_policy<
00939             1, // xst_scalar capacity
00940             LambdaT::capacity_,
00941             LambdaT::primitive_id_
00942         >
00943     >
00944     operator= ( std::stack< StackValueT > const& stack_ )
00945     {
00946         typedef xst_binary_adaptor<
00947             xst_lambda_wrap< typename LambdaT::reference_T >,
00948             xst_lambda_wrap< xst_scalar< StackValueT > >,
00949             xst_assignment_policy<
00950                 1, // xst_scalar capacity
00951                 LambdaT::capacity_,
00952                 LambdaT::primitive_id_
00953             >
00954         > xst_adaptor_T;
00955 
00956         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
00957         return xst_adaptor_T(
00958             make_reference(),
00959             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
00960             );
00961     }
00962 
00963 // generated by gmu/lambda/operators/assign/assign_funcs.h:317
00979     template< typename StackValueT >
00980     xst_binary_adaptor<
00981         xst_lambda_wrap< typename LambdaT::reference_T >,
00982         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
00983         xst_assignment_policy<
00984             1, // xst_stack capacity
00985             LambdaT::capacity_,
00986             LambdaT::primitive_id_
00987         >
00988     >
00989     operator= ( std::stack< StackValueT >* pstack_ )
00990     {
00991         typedef xst_binary_adaptor<
00992             xst_lambda_wrap< typename LambdaT::reference_T >,
00993             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
00994             xst_assignment_policy<
00995                 1, // xst_stack capacity
00996                 LambdaT::capacity_,
00997                 LambdaT::primitive_id_
00998             >
00999         > xst_adaptor_T;
01000 
01001         return xst_adaptor_T(
01002             make_reference(),
01003             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
01004             );
01005     }
01006 
01008 // Assignment = operators end
01010 
01011 // generated by gmu/lambda/gmu_common.h:157
01013 // Assignment *= operators begin
01015 
01017 // Assignment *= abbreviations
01019 // generated by gmu/lambda/operators/assign/assign_funcs.h:8
01034     template< typename RhsValueT >
01035     xst_binary_adaptor<
01036         xst_lambda_wrap< typename LambdaT::reference_T >,
01037         xst_lambda_wrap< xst_scalar< RhsValueT > >,
01038         xst_multiplication_assignment_policy<
01039             1, // xst_scalar capacity
01040             LambdaT::capacity_,
01041             LambdaT::primitive_id_
01042         >
01043     >
01044     operator*= ( RhsValueT const& value_ )
01045     {
01046         typedef xst_binary_adaptor<
01047             xst_lambda_wrap< typename LambdaT::reference_T >,
01048             xst_lambda_wrap< xst_scalar< RhsValueT > >,
01049             xst_multiplication_assignment_policy<
01050                 1, // xst_scalar capacity
01051                 LambdaT::capacity_,
01052                 LambdaT::primitive_id_
01053             >
01054         > xst_adaptor_T;
01055 
01056         return xst_adaptor_T(
01057             make_reference(),
01058             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
01059             );
01060     }
01061 
01062 // generated by gmu/lambda/operators/assign/assign_funcs.h:51
01077     template< typename RhsValueT >
01078     xst_binary_adaptor<
01079         xst_lambda_wrap< typename LambdaT::reference_T >,
01080         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
01081         xst_multiplication_assignment_policy<
01082             1, // xst_scalar capacity
01083             LambdaT::capacity_,
01084             LambdaT::primitive_id_
01085         >
01086     >
01087     operator*= ( RhsValueT* pvalue_ )
01088     {
01089         typedef xst_binary_adaptor<
01090             xst_lambda_wrap< typename LambdaT::reference_T >,
01091             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
01092             xst_multiplication_assignment_policy<
01093                 1, // xst_scalar capacity
01094                 LambdaT::capacity_,
01095                 LambdaT::primitive_id_
01096             >
01097         > xst_adaptor_T;
01098 
01099         return xst_adaptor_T(
01100             make_reference(),
01101             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
01102             );
01103     }
01104 
01105 
01107 // Assignment *= specializations
01109 // generated by gmu/lambda/operators/assign/assign_funcs.h:98
01110 
01125     template< typename OtherLambdaT >
01126     xst_binary_adaptor<
01127         xst_lambda_wrap< typename LambdaT::reference_T >,
01128         xst_lambda_wrap< typename OtherLambdaT::reference_T >,
01129         xst_multiplication_assignment_policy<
01130             OtherLambdaT::capacity_,
01131             LambdaT::capacity_,
01132             LambdaT::primitive_id_
01133         >
01134     >
01135     operator*= ( xst_lambda_wrap< OtherLambdaT > const& lambda_ )
01136     {
01137         typedef xst_binary_adaptor<
01138             xst_lambda_wrap< typename LambdaT::reference_T >,
01139             xst_lambda_wrap< typename OtherLambdaT::reference_T >,
01140             xst_multiplication_assignment_policy<
01141                 OtherLambdaT::capacity_,
01142                 LambdaT::capacity_,
01143                 LambdaT::primitive_id_
01144             >
01145         > xst_adaptor_T;
01146 
01147         return xst_adaptor_T( make_reference(), lambda_.make_reference() );
01148     }
01149 
01150 // generated by gmu/lambda/operators/assign/assign_funcs.h:139
01162     xst_binary_adaptor<
01163         xst_lambda_wrap< typename LambdaT::reference_T >,
01164         xst_lambda_wrap< typename LambdaT::reference_T >,
01165         xst_multiplication_assignment_policy<
01166             LambdaT::capacity_,
01167             LambdaT::capacity_,
01168             LambdaT::primitive_id_
01169         >
01170     >
01171     operator*= ( xst_lambda_wrap< LambdaT > const& lambda_ )
01172     {
01173         typedef xst_binary_adaptor<
01174             xst_lambda_wrap< typename LambdaT::reference_T >,
01175             xst_lambda_wrap< typename LambdaT::reference_T >,
01176             xst_multiplication_assignment_policy<
01177                 LambdaT::capacity_,
01178                 LambdaT::capacity_,
01179                 LambdaT::primitive_id_
01180             >
01181         > xst_adaptor_T;
01182 
01183         return xst_adaptor_T( make_reference(), lambda_.make_reference() );
01184     }
01185 
01186 // generated by gmu/lambda/operators/assign/assign_funcs.h:175
01206     template< typename OtherLambdaT, typename PolicyAdaptorT >
01207     xst_binary_adaptor<
01208         xst_lambda_wrap< typename LambdaT::reference_T >,
01209         xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
01210         xst_multiplication_assignment_policy<
01211             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
01212             LambdaT::capacity_,
01213             LambdaT::primitive_id_
01214         >
01215     >
01216     operator*= ( xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT > const& unary_adaptor_ )
01217     {
01218         typedef xst_binary_adaptor<
01219             xst_lambda_wrap< typename LambdaT::reference_T >,
01220             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
01221             xst_multiplication_assignment_policy<
01222                 xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
01223                 LambdaT::capacity_,
01224                 LambdaT::primitive_id_
01225             >
01226         > xst_adaptor_T;
01227 
01228         return xst_adaptor_T( make_reference(), unary_adaptor_ );
01229     }
01230 
01231 // generated by gmu/lambda/operators/assign/assign_funcs.h:220
01255     template< typename LambdaLhsT, typename LambdaRhsT, typename PolicyAdaptorT >
01256     xst_binary_adaptor<
01257         xst_lambda_wrap< typename LambdaT::reference_T >,
01258         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
01259         xst_multiplication_assignment_policy<
01260             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
01261             LambdaT::capacity_,
01262             LambdaT::primitive_id_
01263         >
01264     >
01265     operator*= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT > const& binary_adaptor_ )
01266     {
01267         typedef xst_binary_adaptor<
01268             xst_lambda_wrap< typename LambdaT::reference_T >,
01269             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
01270             xst_multiplication_assignment_policy<
01271                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
01272                 LambdaT::capacity_,
01273                 LambdaT::primitive_id_
01274             >
01275         > xst_adaptor_T;
01276 
01277         return xst_adaptor_T( make_reference(), binary_adaptor_ );
01278     }
01279 
01281 // More *= assignment abbreviations
01283 // generated by gmu/lambda/operators/assign/assign_funcs.h:272
01299     template< typename StackValueT >
01300     xst_binary_adaptor<
01301         xst_lambda_wrap< typename LambdaT::reference_T >,
01302         xst_lambda_wrap< xst_scalar< StackValueT > >,
01303         xst_multiplication_assignment_policy<
01304             1, // xst_scalar capacity
01305             LambdaT::capacity_,
01306             LambdaT::primitive_id_
01307         >
01308     >
01309     operator*= ( std::stack< StackValueT > const& stack_ )
01310     {
01311         typedef xst_binary_adaptor<
01312             xst_lambda_wrap< typename LambdaT::reference_T >,
01313             xst_lambda_wrap< xst_scalar< StackValueT > >,
01314             xst_multiplication_assignment_policy<
01315                 1, // xst_scalar capacity
01316                 LambdaT::capacity_,
01317                 LambdaT::primitive_id_
01318             >
01319         > xst_adaptor_T;
01320 
01321         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
01322         return xst_adaptor_T(
01323             make_reference(),
01324             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
01325             );
01326     }
01327 
01328 // generated by gmu/lambda/operators/assign/assign_funcs.h:317
01344     template< typename StackValueT >
01345     xst_binary_adaptor<
01346         xst_lambda_wrap< typename LambdaT::reference_T >,
01347         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
01348         xst_multiplication_assignment_policy<
01349             1, // xst_stack capacity
01350             LambdaT::capacity_,
01351             LambdaT::primitive_id_
01352         >
01353     >
01354     operator*= ( std::stack< StackValueT >* pstack_ )
01355     {
01356         typedef xst_binary_adaptor<
01357             xst_lambda_wrap< typename LambdaT::reference_T >,
01358             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
01359             xst_multiplication_assignment_policy<
01360                 1, // xst_stack capacity
01361                 LambdaT::capacity_,
01362                 LambdaT::primitive_id_
01363             >
01364         > xst_adaptor_T;
01365 
01366         return xst_adaptor_T(
01367             make_reference(),
01368             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
01369             );
01370     }
01371 
01373 // Assignment *= operators end
01375 
01376 // generated by gmu/lambda/gmu_common.h:157
01378 // Assignment /= operators begin
01380 
01382 // Assignment /= abbreviations
01384 // generated by gmu/lambda/operators/assign/assign_funcs.h:8
01399     template< typename RhsValueT >
01400     xst_binary_adaptor<
01401         xst_lambda_wrap< typename LambdaT::reference_T >,
01402         xst_lambda_wrap< xst_scalar< RhsValueT > >,
01403         xst_division_assignment_policy<
01404             1, // xst_scalar capacity
01405             LambdaT::capacity_,
01406             LambdaT::primitive_id_
01407         >
01408     >
01409     operator/= ( RhsValueT const& value_ )
01410     {
01411         typedef xst_binary_adaptor<
01412             xst_lambda_wrap< typename LambdaT::reference_T >,
01413             xst_lambda_wrap< xst_scalar< RhsValueT > >,
01414             xst_division_assignment_policy<
01415                 1, // xst_scalar capacity
01416                 LambdaT::capacity_,
01417                 LambdaT::primitive_id_
01418             >
01419         > xst_adaptor_T;
01420 
01421         return xst_adaptor_T(
01422             make_reference(),
01423             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
01424             );
01425     }
01426 
01427 // generated by gmu/lambda/operators/assign/assign_funcs.h:51
01442     template< typename RhsValueT >
01443     xst_binary_adaptor<
01444         xst_lambda_wrap< typename LambdaT::reference_T >,
01445         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
01446         xst_division_assignment_policy<
01447             1, // xst_scalar capacity
01448             LambdaT::capacity_,
01449             LambdaT::primitive_id_
01450         >
01451     >
01452     operator/= ( RhsValueT* pvalue_ )
01453     {
01454         typedef xst_binary_adaptor<
01455             xst_lambda_wrap< typename LambdaT::reference_T >,
01456             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
01457             xst_division_assignment_policy<
01458                 1, // xst_scalar capacity
01459                 LambdaT::capacity_,
01460                 LambdaT::primitive_id_
01461             >
01462         > xst_adaptor_T;
01463 
01464         return xst_adaptor_T(
01465             make_reference(),
01466             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
01467             );
01468     }
01469 
01470 
01472 // Assignment /= specializations
01474 // generated by gmu/lambda/operators/assign/assign_funcs.h:98
01475 
01490     template< typename OtherLambdaT >
01491     xst_binary_adaptor<
01492         xst_lambda_wrap< typename LambdaT::reference_T >,
01493         xst_lambda_wrap< typename OtherLambdaT::reference_T >,
01494         xst_division_assignment_policy<
01495             OtherLambdaT::capacity_,
01496             LambdaT::capacity_,
01497             LambdaT::primitive_id_
01498         >
01499     >
01500     operator/= ( xst_lambda_wrap< OtherLambdaT > const& lambda_ )
01501     {
01502         typedef xst_binary_adaptor<
01503             xst_lambda_wrap< typename LambdaT::reference_T >,
01504             xst_lambda_wrap< typename OtherLambdaT::reference_T >,
01505             xst_division_assignment_policy<
01506                 OtherLambdaT::capacity_,
01507                 LambdaT::capacity_,
01508                 LambdaT::primitive_id_
01509             >
01510         > xst_adaptor_T;
01511 
01512         return xst_adaptor_T( make_reference(), lambda_.make_reference() );
01513     }
01514 
01515 // generated by gmu/lambda/operators/assign/assign_funcs.h:139
01527     xst_binary_adaptor<
01528         xst_lambda_wrap< typename LambdaT::reference_T >,
01529         xst_lambda_wrap< typename LambdaT::reference_T >,
01530         xst_division_assignment_policy<
01531             LambdaT::capacity_,
01532             LambdaT::capacity_,
01533             LambdaT::primitive_id_
01534         >
01535     >
01536     operator/= ( xst_lambda_wrap< LambdaT > const& lambda_ )
01537     {
01538         typedef xst_binary_adaptor<
01539             xst_lambda_wrap< typename LambdaT::reference_T >,
01540             xst_lambda_wrap< typename LambdaT::reference_T >,
01541             xst_division_assignment_policy<
01542                 LambdaT::capacity_,
01543                 LambdaT::capacity_,
01544                 LambdaT::primitive_id_
01545             >
01546         > xst_adaptor_T;
01547 
01548         return xst_adaptor_T( make_reference(), lambda_.make_reference() );
01549     }
01550 
01551 // generated by gmu/lambda/operators/assign/assign_funcs.h:175
01571     template< typename OtherLambdaT, typename PolicyAdaptorT >
01572     xst_binary_adaptor<
01573         xst_lambda_wrap< typename LambdaT::reference_T >,
01574         xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
01575         xst_division_assignment_policy<
01576             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
01577             LambdaT::capacity_,
01578             LambdaT::primitive_id_
01579         >
01580     >
01581     operator/= ( xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT > const& unary_adaptor_ )
01582     {
01583         typedef xst_binary_adaptor<
01584             xst_lambda_wrap< typename LambdaT::reference_T >,
01585             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
01586             xst_division_assignment_policy<
01587                 xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
01588                 LambdaT::capacity_,
01589                 LambdaT::primitive_id_
01590             >
01591         > xst_adaptor_T;
01592 
01593         return xst_adaptor_T( make_reference(), unary_adaptor_ );
01594     }
01595 
01596 // generated by gmu/lambda/operators/assign/assign_funcs.h:220
01620     template< typename LambdaLhsT, typename LambdaRhsT, typename PolicyAdaptorT >
01621     xst_binary_adaptor<
01622         xst_lambda_wrap< typename LambdaT::reference_T >,
01623         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
01624         xst_division_assignment_policy<
01625             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
01626             LambdaT::capacity_,
01627             LambdaT::primitive_id_
01628         >
01629     >
01630     operator/= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT > const& binary_adaptor_ )
01631     {
01632         typedef xst_binary_adaptor<
01633             xst_lambda_wrap< typename LambdaT::reference_T >,
01634             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
01635             xst_division_assignment_policy<
01636                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
01637                 LambdaT::capacity_,
01638                 LambdaT::primitive_id_
01639             >
01640         > xst_adaptor_T;
01641 
01642         return xst_adaptor_T( make_reference(), binary_adaptor_ );
01643     }
01644 
01646 // More /= assignment abbreviations
01648 // generated by gmu/lambda/operators/assign/assign_funcs.h:272
01664     template< typename StackValueT >
01665     xst_binary_adaptor<
01666         xst_lambda_wrap< typename LambdaT::reference_T >,
01667         xst_lambda_wrap< xst_scalar< StackValueT > >,
01668         xst_division_assignment_policy<
01669             1, // xst_scalar capacity
01670             LambdaT::capacity_,
01671             LambdaT::primitive_id_
01672         >
01673     >
01674     operator/= ( std::stack< StackValueT > const& stack_ )
01675     {
01676         typedef xst_binary_adaptor<
01677             xst_lambda_wrap< typename LambdaT::reference_T >,
01678             xst_lambda_wrap< xst_scalar< StackValueT > >,
01679             xst_division_assignment_policy<
01680                 1, // xst_scalar capacity
01681                 LambdaT::capacity_,
01682                 LambdaT::primitive_id_
01683             >
01684         > xst_adaptor_T;
01685 
01686         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
01687         return xst_adaptor_T(
01688             make_reference(),
01689             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
01690             );
01691     }
01692 
01693 // generated by gmu/lambda/operators/assign/assign_funcs.h:317
01709     template< typename StackValueT >
01710     xst_binary_adaptor<
01711         xst_lambda_wrap< typename LambdaT::reference_T >,
01712         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
01713         xst_division_assignment_policy<
01714             1, // xst_stack capacity
01715             LambdaT::capacity_,
01716             LambdaT::primitive_id_
01717         >
01718     >
01719     operator/= ( std::stack< StackValueT >* pstack_ )
01720     {
01721         typedef xst_binary_adaptor<
01722             xst_lambda_wrap< typename LambdaT::reference_T >,
01723             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
01724             xst_division_assignment_policy<
01725                 1, // xst_stack capacity
01726                 LambdaT::capacity_,
01727                 LambdaT::primitive_id_
01728             >
01729         > xst_adaptor_T;
01730 
01731         return xst_adaptor_T(
01732             make_reference(),
01733             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
01734             );
01735     }
01736 
01738 // Assignment /= operators end
01740 
01741 // generated by gmu/lambda/gmu_common.h:157
01743 // Assignment %= operators begin
01745 
01747 // Assignment %= abbreviations
01749 // generated by gmu/lambda/operators/assign/assign_funcs.h:8
01764     template< typename RhsValueT >
01765     xst_binary_adaptor<
01766         xst_lambda_wrap< typename LambdaT::reference_T >,
01767         xst_lambda_wrap< xst_scalar< RhsValueT > >,
01768         xst_modulus_assignment_policy<
01769             1, // xst_scalar capacity
01770             LambdaT::capacity_,
01771             LambdaT::primitive_id_
01772         >
01773     >
01774     operator%= ( RhsValueT const& value_ )
01775     {
01776         typedef xst_binary_adaptor<
01777             xst_lambda_wrap< typename LambdaT::reference_T >,
01778             xst_lambda_wrap< xst_scalar< RhsValueT > >,
01779             xst_modulus_assignment_policy<
01780                 1, // xst_scalar capacity
01781                 LambdaT::capacity_,
01782                 LambdaT::primitive_id_
01783             >
01784         > xst_adaptor_T;
01785 
01786         return xst_adaptor_T(
01787             make_reference(),
01788             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
01789             );
01790     }
01791 
01792 // generated by gmu/lambda/operators/assign/assign_funcs.h:51
01807     template< typename RhsValueT >
01808     xst_binary_adaptor<
01809         xst_lambda_wrap< typename LambdaT::reference_T >,
01810         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
01811         xst_modulus_assignment_policy<
01812             1, // xst_scalar capacity
01813             LambdaT::capacity_,
01814             LambdaT::primitive_id_
01815         >
01816     >
01817     operator%= ( RhsValueT* pvalue_ )
01818     {
01819         typedef xst_binary_adaptor<
01820             xst_lambda_wrap< typename LambdaT::reference_T >,
01821             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
01822             xst_modulus_assignment_policy<
01823                 1, // xst_scalar capacity
01824                 LambdaT::capacity_,
01825                 LambdaT::primitive_id_
01826             >
01827         > xst_adaptor_T;
01828 
01829         return xst_adaptor_T(
01830             make_reference(),
01831             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
01832             );
01833     }
01834 
01835 
01837 // Assignment %= specializations
01839 // generated by gmu/lambda/operators/assign/assign_funcs.h:98
01840 
01855     template< typename OtherLambdaT >
01856     xst_binary_adaptor<
01857         xst_lambda_wrap< typename LambdaT::reference_T >,
01858         xst_lambda_wrap< typename OtherLambdaT::reference_T >,
01859         xst_modulus_assignment_policy<
01860             OtherLambdaT::capacity_,
01861             LambdaT::capacity_,
01862             LambdaT::primitive_id_
01863         >
01864     >
01865     operator%= ( xst_lambda_wrap< OtherLambdaT > const& lambda_ )
01866     {
01867         typedef xst_binary_adaptor<
01868             xst_lambda_wrap< typename LambdaT::reference_T >,
01869             xst_lambda_wrap< typename OtherLambdaT::reference_T >,
01870             xst_modulus_assignment_policy<
01871                 OtherLambdaT::capacity_,
01872                 LambdaT::capacity_,
01873                 LambdaT::primitive_id_
01874             >
01875         > xst_adaptor_T;
01876 
01877         return xst_adaptor_T( make_reference(), lambda_.make_reference() );
01878     }
01879 
01880 // generated by gmu/lambda/operators/assign/assign_funcs.h:139
01892     xst_binary_adaptor<
01893         xst_lambda_wrap< typename LambdaT::reference_T >,
01894         xst_lambda_wrap< typename LambdaT::reference_T >,
01895         xst_modulus_assignment_policy<
01896             LambdaT::capacity_,
01897             LambdaT::capacity_,
01898             LambdaT::primitive_id_
01899         >
01900     >
01901     operator%= ( xst_lambda_wrap< LambdaT > const& lambda_ )
01902     {
01903         typedef xst_binary_adaptor<
01904             xst_lambda_wrap< typename LambdaT::reference_T >,
01905             xst_lambda_wrap< typename LambdaT::reference_T >,
01906             xst_modulus_assignment_policy<
01907                 LambdaT::capacity_,
01908                 LambdaT::capacity_,
01909                 LambdaT::primitive_id_
01910             >
01911         > xst_adaptor_T;
01912 
01913         return xst_adaptor_T( make_reference(), lambda_.make_reference() );
01914     }
01915 
01916 // generated by gmu/lambda/operators/assign/assign_funcs.h:175
01936     template< typename OtherLambdaT, typename PolicyAdaptorT >
01937     xst_binary_adaptor<
01938         xst_lambda_wrap< typename LambdaT::reference_T >,
01939         xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
01940         xst_modulus_assignment_policy<
01941             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
01942             LambdaT::capacity_,
01943             LambdaT::primitive_id_
01944         >
01945     >
01946     operator%= ( xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT > const& unary_adaptor_ )
01947     {
01948         typedef xst_binary_adaptor<
01949             xst_lambda_wrap< typename LambdaT::reference_T >,
01950             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
01951             xst_modulus_assignment_policy<
01952                 xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
01953                 LambdaT::capacity_,
01954                 LambdaT::primitive_id_
01955             >
01956         > xst_adaptor_T;
01957 
01958         return xst_adaptor_T( make_reference(), unary_adaptor_ );
01959     }
01960 
01961 // generated by gmu/lambda/operators/assign/assign_funcs.h:220
01985     template< typename LambdaLhsT, typename LambdaRhsT, typename PolicyAdaptorT >
01986     xst_binary_adaptor<
01987         xst_lambda_wrap< typename LambdaT::reference_T >,
01988         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
01989         xst_modulus_assignment_policy<
01990             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
01991             LambdaT::capacity_,
01992             LambdaT::primitive_id_
01993         >
01994     >
01995     operator%= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT > const& binary_adaptor_ )
01996     {
01997         typedef xst_binary_adaptor<
01998             xst_lambda_wrap< typename LambdaT::reference_T >,
01999             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
02000             xst_modulus_assignment_policy<
02001                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
02002                 LambdaT::capacity_,
02003                 LambdaT::primitive_id_
02004             >
02005         > xst_adaptor_T;
02006 
02007         return xst_adaptor_T( make_reference(), binary_adaptor_ );
02008     }
02009 
02011 // More %= assignment abbreviations
02013 // generated by gmu/lambda/operators/assign/assign_funcs.h:272
02029     template< typename StackValueT >
02030     xst_binary_adaptor<
02031         xst_lambda_wrap< typename LambdaT::reference_T >,
02032         xst_lambda_wrap< xst_scalar< StackValueT > >,
02033         xst_modulus_assignment_policy<
02034             1, // xst_scalar capacity
02035             LambdaT::capacity_,
02036             LambdaT::primitive_id_
02037         >
02038     >
02039     operator%= ( std::stack< StackValueT > const& stack_ )
02040     {
02041         typedef xst_binary_adaptor<
02042             xst_lambda_wrap< typename LambdaT::reference_T >,
02043             xst_lambda_wrap< xst_scalar< StackValueT > >,
02044             xst_modulus_assignment_policy<
02045                 1, // xst_scalar capacity
02046                 LambdaT::capacity_,
02047                 LambdaT::primitive_id_
02048             >
02049         > xst_adaptor_T;
02050 
02051         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
02052         return xst_adaptor_T(
02053             make_reference(),
02054             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
02055             );
02056     }
02057 
02058 // generated by gmu/lambda/operators/assign/assign_funcs.h:317
02074     template< typename StackValueT >
02075     xst_binary_adaptor<
02076         xst_lambda_wrap< typename LambdaT::reference_T >,
02077         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
02078         xst_modulus_assignment_policy<
02079             1, // xst_stack capacity
02080             LambdaT::capacity_,
02081             LambdaT::primitive_id_
02082         >
02083     >
02084     operator%= ( std::stack< StackValueT >* pstack_ )
02085     {
02086         typedef xst_binary_adaptor<
02087             xst_lambda_wrap< typename LambdaT::reference_T >,
02088             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
02089             xst_modulus_assignment_policy<
02090                 1, // xst_stack capacity
02091                 LambdaT::capacity_,
02092                 LambdaT::primitive_id_
02093             >
02094         > xst_adaptor_T;
02095 
02096         return xst_adaptor_T(
02097             make_reference(),
02098             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
02099             );
02100     }
02101 
02103 // Assignment %= operators end
02105 
02106 // generated by gmu/lambda/gmu_common.h:157
02108 // Assignment += operators begin
02110 
02112 // Assignment += abbreviations
02114 // generated by gmu/lambda/operators/assign/assign_funcs.h:8
02129     template< typename RhsValueT >
02130     xst_binary_adaptor<
02131         xst_lambda_wrap< typename LambdaT::reference_T >,
02132         xst_lambda_wrap< xst_scalar< RhsValueT > >,
02133         xst_addition_assignment_policy<
02134             1, // xst_scalar capacity
02135             LambdaT::capacity_,
02136             LambdaT::primitive_id_
02137         >
02138     >
02139     operator+= ( RhsValueT const& value_ )
02140     {
02141         typedef xst_binary_adaptor<
02142             xst_lambda_wrap< typename LambdaT::reference_T >,
02143             xst_lambda_wrap< xst_scalar< RhsValueT > >,
02144             xst_addition_assignment_policy<
02145                 1, // xst_scalar capacity
02146                 LambdaT::capacity_,
02147                 LambdaT::primitive_id_
02148             >
02149         > xst_adaptor_T;
02150 
02151         return xst_adaptor_T(
02152             make_reference(),
02153             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
02154             );
02155     }
02156 
02157 // generated by gmu/lambda/operators/assign/assign_funcs.h:51
02172     template< typename RhsValueT >
02173     xst_binary_adaptor<
02174         xst_lambda_wrap< typename LambdaT::reference_T >,
02175         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
02176         xst_addition_assignment_policy<
02177             1, // xst_scalar capacity
02178             LambdaT::capacity_,
02179             LambdaT::primitive_id_
02180         >
02181     >
02182     operator+= ( RhsValueT* pvalue_ )
02183     {
02184         typedef xst_binary_adaptor<
02185             xst_lambda_wrap< typename LambdaT::reference_T >,
02186             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
02187             xst_addition_assignment_policy<
02188                 1, // xst_scalar capacity
02189                 LambdaT::capacity_,
02190                 LambdaT::primitive_id_
02191             >
02192         > xst_adaptor_T;
02193 
02194         return xst_adaptor_T(
02195             make_reference(),
02196             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
02197             );
02198     }
02199 
02200 
02202 // Assignment += specializations
02204 // generated by gmu/lambda/operators/assign/assign_funcs.h:98
02205 
02220     template< typename OtherLambdaT >
02221     xst_binary_adaptor<
02222         xst_lambda_wrap< typename LambdaT::reference_T >,
02223         xst_lambda_wrap< typename OtherLambdaT::reference_T >,
02224         xst_addition_assignment_policy<
02225             OtherLambdaT::capacity_,
02226             LambdaT::capacity_,
02227             LambdaT::primitive_id_
02228         >
02229     >
02230     operator+= ( xst_lambda_wrap< OtherLambdaT > const& lambda_ )
02231     {
02232         typedef xst_binary_adaptor<
02233             xst_lambda_wrap< typename LambdaT::reference_T >,
02234             xst_lambda_wrap< typename OtherLambdaT::reference_T >,
02235             xst_addition_assignment_policy<
02236                 OtherLambdaT::capacity_,
02237                 LambdaT::capacity_,
02238                 LambdaT::primitive_id_
02239             >
02240         > xst_adaptor_T;
02241 
02242         return xst_adaptor_T( make_reference(), lambda_.make_reference() );
02243     }
02244 
02245 // generated by gmu/lambda/operators/assign/assign_funcs.h:139
02257     xst_binary_adaptor<
02258         xst_lambda_wrap< typename LambdaT::reference_T >,
02259         xst_lambda_wrap< typename LambdaT::reference_T >,
02260         xst_addition_assignment_policy<
02261             LambdaT::capacity_,
02262             LambdaT::capacity_,
02263             LambdaT::primitive_id_
02264         >
02265     >
02266     operator+= ( xst_lambda_wrap< LambdaT > const& lambda_ )
02267     {
02268         typedef xst_binary_adaptor<
02269             xst_lambda_wrap< typename LambdaT::reference_T >,
02270             xst_lambda_wrap< typename LambdaT::reference_T >,
02271             xst_addition_assignment_policy<
02272                 LambdaT::capacity_,
02273                 LambdaT::capacity_,
02274                 LambdaT::primitive_id_
02275             >
02276         > xst_adaptor_T;
02277 
02278         return xst_adaptor_T( make_reference(), lambda_.make_reference() );
02279     }
02280 
02281 // generated by gmu/lambda/operators/assign/assign_funcs.h:175
02301     template< typename OtherLambdaT, typename PolicyAdaptorT >
02302     xst_binary_adaptor<
02303         xst_lambda_wrap< typename LambdaT::reference_T >,
02304         xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
02305         xst_addition_assignment_policy<
02306             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
02307             LambdaT::capacity_,
02308             LambdaT::primitive_id_
02309         >
02310     >
02311     operator+= ( xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT > const& unary_adaptor_ )
02312     {
02313         typedef xst_binary_adaptor<
02314             xst_lambda_wrap< typename LambdaT::reference_T >,
02315             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
02316             xst_addition_assignment_policy<
02317                 xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
02318                 LambdaT::capacity_,
02319                 LambdaT::primitive_id_
02320             >
02321         > xst_adaptor_T;
02322 
02323         return xst_adaptor_T( make_reference(), unary_adaptor_ );
02324     }
02325 
02326 // generated by gmu/lambda/operators/assign/assign_funcs.h:220
02350     template< typename LambdaLhsT, typename LambdaRhsT, typename PolicyAdaptorT >
02351     xst_binary_adaptor<
02352         xst_lambda_wrap< typename LambdaT::reference_T >,
02353         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
02354         xst_addition_assignment_policy<
02355             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
02356             LambdaT::capacity_,
02357             LambdaT::primitive_id_
02358         >
02359     >
02360     operator+= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT > const& binary_adaptor_ )
02361     {
02362         typedef xst_binary_adaptor<
02363             xst_lambda_wrap< typename LambdaT::reference_T >,
02364             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
02365             xst_addition_assignment_policy<
02366                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
02367                 LambdaT::capacity_,
02368                 LambdaT::primitive_id_
02369             >
02370         > xst_adaptor_T;
02371 
02372         return xst_adaptor_T( make_reference(), binary_adaptor_ );
02373     }
02374 
02376 // More += assignment abbreviations
02378 // generated by gmu/lambda/operators/assign/assign_funcs.h:272
02394     template< typename StackValueT >
02395     xst_binary_adaptor<
02396         xst_lambda_wrap< typename LambdaT::reference_T >,
02397         xst_lambda_wrap< xst_scalar< StackValueT > >,
02398         xst_addition_assignment_policy<
02399             1, // xst_scalar capacity
02400             LambdaT::capacity_,
02401             LambdaT::primitive_id_
02402         >
02403     >
02404     operator+= ( std::stack< StackValueT > const& stack_ )
02405     {
02406         typedef xst_binary_adaptor<
02407             xst_lambda_wrap< typename LambdaT::reference_T >,
02408             xst_lambda_wrap< xst_scalar< StackValueT > >,
02409             xst_addition_assignment_policy<
02410                 1, // xst_scalar capacity
02411                 LambdaT::capacity_,
02412                 LambdaT::primitive_id_
02413             >
02414         > xst_adaptor_T;
02415 
02416         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
02417         return xst_adaptor_T(
02418             make_reference(),
02419             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
02420             );
02421     }
02422 
02423 // generated by gmu/lambda/operators/assign/assign_funcs.h:317
02439     template< typename StackValueT >
02440     xst_binary_adaptor<
02441         xst_lambda_wrap< typename LambdaT::reference_T >,
02442         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
02443         xst_addition_assignment_policy<
02444             1, // xst_stack capacity
02445             LambdaT::capacity_,
02446             LambdaT::primitive_id_
02447         >
02448     >
02449     operator+= ( std::stack< StackValueT >* pstack_ )
02450     {
02451         typedef xst_binary_adaptor<
02452             xst_lambda_wrap< typename LambdaT::reference_T >,
02453             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
02454             xst_addition_assignment_policy<
02455                 1, // xst_stack capacity
02456                 LambdaT::capacity_,
02457                 LambdaT::primitive_id_
02458             >
02459         > xst_adaptor_T;
02460 
02461         return xst_adaptor_T(
02462             make_reference(),
02463             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
02464             );
02465     }
02466 
02468 // Assignment += operators end
02470 
02471 // generated by gmu/lambda/gmu_common.h:157
02473 // Assignment -= operators begin
02475 
02477 // Assignment -= abbreviations
02479 // generated by gmu/lambda/operators/assign/assign_funcs.h:8
02494     template< typename RhsValueT >
02495     xst_binary_adaptor<
02496         xst_lambda_wrap< typename LambdaT::reference_T >,
02497         xst_lambda_wrap< xst_scalar< RhsValueT > >,
02498         xst_subtraction_assignment_policy<
02499             1, // xst_scalar capacity
02500             LambdaT::capacity_,
02501             LambdaT::primitive_id_
02502         >
02503     >
02504     operator-= ( RhsValueT const& value_ )
02505     {
02506         typedef xst_binary_adaptor<
02507             xst_lambda_wrap< typename LambdaT::reference_T >,
02508             xst_lambda_wrap< xst_scalar< RhsValueT > >,
02509             xst_subtraction_assignment_policy<
02510                 1, // xst_scalar capacity
02511                 LambdaT::capacity_,
02512                 LambdaT::primitive_id_
02513             >
02514         > xst_adaptor_T;
02515 
02516         return xst_adaptor_T(
02517             make_reference(),
02518             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
02519             );
02520     }
02521 
02522 // generated by gmu/lambda/operators/assign/assign_funcs.h:51
02537     template< typename RhsValueT >
02538     xst_binary_adaptor<
02539         xst_lambda_wrap< typename LambdaT::reference_T >,
02540         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
02541         xst_subtraction_assignment_policy<
02542             1, // xst_scalar capacity
02543             LambdaT::capacity_,
02544             LambdaT::primitive_id_
02545         >
02546     >
02547     operator-= ( RhsValueT* pvalue_ )
02548     {
02549         typedef xst_binary_adaptor<
02550             xst_lambda_wrap< typename LambdaT::reference_T >,
02551             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
02552             xst_subtraction_assignment_policy<
02553                 1, // xst_scalar capacity
02554                 LambdaT::capacity_,
02555                 LambdaT::primitive_id_
02556             >
02557         > xst_adaptor_T;
02558 
02559         return xst_adaptor_T(
02560             make_reference(),
02561             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
02562             );
02563     }
02564 
02565 
02567 // Assignment -= specializations
02569 // generated by gmu/lambda/operators/assign/assign_funcs.h:98
02570 
02585     template< typename OtherLambdaT >
02586     xst_binary_adaptor<
02587         xst_lambda_wrap< typename LambdaT::reference_T >,
02588         xst_lambda_wrap< typename OtherLambdaT::reference_T >,
02589         xst_subtraction_assignment_policy<
02590             OtherLambdaT::capacity_,
02591             LambdaT::capacity_,
02592             LambdaT::primitive_id_
02593         >
02594     >
02595     operator-= ( xst_lambda_wrap< OtherLambdaT > const& lambda_ )
02596     {
02597         typedef xst_binary_adaptor<
02598             xst_lambda_wrap< typename LambdaT::reference_T >,
02599             xst_lambda_wrap< typename OtherLambdaT::reference_T >,
02600             xst_subtraction_assignment_policy<
02601                 OtherLambdaT::capacity_,
02602                 LambdaT::capacity_,
02603                 LambdaT::primitive_id_
02604             >
02605         > xst_adaptor_T;
02606 
02607         return xst_adaptor_T( make_reference(), lambda_.make_reference() );
02608     }
02609 
02610 // generated by gmu/lambda/operators/assign/assign_funcs.h:139
02622     xst_binary_adaptor<
02623         xst_lambda_wrap< typename LambdaT::reference_T >,
02624         xst_lambda_wrap< typename LambdaT::reference_T >,
02625         xst_subtraction_assignment_policy<
02626             LambdaT::capacity_,
02627             LambdaT::capacity_,
02628             LambdaT::primitive_id_
02629         >
02630     >
02631     operator-= ( xst_lambda_wrap< LambdaT > const& lambda_ )
02632     {
02633         typedef xst_binary_adaptor<
02634             xst_lambda_wrap< typename LambdaT::reference_T >,
02635             xst_lambda_wrap< typename LambdaT::reference_T >,
02636             xst_subtraction_assignment_policy<
02637                 LambdaT::capacity_,
02638                 LambdaT::capacity_,
02639                 LambdaT::primitive_id_
02640             >
02641         > xst_adaptor_T;
02642 
02643         return xst_adaptor_T( make_reference(), lambda_.make_reference() );
02644     }
02645 
02646 // generated by gmu/lambda/operators/assign/assign_funcs.h:175
02666     template< typename OtherLambdaT, typename PolicyAdaptorT >
02667     xst_binary_adaptor<
02668         xst_lambda_wrap< typename LambdaT::reference_T >,
02669         xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
02670         xst_subtraction_assignment_policy<
02671             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
02672             LambdaT::capacity_,
02673             LambdaT::primitive_id_
02674         >
02675     >
02676     operator-= ( xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT > const& unary_adaptor_ )
02677     {
02678         typedef xst_binary_adaptor<
02679             xst_lambda_wrap< typename LambdaT::reference_T >,
02680             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
02681             xst_subtraction_assignment_policy<
02682                 xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
02683                 LambdaT::capacity_,
02684                 LambdaT::primitive_id_
02685             >
02686         > xst_adaptor_T;
02687 
02688         return xst_adaptor_T( make_reference(), unary_adaptor_ );
02689     }
02690 
02691 // generated by gmu/lambda/operators/assign/assign_funcs.h:220
02715     template< typename LambdaLhsT, typename LambdaRhsT, typename PolicyAdaptorT >
02716     xst_binary_adaptor<
02717         xst_lambda_wrap< typename LambdaT::reference_T >,
02718         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
02719         xst_subtraction_assignment_policy<
02720             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
02721             LambdaT::capacity_,
02722             LambdaT::primitive_id_
02723         >
02724     >
02725     operator-= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT > const& binary_adaptor_ )
02726     {
02727         typedef xst_binary_adaptor<
02728             xst_lambda_wrap< typename LambdaT::reference_T >,
02729             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
02730             xst_subtraction_assignment_policy<
02731                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
02732                 LambdaT::capacity_,
02733                 LambdaT::primitive_id_
02734             >
02735         > xst_adaptor_T;
02736 
02737         return xst_adaptor_T( make_reference(), binary_adaptor_ );
02738     }
02739 
02741 // More -= assignment abbreviations
02743 // generated by gmu/lambda/operators/assign/assign_funcs.h:272
02759     template< typename StackValueT >
02760     xst_binary_adaptor<
02761         xst_lambda_wrap< typename LambdaT::reference_T >,
02762         xst_lambda_wrap< xst_scalar< StackValueT > >,
02763         xst_subtraction_assignment_policy<
02764             1, // xst_scalar capacity
02765             LambdaT::capacity_,
02766             LambdaT::primitive_id_
02767         >
02768     >
02769     operator-= ( std::stack< StackValueT > const& stack_ )
02770     {
02771         typedef xst_binary_adaptor<
02772             xst_lambda_wrap< typename LambdaT::reference_T >,
02773             xst_lambda_wrap< xst_scalar< StackValueT > >,
02774             xst_subtraction_assignment_policy<
02775                 1, // xst_scalar capacity
02776                 LambdaT::capacity_,
02777                 LambdaT::primitive_id_
02778             >
02779         > xst_adaptor_T;
02780 
02781         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
02782         return xst_adaptor_T(
02783             make_reference(),
02784             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
02785             );
02786     }
02787 
02788 // generated by gmu/lambda/operators/assign/assign_funcs.h:317
02804     template< typename StackValueT >
02805     xst_binary_adaptor<
02806         xst_lambda_wrap< typename LambdaT::reference_T >,
02807         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
02808         xst_subtraction_assignment_policy<
02809             1, // xst_stack capacity
02810             LambdaT::capacity_,
02811             LambdaT::primitive_id_
02812         >
02813     >
02814     operator-= ( std::stack< StackValueT >* pstack_ )
02815     {
02816         typedef xst_binary_adaptor<
02817             xst_lambda_wrap< typename LambdaT::reference_T >,
02818             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
02819             xst_subtraction_assignment_policy<
02820                 1, // xst_stack capacity
02821                 LambdaT::capacity_,
02822                 LambdaT::primitive_id_
02823             >
02824         > xst_adaptor_T;
02825 
02826         return xst_adaptor_T(
02827             make_reference(),
02828             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
02829             );
02830     }
02831 
02833 // Assignment -= operators end
02835 
02836 // generated by gmu/lambda/gmu_common.h:157
02838 // Assignment <<= operators begin
02840 
02842 // Assignment <<= abbreviations
02844 // generated by gmu/lambda/operators/assign/assign_funcs.h:8
02859     template< typename RhsValueT >
02860     xst_binary_adaptor<
02861         xst_lambda_wrap< typename LambdaT::reference_T >,
02862         xst_lambda_wrap< xst_scalar< RhsValueT > >,
02863         xst_left_shift_assignment_policy<
02864             1, // xst_scalar capacity
02865             LambdaT::capacity_,
02866             LambdaT::primitive_id_
02867         >
02868     >
02869     operator<<= ( RhsValueT const& value_ )
02870     {
02871         typedef xst_binary_adaptor<
02872             xst_lambda_wrap< typename LambdaT::reference_T >,
02873             xst_lambda_wrap< xst_scalar< RhsValueT > >,
02874             xst_left_shift_assignment_policy<
02875                 1, // xst_scalar capacity
02876                 LambdaT::capacity_,
02877                 LambdaT::primitive_id_
02878             >
02879         > xst_adaptor_T;
02880 
02881         return xst_adaptor_T(
02882             make_reference(),
02883             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
02884             );
02885     }
02886 
02887 // generated by gmu/lambda/operators/assign/assign_funcs.h:51
02902     template< typename RhsValueT >
02903     xst_binary_adaptor<
02904         xst_lambda_wrap< typename LambdaT::reference_T >,
02905         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
02906         xst_left_shift_assignment_policy<
02907             1, // xst_scalar capacity
02908             LambdaT::capacity_,
02909             LambdaT::primitive_id_
02910         >
02911     >
02912     operator<<= ( RhsValueT* pvalue_ )
02913     {
02914         typedef xst_binary_adaptor<
02915             xst_lambda_wrap< typename LambdaT::reference_T >,
02916             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
02917             xst_left_shift_assignment_policy<
02918                 1, // xst_scalar capacity
02919                 LambdaT::capacity_,
02920                 LambdaT::primitive_id_
02921             >
02922         > xst_adaptor_T;
02923 
02924         return xst_adaptor_T(
02925             make_reference(),
02926             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
02927             );
02928     }
02929 
02930 
02932 // Assignment <<= specializations
02934 // generated by gmu/lambda/operators/assign/assign_funcs.h:98
02935 
02950     template< typename OtherLambdaT >
02951     xst_binary_adaptor<
02952         xst_lambda_wrap< typename LambdaT::reference_T >,
02953         xst_lambda_wrap< typename OtherLambdaT::reference_T >,
02954         xst_left_shift_assignment_policy<
02955             OtherLambdaT::capacity_,
02956             LambdaT::capacity_,
02957             LambdaT::primitive_id_
02958         >
02959     >
02960     operator<<= ( xst_lambda_wrap< OtherLambdaT > const& lambda_ )
02961     {
02962         typedef xst_binary_adaptor<
02963             xst_lambda_wrap< typename LambdaT::reference_T >,
02964             xst_lambda_wrap< typename OtherLambdaT::reference_T >,
02965             xst_left_shift_assignment_policy<
02966                 OtherLambdaT::capacity_,
02967                 LambdaT::capacity_,
02968                 LambdaT::primitive_id_
02969             >
02970         > xst_adaptor_T;
02971 
02972         return xst_adaptor_T( make_reference(), lambda_.make_reference() );
02973     }
02974 
02975 // generated by gmu/lambda/operators/assign/assign_funcs.h:139
02987     xst_binary_adaptor<
02988         xst_lambda_wrap< typename LambdaT::reference_T >,
02989         xst_lambda_wrap< typename LambdaT::reference_T >,
02990         xst_left_shift_assignment_policy<
02991             LambdaT::capacity_,
02992             LambdaT::capacity_,
02993             LambdaT::primitive_id_
02994         >
02995     >
02996     operator<<= ( xst_lambda_wrap< LambdaT > const& lambda_ )
02997     {
02998         typedef xst_binary_adaptor<
02999             xst_lambda_wrap< typename LambdaT::reference_T >,
03000             xst_lambda_wrap< typename LambdaT::reference_T >,
03001             xst_left_shift_assignment_policy<
03002                 LambdaT::capacity_,
03003                 LambdaT::capacity_,
03004                 LambdaT::primitive_id_
03005             >
03006         > xst_adaptor_T;
03007 
03008         return xst_adaptor_T( make_reference(), lambda_.make_reference() );
03009     }
03010 
03011 // generated by gmu/lambda/operators/assign/assign_funcs.h:175
03031     template< typename OtherLambdaT, typename PolicyAdaptorT >
03032     xst_binary_adaptor<
03033         xst_lambda_wrap< typename LambdaT::reference_T >,
03034         xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
03035         xst_left_shift_assignment_policy<
03036             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
03037             LambdaT::capacity_,
03038             LambdaT::primitive_id_
03039         >
03040     >
03041     operator<<= ( xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT > const& unary_adaptor_ )
03042     {
03043         typedef xst_binary_adaptor<
03044             xst_lambda_wrap< typename LambdaT::reference_T >,
03045             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
03046             xst_left_shift_assignment_policy<
03047                 xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
03048                 LambdaT::capacity_,
03049                 LambdaT::primitive_id_
03050             >
03051         > xst_adaptor_T;
03052 
03053         return xst_adaptor_T( make_reference(), unary_adaptor_ );
03054     }
03055 
03056 // generated by gmu/lambda/operators/assign/assign_funcs.h:220
03080     template< typename LambdaLhsT, typename LambdaRhsT, typename PolicyAdaptorT >
03081     xst_binary_adaptor<
03082         xst_lambda_wrap< typename LambdaT::reference_T >,
03083         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
03084         xst_left_shift_assignment_policy<
03085             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
03086             LambdaT::capacity_,
03087             LambdaT::primitive_id_
03088         >
03089     >
03090     operator<<= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT > const& binary_adaptor_ )
03091     {
03092         typedef xst_binary_adaptor<
03093             xst_lambda_wrap< typename LambdaT::reference_T >,
03094             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
03095             xst_left_shift_assignment_policy<
03096                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
03097                 LambdaT::capacity_,
03098                 LambdaT::primitive_id_
03099             >
03100         > xst_adaptor_T;
03101 
03102         return xst_adaptor_T( make_reference(), binary_adaptor_ );
03103     }
03104 
03106 // More <<= assignment abbreviations
03108 // generated by gmu/lambda/operators/assign/assign_funcs.h:272
03124     template< typename StackValueT >
03125     xst_binary_adaptor<
03126         xst_lambda_wrap< typename LambdaT::reference_T >,
03127         xst_lambda_wrap< xst_scalar< StackValueT > >,
03128         xst_left_shift_assignment_policy<
03129             1, // xst_scalar capacity
03130             LambdaT::capacity_,
03131             LambdaT::primitive_id_
03132         >
03133     >
03134     operator<<= ( std::stack< StackValueT > const& stack_ )
03135     {
03136         typedef xst_binary_adaptor<
03137             xst_lambda_wrap< typename LambdaT::reference_T >,
03138             xst_lambda_wrap< xst_scalar< StackValueT > >,
03139             xst_left_shift_assignment_policy<
03140                 1, // xst_scalar capacity
03141                 LambdaT::capacity_,
03142                 LambdaT::primitive_id_
03143             >
03144         > xst_adaptor_T;
03145 
03146         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
03147         return xst_adaptor_T(
03148             make_reference(),
03149             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
03150             );
03151     }
03152 
03153 // generated by gmu/lambda/operators/assign/assign_funcs.h:317
03169     template< typename StackValueT >
03170     xst_binary_adaptor<
03171         xst_lambda_wrap< typename LambdaT::reference_T >,
03172         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
03173         xst_left_shift_assignment_policy<
03174             1, // xst_stack capacity
03175             LambdaT::capacity_,
03176             LambdaT::primitive_id_
03177         >
03178     >
03179     operator<<= ( std::stack< StackValueT >* pstack_ )
03180     {
03181         typedef xst_binary_adaptor<
03182             xst_lambda_wrap< typename LambdaT::reference_T >,
03183             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
03184             xst_left_shift_assignment_policy<
03185                 1, // xst_stack capacity
03186                 LambdaT::capacity_,
03187                 LambdaT::primitive_id_
03188             >
03189         > xst_adaptor_T;
03190 
03191         return xst_adaptor_T(
03192             make_reference(),
03193             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
03194             );
03195     }
03196 
03198 // Assignment <<= operators end
03200 
03201 // generated by gmu/lambda/gmu_common.h:157
03203 // Assignment >>= operators begin
03205 
03207 // Assignment >>= abbreviations
03209 // generated by gmu/lambda/operators/assign/assign_funcs.h:8
03224     template< typename RhsValueT >
03225     xst_binary_adaptor<
03226         xst_lambda_wrap< typename LambdaT::reference_T >,
03227         xst_lambda_wrap< xst_scalar< RhsValueT > >,
03228         xst_right_shift_assignment_policy<
03229             1, // xst_scalar capacity
03230             LambdaT::capacity_,
03231             LambdaT::primitive_id_
03232         >
03233     >
03234     operator>>= ( RhsValueT const& value_ )
03235     {
03236         typedef xst_binary_adaptor<
03237             xst_lambda_wrap< typename LambdaT::reference_T >,
03238             xst_lambda_wrap< xst_scalar< RhsValueT > >,
03239             xst_right_shift_assignment_policy<
03240                 1, // xst_scalar capacity
03241                 LambdaT::capacity_,
03242                 LambdaT::primitive_id_
03243             >
03244         > xst_adaptor_T;
03245 
03246         return xst_adaptor_T(
03247             make_reference(),
03248             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
03249             );
03250     }
03251 
03252 // generated by gmu/lambda/operators/assign/assign_funcs.h:51
03267     template< typename RhsValueT >
03268     xst_binary_adaptor<
03269         xst_lambda_wrap< typename LambdaT::reference_T >,
03270         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
03271         xst_right_shift_assignment_policy<
03272             1, // xst_scalar capacity
03273             LambdaT::capacity_,
03274             LambdaT::primitive_id_
03275         >
03276     >
03277     operator>>= ( RhsValueT* pvalue_ )
03278     {
03279         typedef xst_binary_adaptor<
03280             xst_lambda_wrap< typename LambdaT::reference_T >,
03281             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
03282             xst_right_shift_assignment_policy<
03283                 1, // xst_scalar capacity
03284                 LambdaT::capacity_,
03285                 LambdaT::primitive_id_
03286             >
03287         > xst_adaptor_T;
03288 
03289         return xst_adaptor_T(
03290             make_reference(),
03291             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
03292             );
03293     }
03294 
03295 
03297 // Assignment >>= specializations
03299 // generated by gmu/lambda/operators/assign/assign_funcs.h:98
03300 
03315     template< typename OtherLambdaT >
03316     xst_binary_adaptor<
03317         xst_lambda_wrap< typename LambdaT::reference_T >,
03318         xst_lambda_wrap< typename OtherLambdaT::reference_T >,
03319         xst_right_shift_assignment_policy<
03320             OtherLambdaT::capacity_,
03321             LambdaT::capacity_,
03322             LambdaT::primitive_id_
03323         >
03324     >
03325     operator>>= ( xst_lambda_wrap< OtherLambdaT > const& lambda_ )
03326     {
03327         typedef xst_binary_adaptor<
03328             xst_lambda_wrap< typename LambdaT::reference_T >,
03329             xst_lambda_wrap< typename OtherLambdaT::reference_T >,
03330             xst_right_shift_assignment_policy<
03331                 OtherLambdaT::capacity_,
03332                 LambdaT::capacity_,
03333                 LambdaT::primitive_id_
03334             >
03335         > xst_adaptor_T;
03336 
03337         return xst_adaptor_T( make_reference(), lambda_.make_reference() );
03338     }
03339 
03340 // generated by gmu/lambda/operators/assign/assign_funcs.h:139
03352     xst_binary_adaptor<
03353         xst_lambda_wrap< typename LambdaT::reference_T >,
03354         xst_lambda_wrap< typename LambdaT::reference_T >,
03355         xst_right_shift_assignment_policy<
03356             LambdaT::capacity_,
03357             LambdaT::capacity_,
03358             LambdaT::primitive_id_
03359         >
03360     >
03361     operator>>= ( xst_lambda_wrap< LambdaT > const& lambda_ )
03362     {
03363         typedef xst_binary_adaptor<
03364             xst_lambda_wrap< typename LambdaT::reference_T >,
03365             xst_lambda_wrap< typename LambdaT::reference_T >,
03366             xst_right_shift_assignment_policy<
03367                 LambdaT::capacity_,
03368                 LambdaT::capacity_,
03369                 LambdaT::primitive_id_
03370             >
03371         > xst_adaptor_T;
03372 
03373         return xst_adaptor_T( make_reference(), lambda_.make_reference() );
03374     }
03375 
03376 // generated by gmu/lambda/operators/assign/assign_funcs.h:175
03396     template< typename OtherLambdaT, typename PolicyAdaptorT >
03397     xst_binary_adaptor<
03398         xst_lambda_wrap< typename LambdaT::reference_T >,
03399         xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
03400         xst_right_shift_assignment_policy<
03401             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
03402             LambdaT::capacity_,
03403             LambdaT::primitive_id_
03404         >
03405     >
03406     operator>>= ( xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT > const& unary_adaptor_ )
03407     {
03408         typedef xst_binary_adaptor<
03409             xst_lambda_wrap< typename LambdaT::reference_T >,
03410             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
03411             xst_right_shift_assignment_policy<
03412                 xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
03413                 LambdaT::capacity_,
03414                 LambdaT::primitive_id_
03415             >
03416         > xst_adaptor_T;
03417 
03418         return xst_adaptor_T( make_reference(), unary_adaptor_ );
03419     }
03420 
03421 // generated by gmu/lambda/operators/assign/assign_funcs.h:220
03445     template< typename LambdaLhsT, typename LambdaRhsT, typename PolicyAdaptorT >
03446     xst_binary_adaptor<
03447         xst_lambda_wrap< typename LambdaT::reference_T >,
03448         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
03449         xst_right_shift_assignment_policy<
03450             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
03451             LambdaT::capacity_,
03452             LambdaT::primitive_id_
03453         >
03454     >
03455     operator>>= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT > const& binary_adaptor_ )
03456     {
03457         typedef xst_binary_adaptor<
03458             xst_lambda_wrap< typename LambdaT::reference_T >,
03459             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
03460             xst_right_shift_assignment_policy<
03461                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
03462                 LambdaT::capacity_,
03463                 LambdaT::primitive_id_
03464             >
03465         > xst_adaptor_T;
03466 
03467         return xst_adaptor_T( make_reference(), binary_adaptor_ );
03468     }
03469 
03471 // More >>= assignment abbreviations
03473 // generated by gmu/lambda/operators/assign/assign_funcs.h:272
03489     template< typename StackValueT >
03490     xst_binary_adaptor<
03491         xst_lambda_wrap< typename LambdaT::reference_T >,
03492         xst_lambda_wrap< xst_scalar< StackValueT > >,
03493         xst_right_shift_assignment_policy<
03494             1, // xst_scalar capacity
03495             LambdaT::capacity_,
03496             LambdaT::primitive_id_
03497         >
03498     >
03499     operator>>= ( std::stack< StackValueT > const& stack_ )
03500     {
03501         typedef xst_binary_adaptor<
03502             xst_lambda_wrap< typename LambdaT::reference_T >,
03503             xst_lambda_wrap< xst_scalar< StackValueT > >,
03504             xst_right_shift_assignment_policy<
03505                 1, // xst_scalar capacity
03506                 LambdaT::capacity_,
03507                 LambdaT::primitive_id_
03508             >
03509         > xst_adaptor_T;
03510 
03511         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
03512         return xst_adaptor_T(
03513             make_reference(),
03514             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
03515             );
03516     }
03517 
03518 // generated by gmu/lambda/operators/assign/assign_funcs.h:317
03534     template< typename StackValueT >
03535     xst_binary_adaptor<
03536         xst_lambda_wrap< typename LambdaT::reference_T >,
03537         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
03538         xst_right_shift_assignment_policy<
03539             1, // xst_stack capacity
03540             LambdaT::capacity_,
03541             LambdaT::primitive_id_
03542         >
03543     >
03544     operator>>= ( std::stack< StackValueT >* pstack_ )
03545     {
03546         typedef xst_binary_adaptor<
03547             xst_lambda_wrap< typename LambdaT::reference_T >,
03548             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
03549             xst_right_shift_assignment_policy<
03550                 1, // xst_stack capacity
03551                 LambdaT::capacity_,
03552                 LambdaT::primitive_id_
03553             >
03554         > xst_adaptor_T;
03555 
03556         return xst_adaptor_T(
03557             make_reference(),
03558             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
03559             );
03560     }
03561 
03563 // Assignment >>= operators end
03565 
03566 // generated by gmu/lambda/gmu_common.h:157
03568 // Assignment &= operators begin
03570 
03572 // Assignment &= abbreviations
03574 // generated by gmu/lambda/operators/assign/assign_funcs.h:8
03589     template< typename RhsValueT >
03590     xst_binary_adaptor<
03591         xst_lambda_wrap< typename LambdaT::reference_T >,
03592         xst_lambda_wrap< xst_scalar< RhsValueT > >,
03593         xst_bitwise_and_assignment_policy<
03594             1, // xst_scalar capacity
03595             LambdaT::capacity_,
03596             LambdaT::primitive_id_
03597         >
03598     >
03599     operator&= ( RhsValueT const& value_ )
03600     {
03601         typedef xst_binary_adaptor<
03602             xst_lambda_wrap< typename LambdaT::reference_T >,
03603             xst_lambda_wrap< xst_scalar< RhsValueT > >,
03604             xst_bitwise_and_assignment_policy<
03605                 1, // xst_scalar capacity
03606                 LambdaT::capacity_,
03607                 LambdaT::primitive_id_
03608             >
03609         > xst_adaptor_T;
03610 
03611         return xst_adaptor_T(
03612             make_reference(),
03613             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
03614             );
03615     }
03616 
03617 // generated by gmu/lambda/operators/assign/assign_funcs.h:51
03632     template< typename RhsValueT >
03633     xst_binary_adaptor<
03634         xst_lambda_wrap< typename LambdaT::reference_T >,
03635         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
03636         xst_bitwise_and_assignment_policy<
03637             1, // xst_scalar capacity
03638             LambdaT::capacity_,
03639             LambdaT::primitive_id_
03640         >
03641     >
03642     operator&= ( RhsValueT* pvalue_ )
03643     {
03644         typedef xst_binary_adaptor<
03645             xst_lambda_wrap< typename LambdaT::reference_T >,
03646             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
03647             xst_bitwise_and_assignment_policy<
03648                 1, // xst_scalar capacity
03649                 LambdaT::capacity_,
03650                 LambdaT::primitive_id_
03651             >
03652         > xst_adaptor_T;
03653 
03654         return xst_adaptor_T(
03655             make_reference(),
03656             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
03657             );
03658     }
03659 
03660 
03662 // Assignment &= specializations
03664 // generated by gmu/lambda/operators/assign/assign_funcs.h:98
03665 
03680     template< typename OtherLambdaT >
03681     xst_binary_adaptor<
03682         xst_lambda_wrap< typename LambdaT::reference_T >,
03683         xst_lambda_wrap< typename OtherLambdaT::reference_T >,
03684         xst_bitwise_and_assignment_policy<
03685             OtherLambdaT::capacity_,
03686             LambdaT::capacity_,
03687             LambdaT::primitive_id_
03688         >
03689     >
03690     operator&= ( xst_lambda_wrap< OtherLambdaT > const& lambda_ )
03691     {
03692         typedef xst_binary_adaptor<
03693             xst_lambda_wrap< typename LambdaT::reference_T >,
03694             xst_lambda_wrap< typename OtherLambdaT::reference_T >,
03695             xst_bitwise_and_assignment_policy<
03696                 OtherLambdaT::capacity_,
03697                 LambdaT::capacity_,
03698                 LambdaT::primitive_id_
03699             >
03700         > xst_adaptor_T;
03701 
03702         return xst_adaptor_T( make_reference(), lambda_.make_reference() );
03703     }
03704 
03705 // generated by gmu/lambda/operators/assign/assign_funcs.h:139
03717     xst_binary_adaptor<
03718         xst_lambda_wrap< typename LambdaT::reference_T >,
03719         xst_lambda_wrap< typename LambdaT::reference_T >,
03720         xst_bitwise_and_assignment_policy<
03721             LambdaT::capacity_,
03722             LambdaT::capacity_,
03723             LambdaT::primitive_id_
03724         >
03725     >
03726     operator&= ( xst_lambda_wrap< LambdaT > const& lambda_ )
03727     {
03728         typedef xst_binary_adaptor<
03729             xst_lambda_wrap< typename LambdaT::reference_T >,
03730             xst_lambda_wrap< typename LambdaT::reference_T >,
03731             xst_bitwise_and_assignment_policy<
03732                 LambdaT::capacity_,
03733                 LambdaT::capacity_,
03734                 LambdaT::primitive_id_
03735             >
03736         > xst_adaptor_T;
03737 
03738         return xst_adaptor_T( make_reference(), lambda_.make_reference() );
03739     }
03740 
03741 // generated by gmu/lambda/operators/assign/assign_funcs.h:175
03761     template< typename OtherLambdaT, typename PolicyAdaptorT >
03762     xst_binary_adaptor<
03763         xst_lambda_wrap< typename LambdaT::reference_T >,
03764         xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
03765         xst_bitwise_and_assignment_policy<
03766             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
03767             LambdaT::capacity_,
03768             LambdaT::primitive_id_
03769         >
03770     >
03771     operator&= ( xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT > const& unary_adaptor_ )
03772     {
03773         typedef xst_binary_adaptor<
03774             xst_lambda_wrap< typename LambdaT::reference_T >,
03775             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
03776             xst_bitwise_and_assignment_policy<
03777                 xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
03778                 LambdaT::capacity_,
03779                 LambdaT::primitive_id_
03780             >
03781         > xst_adaptor_T;
03782 
03783         return xst_adaptor_T( make_reference(), unary_adaptor_ );
03784     }
03785 
03786 // generated by gmu/lambda/operators/assign/assign_funcs.h:220
03810     template< typename LambdaLhsT, typename LambdaRhsT, typename PolicyAdaptorT >
03811     xst_binary_adaptor<
03812         xst_lambda_wrap< typename LambdaT::reference_T >,
03813         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
03814         xst_bitwise_and_assignment_policy<
03815             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
03816             LambdaT::capacity_,
03817             LambdaT::primitive_id_
03818         >
03819     >
03820     operator&= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT > const& binary_adaptor_ )
03821     {
03822         typedef xst_binary_adaptor<
03823             xst_lambda_wrap< typename LambdaT::reference_T >,
03824             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
03825             xst_bitwise_and_assignment_policy<
03826                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
03827                 LambdaT::capacity_,
03828                 LambdaT::primitive_id_
03829             >
03830         > xst_adaptor_T;
03831 
03832         return xst_adaptor_T( make_reference(), binary_adaptor_ );
03833     }
03834 
03836 // More &= assignment abbreviations
03838 // generated by gmu/lambda/operators/assign/assign_funcs.h:272
03854     template< typename StackValueT >
03855     xst_binary_adaptor<
03856         xst_lambda_wrap< typename LambdaT::reference_T >,
03857         xst_lambda_wrap< xst_scalar< StackValueT > >,
03858         xst_bitwise_and_assignment_policy<
03859             1, // xst_scalar capacity
03860             LambdaT::capacity_,
03861             LambdaT::primitive_id_
03862         >
03863     >
03864     operator&= ( std::stack< StackValueT > const& stack_ )
03865     {
03866         typedef xst_binary_adaptor<
03867             xst_lambda_wrap< typename LambdaT::reference_T >,
03868             xst_lambda_wrap< xst_scalar< StackValueT > >,
03869             xst_bitwise_and_assignment_policy<
03870                 1, // xst_scalar capacity
03871                 LambdaT::capacity_,
03872                 LambdaT::primitive_id_
03873             >
03874         > xst_adaptor_T;
03875 
03876         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
03877         return xst_adaptor_T(
03878             make_reference(),
03879             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
03880             );
03881     }
03882 
03883 // generated by gmu/lambda/operators/assign/assign_funcs.h:317
03899     template< typename StackValueT >
03900     xst_binary_adaptor<
03901         xst_lambda_wrap< typename LambdaT::reference_T >,
03902         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
03903         xst_bitwise_and_assignment_policy<
03904             1, // xst_stack capacity
03905             LambdaT::capacity_,
03906             LambdaT::primitive_id_
03907         >
03908     >
03909     operator&= ( std::stack< StackValueT >* pstack_ )
03910     {
03911         typedef xst_binary_adaptor<
03912             xst_lambda_wrap< typename LambdaT::reference_T >,
03913             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
03914             xst_bitwise_and_assignment_policy<
03915                 1, // xst_stack capacity
03916                 LambdaT::capacity_,
03917                 LambdaT::primitive_id_
03918             >
03919         > xst_adaptor_T;
03920 
03921         return xst_adaptor_T(
03922             make_reference(),
03923             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
03924             );
03925     }
03926 
03928 // Assignment &= operators end
03930 
03931 // generated by gmu/lambda/gmu_common.h:157
03933 // Assignment |= operators begin
03935 
03937 // Assignment |= abbreviations
03939 // generated by gmu/lambda/operators/assign/assign_funcs.h:8
03954     template< typename RhsValueT >
03955     xst_binary_adaptor<
03956         xst_lambda_wrap< typename LambdaT::reference_T >,
03957         xst_lambda_wrap< xst_scalar< RhsValueT > >,
03958         xst_bitwise_ior_assignment_policy<
03959             1, // xst_scalar capacity
03960             LambdaT::capacity_,
03961             LambdaT::primitive_id_
03962         >
03963     >
03964     operator|= ( RhsValueT const& value_ )
03965     {
03966         typedef xst_binary_adaptor<
03967             xst_lambda_wrap< typename LambdaT::reference_T >,
03968             xst_lambda_wrap< xst_scalar< RhsValueT > >,
03969             xst_bitwise_ior_assignment_policy<
03970                 1, // xst_scalar capacity
03971                 LambdaT::capacity_,
03972                 LambdaT::primitive_id_
03973             >
03974         > xst_adaptor_T;
03975 
03976         return xst_adaptor_T(
03977             make_reference(),
03978             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
03979             );
03980     }
03981 
03982 // generated by gmu/lambda/operators/assign/assign_funcs.h:51
03997     template< typename RhsValueT >
03998     xst_binary_adaptor<
03999         xst_lambda_wrap< typename LambdaT::reference_T >,
04000         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
04001         xst_bitwise_ior_assignment_policy<
04002             1, // xst_scalar capacity
04003             LambdaT::capacity_,
04004             LambdaT::primitive_id_
04005         >
04006     >
04007     operator|= ( RhsValueT* pvalue_ )
04008     {
04009         typedef xst_binary_adaptor<
04010             xst_lambda_wrap< typename LambdaT::reference_T >,
04011             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
04012             xst_bitwise_ior_assignment_policy<
04013                 1, // xst_scalar capacity
04014                 LambdaT::capacity_,
04015                 LambdaT::primitive_id_
04016             >
04017         > xst_adaptor_T;
04018 
04019         return xst_adaptor_T(
04020             make_reference(),
04021             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
04022             );
04023     }
04024 
04025 
04027 // Assignment |= specializations
04029 // generated by gmu/lambda/operators/assign/assign_funcs.h:98
04030 
04045     template< typename OtherLambdaT >
04046     xst_binary_adaptor<
04047         xst_lambda_wrap< typename LambdaT::reference_T >,
04048         xst_lambda_wrap< typename OtherLambdaT::reference_T >,
04049         xst_bitwise_ior_assignment_policy<
04050             OtherLambdaT::capacity_,
04051             LambdaT::capacity_,
04052             LambdaT::primitive_id_
04053         >
04054     >
04055     operator|= ( xst_lambda_wrap< OtherLambdaT > const& lambda_ )
04056     {
04057         typedef xst_binary_adaptor<
04058             xst_lambda_wrap< typename LambdaT::reference_T >,
04059             xst_lambda_wrap< typename OtherLambdaT::reference_T >,
04060             xst_bitwise_ior_assignment_policy<
04061                 OtherLambdaT::capacity_,
04062                 LambdaT::capacity_,
04063                 LambdaT::primitive_id_
04064             >
04065         > xst_adaptor_T;
04066 
04067         return xst_adaptor_T( make_reference(), lambda_.make_reference() );
04068     }
04069 
04070 // generated by gmu/lambda/operators/assign/assign_funcs.h:139
04082     xst_binary_adaptor<
04083         xst_lambda_wrap< typename LambdaT::reference_T >,
04084         xst_lambda_wrap< typename LambdaT::reference_T >,
04085         xst_bitwise_ior_assignment_policy<
04086             LambdaT::capacity_,
04087             LambdaT::capacity_,
04088             LambdaT::primitive_id_
04089         >
04090     >
04091     operator|= ( xst_lambda_wrap< LambdaT > const& lambda_ )
04092     {
04093         typedef xst_binary_adaptor<
04094             xst_lambda_wrap< typename LambdaT::reference_T >,
04095             xst_lambda_wrap< typename LambdaT::reference_T >,
04096             xst_bitwise_ior_assignment_policy<
04097                 LambdaT::capacity_,
04098                 LambdaT::capacity_,
04099                 LambdaT::primitive_id_
04100             >
04101         > xst_adaptor_T;
04102 
04103         return xst_adaptor_T( make_reference(), lambda_.make_reference() );
04104     }
04105 
04106 // generated by gmu/lambda/operators/assign/assign_funcs.h:175
04126     template< typename OtherLambdaT, typename PolicyAdaptorT >
04127     xst_binary_adaptor<
04128         xst_lambda_wrap< typename LambdaT::reference_T >,
04129         xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
04130         xst_bitwise_ior_assignment_policy<
04131             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
04132             LambdaT::capacity_,
04133             LambdaT::primitive_id_
04134         >
04135     >
04136     operator|= ( xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT > const& unary_adaptor_ )
04137     {
04138         typedef xst_binary_adaptor<
04139             xst_lambda_wrap< typename LambdaT::reference_T >,
04140             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
04141             xst_bitwise_ior_assignment_policy<
04142                 xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
04143                 LambdaT::capacity_,
04144                 LambdaT::primitive_id_
04145             >
04146         > xst_adaptor_T;
04147 
04148         return xst_adaptor_T( make_reference(), unary_adaptor_ );
04149     }
04150 
04151 // generated by gmu/lambda/operators/assign/assign_funcs.h:220
04175     template< typename LambdaLhsT, typename LambdaRhsT, typename PolicyAdaptorT >
04176     xst_binary_adaptor<
04177         xst_lambda_wrap< typename LambdaT::reference_T >,
04178         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
04179         xst_bitwise_ior_assignment_policy<
04180             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
04181             LambdaT::capacity_,
04182             LambdaT::primitive_id_
04183         >
04184     >
04185     operator|= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT > const& binary_adaptor_ )
04186     {
04187         typedef xst_binary_adaptor<
04188             xst_lambda_wrap< typename LambdaT::reference_T >,
04189             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
04190             xst_bitwise_ior_assignment_policy<
04191                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
04192                 LambdaT::capacity_,
04193                 LambdaT::primitive_id_
04194             >
04195         > xst_adaptor_T;
04196 
04197         return xst_adaptor_T( make_reference(), binary_adaptor_ );
04198     }
04199 
04201 // More |= assignment abbreviations
04203 // generated by gmu/lambda/operators/assign/assign_funcs.h:272
04219     template< typename StackValueT >
04220     xst_binary_adaptor<
04221         xst_lambda_wrap< typename LambdaT::reference_T >,
04222         xst_lambda_wrap< xst_scalar< StackValueT > >,
04223         xst_bitwise_ior_assignment_policy<
04224             1, // xst_scalar capacity
04225             LambdaT::capacity_,
04226             LambdaT::primitive_id_
04227         >
04228     >
04229     operator|= ( std::stack< StackValueT > const& stack_ )
04230     {
04231         typedef xst_binary_adaptor<
04232             xst_lambda_wrap< typename LambdaT::reference_T >,
04233             xst_lambda_wrap< xst_scalar< StackValueT > >,
04234             xst_bitwise_ior_assignment_policy<
04235                 1, // xst_scalar capacity
04236                 LambdaT::capacity_,
04237                 LambdaT::primitive_id_
04238             >
04239         > xst_adaptor_T;
04240 
04241         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
04242         return xst_adaptor_T(
04243             make_reference(),
04244             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
04245             );
04246     }
04247 
04248 // generated by gmu/lambda/operators/assign/assign_funcs.h:317
04264     template< typename StackValueT >
04265     xst_binary_adaptor<
04266         xst_lambda_wrap< typename LambdaT::reference_T >,
04267         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
04268         xst_bitwise_ior_assignment_policy<
04269             1, // xst_stack capacity
04270             LambdaT::capacity_,
04271             LambdaT::primitive_id_
04272         >
04273     >
04274     operator|= ( std::stack< StackValueT >* pstack_ )
04275     {
04276         typedef xst_binary_adaptor<
04277             xst_lambda_wrap< typename LambdaT::reference_T >,
04278             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
04279             xst_bitwise_ior_assignment_policy<
04280                 1, // xst_stack capacity
04281                 LambdaT::capacity_,
04282                 LambdaT::primitive_id_
04283             >
04284         > xst_adaptor_T;
04285 
04286         return xst_adaptor_T(
04287             make_reference(),
04288             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
04289             );
04290     }
04291 
04293 // Assignment |= operators end
04295 
04296 // generated by gmu/lambda/gmu_common.h:157
04298 // Assignment ^= operators begin
04300 
04302 // Assignment ^= abbreviations
04304 // generated by gmu/lambda/operators/assign/assign_funcs.h:8
04319     template< typename RhsValueT >
04320     xst_binary_adaptor<
04321         xst_lambda_wrap< typename LambdaT::reference_T >,
04322         xst_lambda_wrap< xst_scalar< RhsValueT > >,
04323         xst_bitwise_xor_assignment_policy<
04324             1, // xst_scalar capacity
04325             LambdaT::capacity_,
04326             LambdaT::primitive_id_
04327         >
04328     >
04329     operator^= ( RhsValueT const& value_ )
04330     {
04331         typedef xst_binary_adaptor<
04332             xst_lambda_wrap< typename LambdaT::reference_T >,
04333             xst_lambda_wrap< xst_scalar< RhsValueT > >,
04334             xst_bitwise_xor_assignment_policy<
04335                 1, // xst_scalar capacity
04336                 LambdaT::capacity_,
04337                 LambdaT::primitive_id_
04338             >
04339         > xst_adaptor_T;
04340 
04341         return xst_adaptor_T(
04342             make_reference(),
04343             xst_lambda_wrap< xst_scalar< RhsValueT > >( value_ )
04344             );
04345     }
04346 
04347 // generated by gmu/lambda/operators/assign/assign_funcs.h:51
04362     template< typename RhsValueT >
04363     xst_binary_adaptor<
04364         xst_lambda_wrap< typename LambdaT::reference_T >,
04365         xst_lambda_wrap< xst_scalar< RhsValueT& > >,
04366         xst_bitwise_xor_assignment_policy<
04367             1, // xst_scalar capacity
04368             LambdaT::capacity_,
04369             LambdaT::primitive_id_
04370         >
04371     >
04372     operator^= ( RhsValueT* pvalue_ )
04373     {
04374         typedef xst_binary_adaptor<
04375             xst_lambda_wrap< typename LambdaT::reference_T >,
04376             xst_lambda_wrap< xst_scalar< RhsValueT& > >,
04377             xst_bitwise_xor_assignment_policy<
04378                 1, // xst_scalar capacity
04379                 LambdaT::capacity_,
04380                 LambdaT::primitive_id_
04381             >
04382         > xst_adaptor_T;
04383 
04384         return xst_adaptor_T(
04385             make_reference(),
04386             xst_lambda_wrap< xst_scalar< RhsValueT& > >( pvalue_ )
04387             );
04388     }
04389 
04390 
04392 // Assignment ^= specializations
04394 // generated by gmu/lambda/operators/assign/assign_funcs.h:98
04395 
04410     template< typename OtherLambdaT >
04411     xst_binary_adaptor<
04412         xst_lambda_wrap< typename LambdaT::reference_T >,
04413         xst_lambda_wrap< typename OtherLambdaT::reference_T >,
04414         xst_bitwise_xor_assignment_policy<
04415             OtherLambdaT::capacity_,
04416             LambdaT::capacity_,
04417             LambdaT::primitive_id_
04418         >
04419     >
04420     operator^= ( xst_lambda_wrap< OtherLambdaT > const& lambda_ )
04421     {
04422         typedef xst_binary_adaptor<
04423             xst_lambda_wrap< typename LambdaT::reference_T >,
04424             xst_lambda_wrap< typename OtherLambdaT::reference_T >,
04425             xst_bitwise_xor_assignment_policy<
04426                 OtherLambdaT::capacity_,
04427                 LambdaT::capacity_,
04428                 LambdaT::primitive_id_
04429             >
04430         > xst_adaptor_T;
04431 
04432         return xst_adaptor_T( make_reference(), lambda_.make_reference() );
04433     }
04434 
04435 // generated by gmu/lambda/operators/assign/assign_funcs.h:139
04447     xst_binary_adaptor<
04448         xst_lambda_wrap< typename LambdaT::reference_T >,
04449         xst_lambda_wrap< typename LambdaT::reference_T >,
04450         xst_bitwise_xor_assignment_policy<
04451             LambdaT::capacity_,
04452             LambdaT::capacity_,
04453             LambdaT::primitive_id_
04454         >
04455     >
04456     operator^= ( xst_lambda_wrap< LambdaT > const& lambda_ )
04457     {
04458         typedef xst_binary_adaptor<
04459             xst_lambda_wrap< typename LambdaT::reference_T >,
04460             xst_lambda_wrap< typename LambdaT::reference_T >,
04461             xst_bitwise_xor_assignment_policy<
04462                 LambdaT::capacity_,
04463                 LambdaT::capacity_,
04464                 LambdaT::primitive_id_
04465             >
04466         > xst_adaptor_T;
04467 
04468         return xst_adaptor_T( make_reference(), lambda_.make_reference() );
04469     }
04470 
04471 // generated by gmu/lambda/operators/assign/assign_funcs.h:175
04491     template< typename OtherLambdaT, typename PolicyAdaptorT >
04492     xst_binary_adaptor<
04493         xst_lambda_wrap< typename LambdaT::reference_T >,
04494         xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
04495         xst_bitwise_xor_assignment_policy<
04496             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
04497             LambdaT::capacity_,
04498             LambdaT::primitive_id_
04499         >
04500     >
04501     operator^= ( xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT > const& unary_adaptor_ )
04502     {
04503         typedef xst_binary_adaptor<
04504             xst_lambda_wrap< typename LambdaT::reference_T >,
04505             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
04506             xst_bitwise_xor_assignment_policy<
04507                 xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
04508                 LambdaT::capacity_,
04509                 LambdaT::primitive_id_
04510             >
04511         > xst_adaptor_T;
04512 
04513         return xst_adaptor_T( make_reference(), unary_adaptor_ );
04514     }
04515 
04516 // generated by gmu/lambda/operators/assign/assign_funcs.h:220
04540     template< typename LambdaLhsT, typename LambdaRhsT, typename PolicyAdaptorT >
04541     xst_binary_adaptor<
04542         xst_lambda_wrap< typename LambdaT::reference_T >,
04543         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
04544         xst_bitwise_xor_assignment_policy<
04545             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
04546             LambdaT::capacity_,
04547             LambdaT::primitive_id_
04548         >
04549     >
04550     operator^= ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT > const& binary_adaptor_ )
04551     {
04552         typedef xst_binary_adaptor<
04553             xst_lambda_wrap< typename LambdaT::reference_T >,
04554             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
04555             xst_bitwise_xor_assignment_policy<
04556                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
04557                 LambdaT::capacity_,
04558                 LambdaT::primitive_id_
04559             >
04560         > xst_adaptor_T;
04561 
04562         return xst_adaptor_T( make_reference(), binary_adaptor_ );
04563     }
04564 
04566 // More ^= assignment abbreviations
04568 // generated by gmu/lambda/operators/assign/assign_funcs.h:272
04584     template< typename StackValueT >
04585     xst_binary_adaptor<
04586         xst_lambda_wrap< typename LambdaT::reference_T >,
04587         xst_lambda_wrap< xst_scalar< StackValueT > >,
04588         xst_bitwise_xor_assignment_policy<
04589             1, // xst_scalar capacity
04590             LambdaT::capacity_,
04591             LambdaT::primitive_id_
04592         >
04593     >
04594     operator^= ( std::stack< StackValueT > const& stack_ )
04595     {
04596         typedef xst_binary_adaptor<
04597             xst_lambda_wrap< typename LambdaT::reference_T >,
04598             xst_lambda_wrap< xst_scalar< StackValueT > >,
04599             xst_bitwise_xor_assignment_policy<
04600                 1, // xst_scalar capacity
04601                 LambdaT::capacity_,
04602                 LambdaT::primitive_id_
04603             >
04604         > xst_adaptor_T;
04605 
04606         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
04607         return xst_adaptor_T(
04608             make_reference(),
04609             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
04610             );
04611     }
04612 
04613 // generated by gmu/lambda/operators/assign/assign_funcs.h:317
04629     template< typename StackValueT >
04630     xst_binary_adaptor<
04631         xst_lambda_wrap< typename LambdaT::reference_T >,
04632         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
04633         xst_bitwise_xor_assignment_policy<
04634             1, // xst_stack capacity
04635             LambdaT::capacity_,
04636             LambdaT::primitive_id_
04637         >
04638     >
04639     operator^= ( std::stack< StackValueT >* pstack_ )
04640     {
04641         typedef xst_binary_adaptor<
04642             xst_lambda_wrap< typename LambdaT::reference_T >,
04643             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
04644             xst_bitwise_xor_assignment_policy<
04645                 1, // xst_stack capacity
04646                 LambdaT::capacity_,
04647                 LambdaT::primitive_id_
04648             >
04649         > xst_adaptor_T;
04650 
04651         return xst_adaptor_T(
04652             make_reference(),
04653             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
04654             );
04655     }
04656 
04658 // Assignment ^= operators end
04660 
04661 
04662 // generated by gmu/lambda/gmu_common.h:607
04663 // on Thu Nov 02 13:01:33 2006.
04664 // generated by gmu/lambda/gmu_common.h:167
04666 // Subscript [] operators begin
04668 
04670 // Subscript abbreviations
04672 // generated by gmu/lambda/operators/subscript/subscript_funcs.h:8
04687     template< typename SubscriptValueT >
04688     xst_binary_adaptor<
04689         xst_lambda_wrap< typename LambdaT::reference_T >,
04690         xst_lambda_wrap< xst_scalar< SubscriptValueT > >,
04691         xst_subscript_policy<
04692             1, // xst_scalar capacity
04693             LambdaT::capacity_,
04694             LambdaT::primitive_id_
04695         >
04696     >
04697     operator[] ( SubscriptValueT const& value_ )
04698     {
04699         typedef xst_binary_adaptor<
04700             xst_lambda_wrap< typename LambdaT::reference_T >,
04701             xst_lambda_wrap< xst_scalar< SubscriptValueT > >,
04702             xst_subscript_policy<
04703                 1, // xst_scalar capacity
04704                 LambdaT::capacity_,
04705                 LambdaT::primitive_id_
04706             >
04707         > xst_adaptor_T;
04708 
04709         return xst_adaptor_T(
04710             make_reference(),
04711             xst_lambda_wrap< xst_scalar< SubscriptValueT > >( value_ )
04712             );
04713     }
04714 
04715 // generated by gmu/lambda/operators/subscript/subscript_funcs.h:51
04730     template< typename SubscriptValueT >
04731     xst_binary_adaptor<
04732         xst_lambda_wrap< typename LambdaT::reference_T >,
04733         xst_lambda_wrap< xst_scalar< SubscriptValueT& > >,
04734         xst_subscript_policy<
04735             1, // xst_scalar capacity
04736             LambdaT::capacity_,
04737             LambdaT::primitive_id_
04738         >
04739     >
04740     operator[] ( SubscriptValueT* pvalue_ )
04741     {
04742         typedef xst_binary_adaptor<
04743             xst_lambda_wrap< typename LambdaT::reference_T >,
04744             xst_lambda_wrap< xst_scalar< SubscriptValueT& > >,
04745             xst_subscript_policy<
04746                 1, // xst_scalar capacity
04747                 LambdaT::capacity_,
04748                 LambdaT::primitive_id_
04749             >
04750         > xst_adaptor_T;
04751 
04752         return xst_adaptor_T(
04753             make_reference(),
04754             xst_lambda_wrap< xst_scalar< SubscriptValueT& > >( pvalue_ )
04755             );
04756     }
04757 
04759 // Subscript [] specializations
04761 // generated by gmu/lambda/operators/subscript/subscript_funcs.h:97
04762 
04777     template< typename OtherLambdaT >
04778     xst_binary_adaptor<
04779         xst_lambda_wrap< typename LambdaT::reference_T >,
04780         xst_lambda_wrap< typename OtherLambdaT::reference_T >,
04781         xst_subscript_policy<
04782             OtherLambdaT::capacity_,
04783             LambdaT::capacity_,
04784             LambdaT::primitive_id_
04785         >
04786     >
04787     operator[] ( xst_lambda_wrap< OtherLambdaT > const& lambda_ )
04788     {
04789         typedef xst_binary_adaptor<
04790             xst_lambda_wrap< typename LambdaT::reference_T >,
04791             xst_lambda_wrap< typename OtherLambdaT::reference_T >,
04792             xst_subscript_policy<
04793                 OtherLambdaT::capacity_,
04794                 LambdaT::capacity_,
04795                 LambdaT::primitive_id_
04796             >
04797         > xst_adaptor_T;
04798 
04799         return xst_adaptor_T( make_reference(), lambda_.make_reference() );
04800     }
04801 
04802 // generated by gmu/lambda/operators/subscript/subscript_funcs.h:138
04822     template< typename OtherLambdaT, typename PolicyAdaptorT >
04823     xst_binary_adaptor<
04824         xst_lambda_wrap< typename LambdaT::reference_T >,
04825         xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
04826         xst_subscript_policy<
04827             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
04828             LambdaT::capacity_,
04829             LambdaT::primitive_id_
04830         >
04831     >
04832     operator[] ( xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT > const& unary_adaptor_ )
04833     {
04834         typedef xst_binary_adaptor<
04835             xst_lambda_wrap< typename LambdaT::reference_T >,
04836             xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >,
04837             xst_subscript_policy<
04838                 xst_unary_adaptor< OtherLambdaT, PolicyAdaptorT >::capacity_,
04839                 LambdaT::capacity_,
04840                 LambdaT::primitive_id_
04841             >
04842         > xst_adaptor_T;
04843 
04844         return xst_adaptor_T( make_reference(), unary_adaptor_ );
04845     }
04846 
04847 // generated by gmu/lambda/operators/subscript/subscript_funcs.h:183
04871     template< typename LambdaLhsT, typename LambdaRhsT, typename PolicyAdaptorT >
04872     xst_binary_adaptor<
04873         xst_lambda_wrap< typename LambdaT::reference_T >,
04874         xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
04875         xst_subscript_policy<
04876             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
04877             LambdaT::capacity_,
04878             LambdaT::primitive_id_
04879         >
04880     >
04881     operator[] ( xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT > const& binary_adaptor_ )
04882     {
04883         typedef xst_binary_adaptor<
04884             xst_lambda_wrap< typename LambdaT::reference_T >,
04885             xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >,
04886             xst_subscript_policy<
04887                 xst_binary_adaptor< LambdaLhsT, LambdaRhsT, PolicyAdaptorT >::capacity_,
04888                 LambdaT::capacity_,
04889                 LambdaT::primitive_id_
04890             >
04891         > xst_adaptor_T;
04892 
04893         return xst_adaptor_T( make_reference(), binary_adaptor_ );
04894     }
04895 
04896 
04898 // More subscript abbreviations
04900 // generated by gmu/lambda/operators/subscript/subscript_funcs.h:236
04920     template< typename StackValueT >
04921     xst_binary_adaptor<
04922         xst_lambda_wrap< typename LambdaT::reference_T >,
04923         xst_lambda_wrap< xst_scalar< StackValueT > >,
04924         xst_subscript_policy<
04925             1, // xst_scalar capacity
04926             LambdaT::capacity_,
04927             LambdaT::primitive_id_
04928         >
04929     >
04930     operator[] ( std::stack< StackValueT > const& stack_ )
04931     {
04932         typedef xst_binary_adaptor<
04933             xst_lambda_wrap< typename LambdaT::reference_T >,
04934             xst_lambda_wrap< xst_scalar< StackValueT > >,
04935             xst_subscript_policy<
04936                 1, // xst_scalar capacity
04937                 LambdaT::capacity_,
04938                 LambdaT::primitive_id_
04939             >
04940         > xst_adaptor_T;
04941 
04942         assert( !stack_.empty() );  // have you forgot to pass stack by address, instead of passing it by value?
04943         return xst_adaptor_T(
04944             make_reference(),
04945             xst_lambda_wrap< xst_scalar< StackValueT > >( stack_.top() )
04946             );
04947     }
04948 
04949 // generated by gmu/lambda/operators/subscript/subscript_funcs.h:285
04968     template< typename StackValueT >
04969     xst_binary_adaptor<
04970         xst_lambda_wrap< typename LambdaT::reference_T >,
04971         xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
04972         xst_subscript_policy<
04973             1, // xst_scalar capacity
04974             LambdaT::capacity_,
04975             LambdaT::primitive_id_
04976         >
04977     >
04978     operator[] ( std::stack< StackValueT >* pstack_ )
04979     {
04980         typedef xst_binary_adaptor<
04981             xst_lambda_wrap< typename LambdaT::reference_T >,
04982             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >,
04983             xst_subscript_policy<
04984                 1, // xst_scalar capacity
04985                 LambdaT::capacity_,
04986                 LambdaT::primitive_id_
04987             >
04988         > xst_adaptor_T;
04989 
04990         return xst_adaptor_T(
04991             make_reference(),
04992             xst_lambda_wrap< xst_stack< std::stack< StackValueT >& > >( pstack_ )
04993             );
04994     }
04995 
04997 // Subscript [] operators end
04999 
05000 //end_generated_code
05001 
05002 
05003 };  // xst_lambda_wrap
05004 
05005 
05006 }   // namespace cttl_impl
05007 
05008 
05009 #endif //_XST_BASE_H_INCLUDED_
Generated on Thu Nov 2 17:48:21 2006 for CTTL Lambda Expression by  doxygen 1.3.9.1