CTTL Lambda Expression: xst_member_alias

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 
00034 // xst_member_alias_bitset.h
00035 
00036 #ifndef _XST_MEMBER_ALIAS_BITSET_H_INCLUDED_
00037 #define _XST_MEMBER_ALIAS_BITSET_H_INCLUDED_
00038 
00039 
00040 namespace cttl_impl {
00041 
00046 template< size_t N >
00047 struct xst_non_scalar_traits< std::bitset<N> >
00048 {
00049     typedef std::bitset<N> value_type;
00050 
00051     static char identity( value_type const& )
00052     {
00053         return '?';
00054     }
00055 
00056 }; // struct xst_non_scalar_traits
00057 
00058 }   // namespace cttl_impl
00059 
00060 
00061 
00062 namespace cttl {
00063 
00064 using namespace cttl_impl;
00065 
00066 namespace alias {
00067 
00080 template< size_t N, typename LambdaT >
00081 inline
00082 xst_unary_adaptor<
00083     xst_lambda_wrap<
00084         xst_scalar<
00085             xst_member_action<
00086                 /*ObjectT*/         typename LambdaT::value_T &,
00087                 /*MemberActionT*/   std::mem_fun_t<
00088                                         /*ResultT*/std::bitset<N>&,
00089                                         /*ObjectT*/typename LambdaT::value_T
00090                                     >,
00091                 /*ArgumentT*/       void,
00092                 /*ResultT*/         std::bitset<N>&
00093             >
00094         >
00095     >
00096     ,
00097     xst_dereference_policy<
00098         xst_dereference_traits<
00099             /*ObjectT*/ typename LambdaT::value_T,
00100             /*ResultT*/ std::bitset<N>&
00101         >::capacity_,
00102         LambdaT::primitive_id_
00103     >
00104 >
00105 flip(
00106     xst_lambda_wrap< LambdaT >* plambda_
00107     )
00108 {
00109     typedef typename LambdaT::value_T object_T;
00110     typedef std::bitset<N>& result_T;
00111     typedef xst_unary_adaptor<
00112         xst_lambda_wrap<
00113             xst_scalar<
00114                 xst_member_action<
00115                     /*ObjectT*/         typename LambdaT::value_T &,
00116                     /*MemberActionT*/   std::mem_fun_t<
00117                                             /*ResultT*/std::bitset<N>&,
00118                                             /*ObjectT*/typename LambdaT::value_T
00119                                         >,
00120                     /*ArgumentT*/       void,
00121                     /*ResultT*/         std::bitset<N>&
00122                 >
00123             >
00124         >
00125         ,
00126         xst_dereference_policy<
00127             xst_dereference_traits<
00128                 /*ObjectT*/ typename LambdaT::value_T,
00129                 /*ResultT*/ std::bitset<N>&
00130             >::capacity_,
00131             LambdaT::primitive_id_
00132         >
00133     >
00134     xst_adaptor_T;
00135 
00136     return xst_adaptor_T( scalar(
00137 #ifdef CTTL_TRACE_DEPOSITS
00138             xst_traced_action(
00139                 __LINE__,
00140                 "std::bitset<N>& alias::flip()",
00141 #else
00142             action(
00143 #endif // CTTL_TRACE_DEPOSITS
00144                 &plambda_->top( const_scalar( 0 ) ),
00145                 ( std::mem_fun_t<
00146                     result_T,
00147                     object_T
00148                     >
00149                     ( &object_T::flip )
00150                 )
00151             )
00152         ))
00153         ;
00154 }
00155 
00168 template< size_t N, typename LambdaT, typename ArgumentT >
00169 inline
00170 xst_unary_adaptor<
00171     xst_lambda_wrap<
00172         xst_scalar<
00173             xst_member_action<
00174                 /*ObjectT*/         typename LambdaT::value_T &,
00175                 /*MemberActionT*/   std::mem_fun1_t<
00176                                         /*ResultT*/std::bitset<N>&,
00177                                         /*ObjectT*/typename LambdaT::value_T,
00178                                         /*ArgumentT*/ArgumentT
00179                                     >,
00180                 /*ArgumentT*/       ArgumentT const&,
00181                 /*ResultT*/         std::bitset<N>&
00182             >
00183         >
00184     >
00185     ,
00186     xst_dereference_policy<
00187         xst_dereference_traits<
00188             /*ObjectT*/ typename LambdaT::value_T,
00189             /*ResultT*/ std::bitset<N>&
00190         >::capacity_,
00191         LambdaT::primitive_id_
00192     >
00193 >
00194 flip(
00195     xst_lambda_wrap< LambdaT >* plambda_,
00196     // Although flip() receives its argument by value,
00197     // this helper passes it by const reference.
00198     ArgumentT const& arg_
00199     )
00200 {
00201     typedef typename LambdaT::value_T object_T;
00202     typedef std::bitset<N>& result_T;
00203     typedef xst_unary_adaptor<
00204         xst_lambda_wrap<
00205             xst_scalar<
00206                 xst_member_action<
00207                     /*ObjectT*/         typename LambdaT::value_T &,
00208                     /*MemberActionT*/   std::mem_fun1_t<
00209                                             /*ResultT*/std::bitset<N>&,
00210                                             /*ObjectT*/typename LambdaT::value_T,
00211                                             /*ArgumentT*/ArgumentT
00212                                         >,
00213                     /*ArgumentT*/       ArgumentT const&,
00214                     /*ResultT*/         std::bitset<N>&
00215                 >
00216             >
00217         >
00218         ,
00219         xst_dereference_policy<
00220             xst_dereference_traits<
00221                 /*ObjectT*/ typename LambdaT::value_T,
00222                 /*ResultT*/ std::bitset<N>&
00223             >::capacity_,
00224             LambdaT::primitive_id_
00225         >
00226     >
00227     xst_adaptor_T;
00228 
00229     return xst_adaptor_T( scalar(
00230 #ifdef CTTL_TRACE_DEPOSITS
00231             xst_traced_action(
00232                 __LINE__,
00233                 "std::bitset<N>& alias::flip(size_t)",
00234 #else
00235             action(
00236 #endif // CTTL_TRACE_DEPOSITS
00237                 &plambda_->top( const_scalar( 0 ) ),
00238                 ( std::mem_fun1_t<
00239                     result_T,
00240                     object_T,
00241                     ArgumentT
00242                     >
00243                     ( &object_T::flip )
00244                 ),
00245                 arg_
00246             )
00247         ))
00248         ;
00249 }
00250 
00263 template< size_t N, typename LambdaT >
00264 inline
00265 xst_unary_adaptor<
00266     xst_lambda_wrap<
00267         xst_scalar<
00268             xst_member_action<
00269                 /*ObjectT*/         typename LambdaT::value_T &,
00270                 /*MemberActionT*/   std::mem_fun_t<
00271                                         /*ResultT*/std::bitset<N>&,
00272                                         /*ObjectT*/typename LambdaT::value_T
00273                                     >,
00274                 /*ArgumentT*/       void,
00275                 /*ResultT*/         std::bitset<N>&
00276             >
00277         >
00278     >
00279     ,
00280     xst_dereference_policy<
00281         xst_dereference_traits<
00282             /*ObjectT*/ typename LambdaT::value_T,
00283             /*ResultT*/ std::bitset<N>&
00284         >::capacity_,
00285         LambdaT::primitive_id_
00286     >
00287 >
00288 reset(
00289     xst_lambda_wrap< LambdaT >* plambda_
00290     )
00291 {
00292     typedef typename LambdaT::value_T object_T;
00293     typedef std::bitset<N>& result_T;
00294     typedef xst_unary_adaptor<
00295         xst_lambda_wrap<
00296             xst_scalar<
00297                 xst_member_action<
00298                     /*ObjectT*/         typename LambdaT::value_T &,
00299                     /*MemberActionT*/   std::mem_fun_t<
00300                                             /*ResultT*/std::bitset<N>&,
00301                                             /*ObjectT*/typename LambdaT::value_T
00302                                         >,
00303                     /*ArgumentT*/       void,
00304                     /*ResultT*/         std::bitset<N>&
00305                 >
00306             >
00307         >
00308         ,
00309         xst_dereference_policy<
00310             xst_dereference_traits<
00311                 /*ObjectT*/ typename LambdaT::value_T,
00312                 /*ResultT*/ std::bitset<N>&
00313             >::capacity_,
00314             LambdaT::primitive_id_
00315         >
00316     >
00317     xst_adaptor_T;
00318 
00319     return xst_adaptor_T( scalar(
00320 #ifdef CTTL_TRACE_DEPOSITS
00321             xst_traced_action(
00322                 __LINE__,
00323                 "std::bitset<N>& alias::reset()",
00324 #else
00325             action(
00326 #endif // CTTL_TRACE_DEPOSITS
00327                 &plambda_->top( const_scalar( 0 ) ),
00328                 ( std::mem_fun_t<
00329                     result_T,
00330                     object_T
00331                     >
00332                     ( &object_T::reset )
00333                 )
00334             )
00335         ))
00336         ;
00337 }
00338 
00351 template< size_t N, typename LambdaT, typename ArgumentT >
00352 inline
00353 xst_unary_adaptor<
00354     xst_lambda_wrap<
00355         xst_scalar<
00356             xst_member_action<
00357                 /*ObjectT*/         typename LambdaT::value_T &,
00358                 /*MemberActionT*/   std::mem_fun1_t<
00359                                         /*ResultT*/std::bitset<N>&,
00360                                         /*ObjectT*/typename LambdaT::value_T,
00361                                         /*ArgumentT*/ArgumentT
00362                                     >,
00363                 /*ArgumentT*/       ArgumentT const&,
00364                 /*ResultT*/         std::bitset<N>&
00365             >
00366         >
00367     >
00368     ,
00369     xst_dereference_policy<
00370         xst_dereference_traits<
00371             /*ObjectT*/ typename LambdaT::value_T,
00372             /*ResultT*/ std::bitset<N>&
00373         >::capacity_,
00374         LambdaT::primitive_id_
00375     >
00376 >
00377 reset(
00378     xst_lambda_wrap< LambdaT >* plambda_,
00379     // Although reset() receives its argument by value,
00380     // this helper passes it by const reference.
00381     ArgumentT const& arg_
00382     )
00383 {
00384     typedef typename LambdaT::value_T object_T;
00385     typedef std::bitset<N>& result_T;
00386     typedef xst_unary_adaptor<
00387         xst_lambda_wrap<
00388             xst_scalar<
00389                 xst_member_action<
00390                     /*ObjectT*/         typename LambdaT::value_T &,
00391                     /*MemberActionT*/   std::mem_fun1_t<
00392                                             /*ResultT*/std::bitset<N>&,
00393                                             /*ObjectT*/typename LambdaT::value_T,
00394                                             /*ArgumentT*/ArgumentT
00395                                         >,
00396                     /*ArgumentT*/       ArgumentT const&,
00397                     /*ResultT*/         std::bitset<N>&
00398                 >
00399             >
00400         >
00401         ,
00402         xst_dereference_policy<
00403             xst_dereference_traits<
00404                 /*ObjectT*/ typename LambdaT::value_T,
00405                 /*ResultT*/ std::bitset<N>&
00406             >::capacity_,
00407             LambdaT::primitive_id_
00408         >
00409     >
00410     xst_adaptor_T;
00411 
00412     return xst_adaptor_T( scalar(
00413 #ifdef CTTL_TRACE_DEPOSITS
00414             xst_traced_action(
00415                 __LINE__,
00416                 "std::bitset<N>& alias::reset(size_t)",
00417 #else
00418             action(
00419 #endif // CTTL_TRACE_DEPOSITS
00420                 &plambda_->top( const_scalar( 0 ) ),
00421                 ( std::mem_fun1_t<
00422                     result_T,
00423                     object_T,
00424                     ArgumentT
00425                     >
00426                     ( &object_T::reset )
00427                 ),
00428                 arg_
00429             )
00430         ))
00431         ;
00432 }
00433 
00446 template< size_t N, typename LambdaT >
00447 inline
00448 xst_unary_adaptor<
00449     xst_lambda_wrap<
00450         xst_scalar<
00451             xst_member_action<
00452                 /*ObjectT*/         typename LambdaT::value_T &,
00453                 /*MemberActionT*/   std::mem_fun_t<
00454                                         /*ResultT*/std::bitset<N>&,
00455                                         /*ObjectT*/typename LambdaT::value_T
00456                                     >,
00457                 /*ArgumentT*/       void,
00458                 /*ResultT*/         std::bitset<N>&
00459             >
00460         >
00461     >
00462     ,
00463     xst_dereference_policy<
00464         xst_dereference_traits<
00465             /*ObjectT*/ typename LambdaT::value_T,
00466             /*ResultT*/ std::bitset<N>&
00467         >::capacity_,
00468         LambdaT::primitive_id_
00469     >
00470 >
00471 set(
00472     xst_lambda_wrap< LambdaT >* plambda_
00473     )
00474 {
00475     typedef typename LambdaT::value_T object_T;
00476     typedef std::bitset<N>& result_T;
00477     typedef xst_unary_adaptor<
00478         xst_lambda_wrap<
00479             xst_scalar<
00480                 xst_member_action<
00481                     /*ObjectT*/         typename LambdaT::value_T &,
00482                     /*MemberActionT*/   std::mem_fun_t<
00483                                             /*ResultT*/std::bitset<N>&,
00484                                             /*ObjectT*/typename LambdaT::value_T
00485                                         >,
00486                     /*ArgumentT*/       void,
00487                     /*ResultT*/         std::bitset<N>&
00488                 >
00489             >
00490         >
00491         ,
00492         xst_dereference_policy<
00493             xst_dereference_traits<
00494                 /*ObjectT*/ typename LambdaT::value_T,
00495                 /*ResultT*/ std::bitset<N>&
00496             >::capacity_,
00497             LambdaT::primitive_id_
00498         >
00499     >
00500     xst_adaptor_T;
00501 
00502     return xst_adaptor_T( scalar(
00503 #ifdef CTTL_TRACE_DEPOSITS
00504             xst_traced_action(
00505                 __LINE__,
00506                 "std::bitset<N>& alias::set()",
00507 #else
00508             action(
00509 #endif // CTTL_TRACE_DEPOSITS
00510                 &plambda_->top( const_scalar( 0 ) ),
00511                 ( std::mem_fun_t<
00512                     result_T,
00513                     object_T
00514                     >
00515                     ( &object_T::set )
00516                 )
00517             )
00518         ))
00519         ;
00520 }
00521 
00522 
00523 } // namespace alias
00524 
00525 }   // namespace cttl
00526 
00527 
00528 #endif //_XST_MEMBER_ALIAS_BITSET_H_INCLUDED_