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

xtl_op_speclzd.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 
00037 #ifndef _CTTL_XTL_OP_SPECLZD_H_INCLUDED_
00038 #define _CTTL_XTL_OP_SPECLZD_H_INCLUDED_
00039 
00040 namespace cttl {
00041 
00042 
00043 /* specialization for binary expr + CTTL_STD_CHAR */
00044 template< typename Left_exprT >
00045 inline
00046 xtl_wrap<
00047     xtl_opbinplus<
00048         xtl_wrap< Left_exprT >,
00049         xtl_wrap< xtl_char< CTTL_STD_CHAR > >
00050     >
00051 >
00052 operator+ ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_CHAR rhs_expr_ )
00053 {
00054     typedef
00055         xtl_opbinplus<
00056             xtl_wrap< Left_exprT >,
00057             xtl_wrap< xtl_char< CTTL_STD_CHAR > >
00058         >
00059         opplus_T;
00060 
00061     return xtl_wrap< opplus_T >( opplus_T( lhs_expr_, xtl_char< CTTL_STD_CHAR >( rhs_expr_ ) ) );
00062 }
00063 
00064 
00065 /* specialization for binary CTTL_STD_CHAR + expr */
00066 template< typename Right_exprT >
00067 inline
00068 xtl_wrap<
00069     xtl_opbinplus<
00070         xtl_wrap< xtl_char< CTTL_STD_CHAR > >,
00071         xtl_wrap< Right_exprT >
00072     >
00073 >
00074 operator+ ( CTTL_STD_CHAR lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
00075 {
00076     typedef
00077         xtl_opbinplus<
00078             xtl_wrap< xtl_char< CTTL_STD_CHAR > >,
00079             xtl_wrap< Right_exprT >
00080         >
00081         opplus_T;
00082 
00083     return xtl_wrap< opplus_T >( opplus_T( xtl_char< CTTL_STD_CHAR >( lhs_expr_ ), rhs_expr_ ) );
00084 }
00085 
00086 
00087 /* specialization for binary expr + CTTL_STD_WCHAR */
00088 template< typename Left_exprT >
00089 inline
00090 xtl_wrap<
00091     xtl_opbinplus<
00092         xtl_wrap< Left_exprT >,
00093         xtl_wrap< xtl_char< CTTL_STD_WCHAR > >
00094     >
00095 >
00096 operator+ ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WCHAR rhs_expr_ )
00097 {
00098     typedef
00099         xtl_opbinplus<
00100             xtl_wrap< Left_exprT >,
00101             xtl_wrap< xtl_char< CTTL_STD_WCHAR > >
00102         >
00103         opplus_T;
00104 
00105     return xtl_wrap< opplus_T >( opplus_T( lhs_expr_, xtl_char< CTTL_STD_WCHAR >( rhs_expr_ ) ) );
00106 }
00107 
00108 
00109 /* specialization for binary CTTL_STD_WCHAR + expr */
00110 template< typename Right_exprT >
00111 inline
00112 xtl_wrap<
00113     xtl_opbinplus<
00114         xtl_wrap< xtl_char< CTTL_STD_WCHAR > >,
00115         xtl_wrap< Right_exprT >
00116     >
00117 >
00118 operator+ ( CTTL_STD_WCHAR lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
00119 {
00120     typedef
00121         xtl_opbinplus<
00122             xtl_wrap< xtl_char< CTTL_STD_WCHAR > >,
00123             xtl_wrap< Right_exprT >
00124         >
00125         opplus_T;
00126 
00127     return xtl_wrap< opplus_T >( opplus_T( xtl_char< CTTL_STD_WCHAR >( lhs_expr_ ), rhs_expr_ ) );
00128 }
00129 
00130 
00131 /* specialization for binary expr + bool */
00132 template< typename Left_exprT >
00133 inline
00134 xtl_wrap<
00135     xtl_opbinplus<
00136         xtl_wrap< Left_exprT >,
00137         xtl_wrap< xtl_bool< false > >
00138     >
00139 >
00140 operator+ ( xtl_wrap< Left_exprT > const& lhs_expr_, bool rhs_expr_ )
00141 {
00142     typedef
00143         xtl_opbinplus<
00144             xtl_wrap< Left_exprT >,
00145             xtl_wrap< xtl_bool< false > >
00146         >
00147         opplus_T;
00148 
00149     return xtl_wrap< opplus_T >( opplus_T( lhs_expr_, xtl_bool< false >( rhs_expr_ ) ) );
00150 }
00151 
00152 
00153 /* specialization for binary bool + expr */
00154 template< typename Right_exprT >
00155 inline
00156 xtl_wrap<
00157     xtl_opbinplus<
00158         xtl_wrap< xtl_bool< false > >,
00159         xtl_wrap< Right_exprT >
00160     >
00161 >
00162 operator+ ( bool lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
00163 {
00164     typedef
00165         xtl_opbinplus<
00166             xtl_wrap< xtl_bool< false > >,
00167             xtl_wrap< Right_exprT >
00168         >
00169         opplus_T;
00170 
00171     return xtl_wrap< opplus_T >( opplus_T( xtl_bool< false >( lhs_expr_ ), rhs_expr_ ) );
00172 }
00173 
00174 
00175 /* specialization for binary expr + CTTL_STD_CHAR const* */
00176 template< typename Left_exprT >
00177 inline
00178 xtl_wrap<
00179     xtl_opbinplus<
00180         xtl_wrap< Left_exprT >,
00181         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
00182     >
00183 >
00184 operator+ ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_CHAR const* rhs_expr_ )
00185 {
00186     typedef
00187         xtl_opbinplus<
00188             xtl_wrap< Left_exprT >,
00189             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
00190         >
00191         opplus_T;
00192 
00193     return xtl_wrap< opplus_T >( opplus_T( lhs_expr_, xtl_text_symbol< CTTL_STD_STRING >( rhs_expr_ ) ) );
00194 }
00195 
00196 
00197 /* specialization for binary CTTL_STD_CHAR const* + expr */
00198 template< typename Right_exprT >
00199 inline
00200 xtl_wrap<
00201     xtl_opbinplus<
00202         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
00203         xtl_wrap< Right_exprT >
00204     >
00205 >
00206 operator+ ( CTTL_STD_CHAR const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
00207 {
00208     typedef
00209         xtl_opbinplus<
00210             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
00211             xtl_wrap< Right_exprT >
00212         >
00213         opplus_T;
00214 
00215     return xtl_wrap< opplus_T >( opplus_T( xtl_text_symbol< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
00216 }
00217 
00218 
00219 /* specialization for binary expr + CTTL_STD_STRING const& */
00220 template< typename Left_exprT >
00221 inline
00222 xtl_wrap<
00223     xtl_opbinplus<
00224         xtl_wrap< Left_exprT >,
00225         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
00226     >
00227 >
00228 operator+ ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_STRING const& rhs_expr_ )
00229 {
00230     typedef
00231         xtl_opbinplus<
00232             xtl_wrap< Left_exprT >,
00233             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
00234         >
00235         opplus_T;
00236 
00237     return xtl_wrap< opplus_T >( opplus_T( lhs_expr_, xtl_text_symbol< CTTL_STD_STRING >( rhs_expr_ ) ) );
00238 }
00239 
00240 
00241 /* specialization for binary CTTL_STD_STRING const& + expr */
00242 template< typename Right_exprT >
00243 inline
00244 xtl_wrap<
00245     xtl_opbinplus<
00246         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
00247         xtl_wrap< Right_exprT >
00248     >
00249 >
00250 operator+ ( CTTL_STD_STRING const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
00251 {
00252     typedef
00253         xtl_opbinplus<
00254             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
00255             xtl_wrap< Right_exprT >
00256         >
00257         opplus_T;
00258 
00259     return xtl_wrap< opplus_T >( opplus_T( xtl_text_symbol< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
00260 }
00261 
00262 
00263 /* specialization for binary expr + CTTL_STD_WCHAR const* */
00264 template< typename Left_exprT >
00265 inline
00266 xtl_wrap<
00267     xtl_opbinplus<
00268         xtl_wrap< Left_exprT >,
00269         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
00270     >
00271 >
00272 operator+ ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WCHAR const* rhs_expr_ )
00273 {
00274     typedef
00275         xtl_opbinplus<
00276             xtl_wrap< Left_exprT >,
00277             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
00278         >
00279         opplus_T;
00280 
00281     return xtl_wrap< opplus_T >( opplus_T( lhs_expr_, xtl_text_symbol< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
00282 }
00283 
00284 
00285 /* specialization for binary CTTL_STD_WCHAR const* + expr */
00286 template< typename Right_exprT >
00287 inline
00288 xtl_wrap<
00289     xtl_opbinplus<
00290         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
00291         xtl_wrap< Right_exprT >
00292     >
00293 >
00294 operator+ ( CTTL_STD_WCHAR const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
00295 {
00296     typedef
00297         xtl_opbinplus<
00298             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
00299             xtl_wrap< Right_exprT >
00300         >
00301         opplus_T;
00302 
00303     return xtl_wrap< opplus_T >( opplus_T( xtl_text_symbol< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
00304 }
00305 
00306 
00307 /* specialization for binary expr + CTTL_STD_WSTRING const& */
00308 template< typename Left_exprT >
00309 inline
00310 xtl_wrap<
00311     xtl_opbinplus<
00312         xtl_wrap< Left_exprT >,
00313         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
00314     >
00315 >
00316 operator+ ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WSTRING const& rhs_expr_ )
00317 {
00318     typedef
00319         xtl_opbinplus<
00320             xtl_wrap< Left_exprT >,
00321             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
00322         >
00323         opplus_T;
00324 
00325     return xtl_wrap< opplus_T >( opplus_T( lhs_expr_, xtl_text_symbol< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
00326 }
00327 
00328 
00329 /* specialization for binary CTTL_STD_WSTRING const& + expr */
00330 template< typename Right_exprT >
00331 inline
00332 xtl_wrap<
00333     xtl_opbinplus<
00334         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
00335         xtl_wrap< Right_exprT >
00336     >
00337 >
00338 operator+ ( CTTL_STD_WSTRING const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
00339 {
00340     typedef
00341         xtl_opbinplus<
00342             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
00343             xtl_wrap< Right_exprT >
00344         >
00345         opplus_T;
00346 
00347     return xtl_wrap< opplus_T >( opplus_T( xtl_text_symbol< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
00348 }
00349 
00350 
00351 /* specialization for binary expr + std::set< CTTL_STD_STRING > const& */
00352 template< typename Left_exprT >
00353 inline
00354 xtl_wrap<
00355     xtl_opbinplus<
00356         xtl_wrap< Left_exprT >,
00357         xtl_wrap< xtl_keyword< CTTL_STD_STRING > >
00358     >
00359 >
00360 operator+ ( xtl_wrap< Left_exprT > const& lhs_expr_, std::set< CTTL_STD_STRING > const& rhs_expr_ )
00361 {
00362     typedef
00363         xtl_opbinplus<
00364             xtl_wrap< Left_exprT >,
00365             xtl_wrap< xtl_keyword< CTTL_STD_STRING > >
00366         >
00367         opplus_T;
00368 
00369     return xtl_wrap< opplus_T >( opplus_T( lhs_expr_, xtl_keyword< CTTL_STD_STRING >( rhs_expr_ ) ) );
00370 }
00371 
00372 
00373 /* specialization for binary std::set< CTTL_STD_STRING > const& + expr */
00374 template< typename Right_exprT >
00375 inline
00376 xtl_wrap<
00377     xtl_opbinplus<
00378         xtl_wrap< xtl_keyword< CTTL_STD_STRING > >,
00379         xtl_wrap< Right_exprT >
00380     >
00381 >
00382 operator+ ( std::set< CTTL_STD_STRING > const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
00383 {
00384     typedef
00385         xtl_opbinplus<
00386             xtl_wrap< xtl_keyword< CTTL_STD_STRING > >,
00387             xtl_wrap< Right_exprT >
00388         >
00389         opplus_T;
00390 
00391     return xtl_wrap< opplus_T >( opplus_T( xtl_keyword< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
00392 }
00393 
00394 
00395 /* specialization for binary expr + std::set< CTTL_STD_WSTRING > const& */
00396 template< typename Left_exprT >
00397 inline
00398 xtl_wrap<
00399     xtl_opbinplus<
00400         xtl_wrap< Left_exprT >,
00401         xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >
00402     >
00403 >
00404 operator+ ( xtl_wrap< Left_exprT > const& lhs_expr_, std::set< CTTL_STD_WSTRING > const& rhs_expr_ )
00405 {
00406     typedef
00407         xtl_opbinplus<
00408             xtl_wrap< Left_exprT >,
00409             xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >
00410         >
00411         opplus_T;
00412 
00413     return xtl_wrap< opplus_T >( opplus_T( lhs_expr_, xtl_keyword< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
00414 }
00415 
00416 
00417 /* specialization for binary std::set< CTTL_STD_WSTRING > const& + expr */
00418 template< typename Right_exprT >
00419 inline
00420 xtl_wrap<
00421     xtl_opbinplus<
00422         xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >,
00423         xtl_wrap< Right_exprT >
00424     >
00425 >
00426 operator+ ( std::set< CTTL_STD_WSTRING > const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
00427 {
00428     typedef
00429         xtl_opbinplus<
00430             xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >,
00431             xtl_wrap< Right_exprT >
00432         >
00433         opplus_T;
00434 
00435     return xtl_wrap< opplus_T >( opplus_T( xtl_keyword< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
00436 }
00437 
00438 
00439 /* specialization for binary expr + iswhat_T */
00440 template< typename Left_exprT >
00441 inline
00442 xtl_wrap<
00443     xtl_opbinplus<
00444         xtl_wrap< Left_exprT >,
00445         xtl_wrap< xtl_iswhat_entity >
00446     >
00447 >
00448 operator+ ( xtl_wrap< Left_exprT > const& lhs_expr_, iswhat_T rhs_expr_ )
00449 {
00450     typedef
00451         xtl_opbinplus<
00452             xtl_wrap< Left_exprT >,
00453             xtl_wrap< xtl_iswhat_entity >
00454         >
00455         opplus_T;
00456 
00457     return xtl_wrap< opplus_T >( opplus_T( lhs_expr_, xtl_iswhat_entity( rhs_expr_ ) ) );
00458 }
00459 
00460 
00461 /* specialization for binary iswhat_T + expr */
00462 template< typename Right_exprT >
00463 inline
00464 xtl_wrap<
00465     xtl_opbinplus<
00466         xtl_wrap< xtl_iswhat_entity >,
00467         xtl_wrap< Right_exprT >
00468     >
00469 >
00470 operator+ ( iswhat_T lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
00471 {
00472     typedef
00473         xtl_opbinplus<
00474             xtl_wrap< xtl_iswhat_entity >,
00475             xtl_wrap< Right_exprT >
00476         >
00477         opplus_T;
00478 
00479     return xtl_wrap< opplus_T >( opplus_T( xtl_iswhat_entity( lhs_expr_ ), rhs_expr_ ) );
00480 }
00481 
00482 
00483 /* specialization for binary expr + iswwhat_T */
00484 template< typename Left_exprT >
00485 inline
00486 xtl_wrap<
00487     xtl_opbinplus<
00488         xtl_wrap< Left_exprT >,
00489         xtl_wrap< xtl_iswwhat_entity >
00490     >
00491 >
00492 operator+ ( xtl_wrap< Left_exprT > const& lhs_expr_, iswwhat_T rhs_expr_ )
00493 {
00494     typedef
00495         xtl_opbinplus<
00496             xtl_wrap< Left_exprT >,
00497             xtl_wrap< xtl_iswwhat_entity >
00498         >
00499         opplus_T;
00500 
00501     return xtl_wrap< opplus_T >( opplus_T( lhs_expr_, xtl_iswwhat_entity( rhs_expr_ ) ) );
00502 }
00503 
00504 
00505 /* specialization for binary iswwhat_T + expr */
00506 template< typename Right_exprT >
00507 inline
00508 xtl_wrap<
00509     xtl_opbinplus<
00510         xtl_wrap< xtl_iswwhat_entity >,
00511         xtl_wrap< Right_exprT >
00512     >
00513 >
00514 operator+ ( iswwhat_T lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
00515 {
00516     typedef
00517         xtl_opbinplus<
00518             xtl_wrap< xtl_iswwhat_entity >,
00519             xtl_wrap< Right_exprT >
00520         >
00521         opplus_T;
00522 
00523     return xtl_wrap< opplus_T >( opplus_T( xtl_iswwhat_entity( lhs_expr_ ), rhs_expr_ ) );
00524 }
00525 
00526 
00527 /* specialization for binary expr + CTTL_STD_STRING const* */
00528 template< typename Left_exprT >
00529 inline
00530 xtl_wrap<
00531     xtl_opbinplus<
00532         xtl_wrap< Left_exprT >,
00533         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >
00534     >
00535 >
00536 operator+ ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_STRING const* rhs_expr_ )
00537 {
00538     typedef
00539         xtl_opbinplus<
00540             xtl_wrap< Left_exprT >,
00541             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >
00542         >
00543         opplus_T;
00544 
00545     return xtl_wrap< opplus_T >( opplus_T( lhs_expr_, xtl_text_ref_symbol< CTTL_STD_STRING >( rhs_expr_ ) ) );
00546 }
00547 
00548 
00549 /* specialization for binary CTTL_STD_STRING const* + expr */
00550 template< typename Right_exprT >
00551 inline
00552 xtl_wrap<
00553     xtl_opbinplus<
00554         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >,
00555         xtl_wrap< Right_exprT >
00556     >
00557 >
00558 operator+ ( CTTL_STD_STRING const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
00559 {
00560     typedef
00561         xtl_opbinplus<
00562             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >,
00563             xtl_wrap< Right_exprT >
00564         >
00565         opplus_T;
00566 
00567     return xtl_wrap< opplus_T >( opplus_T( xtl_text_ref_symbol< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
00568 }
00569 
00570 
00571 /* specialization for binary expr + CTTL_STD_WSTRING const* */
00572 template< typename Left_exprT >
00573 inline
00574 xtl_wrap<
00575     xtl_opbinplus<
00576         xtl_wrap< Left_exprT >,
00577         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >
00578     >
00579 >
00580 operator+ ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WSTRING const* rhs_expr_ )
00581 {
00582     typedef
00583         xtl_opbinplus<
00584             xtl_wrap< Left_exprT >,
00585             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >
00586         >
00587         opplus_T;
00588 
00589     return xtl_wrap< opplus_T >( opplus_T( lhs_expr_, xtl_text_ref_symbol< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
00590 }
00591 
00592 
00593 /* specialization for binary CTTL_STD_WSTRING const* + expr */
00594 template< typename Right_exprT >
00595 inline
00596 xtl_wrap<
00597     xtl_opbinplus<
00598         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >,
00599         xtl_wrap< Right_exprT >
00600     >
00601 >
00602 operator+ ( CTTL_STD_WSTRING const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
00603 {
00604     typedef
00605         xtl_opbinplus<
00606             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >,
00607             xtl_wrap< Right_exprT >
00608         >
00609         opplus_T;
00610 
00611     return xtl_wrap< opplus_T >( opplus_T( xtl_text_ref_symbol< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
00612 }
00613 
00614 
00615 
00616 /* specialization for binary expr | CTTL_STD_CHAR */
00617 template< typename Left_exprT >
00618 inline
00619 xtl_wrap<
00620     xtl_opbinpipe<
00621         xtl_wrap< Left_exprT >,
00622         xtl_wrap< xtl_char< CTTL_STD_CHAR > >
00623     >
00624 >
00625 operator| ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_CHAR rhs_expr_ )
00626 {
00627     typedef
00628         xtl_opbinpipe<
00629             xtl_wrap< Left_exprT >,
00630             xtl_wrap< xtl_char< CTTL_STD_CHAR > >
00631         >
00632         oppipe_T;
00633 
00634     return xtl_wrap< oppipe_T >( oppipe_T( lhs_expr_, xtl_char< CTTL_STD_CHAR >( rhs_expr_ ) ) );
00635 }
00636 
00637 
00638 /* specialization for binary CTTL_STD_CHAR | expr */
00639 template< typename Right_exprT >
00640 inline
00641 xtl_wrap<
00642     xtl_opbinpipe<
00643         xtl_wrap< xtl_char< CTTL_STD_CHAR > >,
00644         xtl_wrap< Right_exprT >
00645     >
00646 >
00647 operator| ( CTTL_STD_CHAR lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
00648 {
00649     typedef
00650         xtl_opbinpipe<
00651             xtl_wrap< xtl_char< CTTL_STD_CHAR > >,
00652             xtl_wrap< Right_exprT >
00653         >
00654         oppipe_T;
00655 
00656     return xtl_wrap< oppipe_T >( oppipe_T( xtl_char< CTTL_STD_CHAR >( lhs_expr_ ), rhs_expr_ ) );
00657 }
00658 
00659 
00660 /* specialization for binary expr | CTTL_STD_WCHAR */
00661 template< typename Left_exprT >
00662 inline
00663 xtl_wrap<
00664     xtl_opbinpipe<
00665         xtl_wrap< Left_exprT >,
00666         xtl_wrap< xtl_char< CTTL_STD_WCHAR > >
00667     >
00668 >
00669 operator| ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WCHAR rhs_expr_ )
00670 {
00671     typedef
00672         xtl_opbinpipe<
00673             xtl_wrap< Left_exprT >,
00674             xtl_wrap< xtl_char< CTTL_STD_WCHAR > >
00675         >
00676         oppipe_T;
00677 
00678     return xtl_wrap< oppipe_T >( oppipe_T( lhs_expr_, xtl_char< CTTL_STD_WCHAR >( rhs_expr_ ) ) );
00679 }
00680 
00681 
00682 /* specialization for binary CTTL_STD_WCHAR | expr */
00683 template< typename Right_exprT >
00684 inline
00685 xtl_wrap<
00686     xtl_opbinpipe<
00687         xtl_wrap< xtl_char< CTTL_STD_WCHAR > >,
00688         xtl_wrap< Right_exprT >
00689     >
00690 >
00691 operator| ( CTTL_STD_WCHAR lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
00692 {
00693     typedef
00694         xtl_opbinpipe<
00695             xtl_wrap< xtl_char< CTTL_STD_WCHAR > >,
00696             xtl_wrap< Right_exprT >
00697         >
00698         oppipe_T;
00699 
00700     return xtl_wrap< oppipe_T >( oppipe_T( xtl_char< CTTL_STD_WCHAR >( lhs_expr_ ), rhs_expr_ ) );
00701 }
00702 
00703 
00704 /* specialization for binary expr | bool */
00705 template< typename Left_exprT >
00706 inline
00707 xtl_wrap<
00708     xtl_opbinpipe<
00709         xtl_wrap< Left_exprT >,
00710         xtl_wrap< xtl_bool< false > >
00711     >
00712 >
00713 operator| ( xtl_wrap< Left_exprT > const& lhs_expr_, bool rhs_expr_ )
00714 {
00715     typedef
00716         xtl_opbinpipe<
00717             xtl_wrap< Left_exprT >,
00718             xtl_wrap< xtl_bool< false > >
00719         >
00720         oppipe_T;
00721 
00722     return xtl_wrap< oppipe_T >( oppipe_T( lhs_expr_, xtl_bool< false >( rhs_expr_ ) ) );
00723 }
00724 
00725 
00726 /* specialization for binary bool | expr */
00727 template< typename Right_exprT >
00728 inline
00729 xtl_wrap<
00730     xtl_opbinpipe<
00731         xtl_wrap< xtl_bool< false > >,
00732         xtl_wrap< Right_exprT >
00733     >
00734 >
00735 operator| ( bool lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
00736 {
00737     typedef
00738         xtl_opbinpipe<
00739             xtl_wrap< xtl_bool< false > >,
00740             xtl_wrap< Right_exprT >
00741         >
00742         oppipe_T;
00743 
00744     return xtl_wrap< oppipe_T >( oppipe_T( xtl_bool< false >( lhs_expr_ ), rhs_expr_ ) );
00745 }
00746 
00747 
00748 /* specialization for binary expr | CTTL_STD_CHAR const* */
00749 template< typename Left_exprT >
00750 inline
00751 xtl_wrap<
00752     xtl_opbinpipe<
00753         xtl_wrap< Left_exprT >,
00754         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
00755     >
00756 >
00757 operator| ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_CHAR const* rhs_expr_ )
00758 {
00759     typedef
00760         xtl_opbinpipe<
00761             xtl_wrap< Left_exprT >,
00762             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
00763         >
00764         oppipe_T;
00765 
00766     return xtl_wrap< oppipe_T >( oppipe_T( lhs_expr_, xtl_text_symbol< CTTL_STD_STRING >( rhs_expr_ ) ) );
00767 }
00768 
00769 
00770 /* specialization for binary CTTL_STD_CHAR const* | expr */
00771 template< typename Right_exprT >
00772 inline
00773 xtl_wrap<
00774     xtl_opbinpipe<
00775         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
00776         xtl_wrap< Right_exprT >
00777     >
00778 >
00779 operator| ( CTTL_STD_CHAR const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
00780 {
00781     typedef
00782         xtl_opbinpipe<
00783             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
00784             xtl_wrap< Right_exprT >
00785         >
00786         oppipe_T;
00787 
00788     return xtl_wrap< oppipe_T >( oppipe_T( xtl_text_symbol< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
00789 }
00790 
00791 
00792 /* specialization for binary expr | CTTL_STD_STRING const& */
00793 template< typename Left_exprT >
00794 inline
00795 xtl_wrap<
00796     xtl_opbinpipe<
00797         xtl_wrap< Left_exprT >,
00798         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
00799     >
00800 >
00801 operator| ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_STRING const& rhs_expr_ )
00802 {
00803     typedef
00804         xtl_opbinpipe<
00805             xtl_wrap< Left_exprT >,
00806             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
00807         >
00808         oppipe_T;
00809 
00810     return xtl_wrap< oppipe_T >( oppipe_T( lhs_expr_, xtl_text_symbol< CTTL_STD_STRING >( rhs_expr_ ) ) );
00811 }
00812 
00813 
00814 /* specialization for binary CTTL_STD_STRING const& | expr */
00815 template< typename Right_exprT >
00816 inline
00817 xtl_wrap<
00818     xtl_opbinpipe<
00819         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
00820         xtl_wrap< Right_exprT >
00821     >
00822 >
00823 operator| ( CTTL_STD_STRING const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
00824 {
00825     typedef
00826         xtl_opbinpipe<
00827             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
00828             xtl_wrap< Right_exprT >
00829         >
00830         oppipe_T;
00831 
00832     return xtl_wrap< oppipe_T >( oppipe_T( xtl_text_symbol< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
00833 }
00834 
00835 
00836 /* specialization for binary expr | CTTL_STD_WCHAR const* */
00837 template< typename Left_exprT >
00838 inline
00839 xtl_wrap<
00840     xtl_opbinpipe<
00841         xtl_wrap< Left_exprT >,
00842         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
00843     >
00844 >
00845 operator| ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WCHAR const* rhs_expr_ )
00846 {
00847     typedef
00848         xtl_opbinpipe<
00849             xtl_wrap< Left_exprT >,
00850             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
00851         >
00852         oppipe_T;
00853 
00854     return xtl_wrap< oppipe_T >( oppipe_T( lhs_expr_, xtl_text_symbol< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
00855 }
00856 
00857 
00858 /* specialization for binary CTTL_STD_WCHAR const* | expr */
00859 template< typename Right_exprT >
00860 inline
00861 xtl_wrap<
00862     xtl_opbinpipe<
00863         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
00864         xtl_wrap< Right_exprT >
00865     >
00866 >
00867 operator| ( CTTL_STD_WCHAR const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
00868 {
00869     typedef
00870         xtl_opbinpipe<
00871             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
00872             xtl_wrap< Right_exprT >
00873         >
00874         oppipe_T;
00875 
00876     return xtl_wrap< oppipe_T >( oppipe_T( xtl_text_symbol< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
00877 }
00878 
00879 
00880 /* specialization for binary expr | CTTL_STD_WSTRING const& */
00881 template< typename Left_exprT >
00882 inline
00883 xtl_wrap<
00884     xtl_opbinpipe<
00885         xtl_wrap< Left_exprT >,
00886         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
00887     >
00888 >
00889 operator| ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WSTRING const& rhs_expr_ )
00890 {
00891     typedef
00892         xtl_opbinpipe<
00893             xtl_wrap< Left_exprT >,
00894             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
00895         >
00896         oppipe_T;
00897 
00898     return xtl_wrap< oppipe_T >( oppipe_T( lhs_expr_, xtl_text_symbol< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
00899 }
00900 
00901 
00902 /* specialization for binary CTTL_STD_WSTRING const& | expr */
00903 template< typename Right_exprT >
00904 inline
00905 xtl_wrap<
00906     xtl_opbinpipe<
00907         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
00908         xtl_wrap< Right_exprT >
00909     >
00910 >
00911 operator| ( CTTL_STD_WSTRING const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
00912 {
00913     typedef
00914         xtl_opbinpipe<
00915             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
00916             xtl_wrap< Right_exprT >
00917         >
00918         oppipe_T;
00919 
00920     return xtl_wrap< oppipe_T >( oppipe_T( xtl_text_symbol< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
00921 }
00922 
00923 
00924 /* specialization for binary expr | std::set< CTTL_STD_STRING > const& */
00925 template< typename Left_exprT >
00926 inline
00927 xtl_wrap<
00928     xtl_opbinpipe<
00929         xtl_wrap< Left_exprT >,
00930         xtl_wrap< xtl_keyword< CTTL_STD_STRING > >
00931     >
00932 >
00933 operator| ( xtl_wrap< Left_exprT > const& lhs_expr_, std::set< CTTL_STD_STRING > const& rhs_expr_ )
00934 {
00935     typedef
00936         xtl_opbinpipe<
00937             xtl_wrap< Left_exprT >,
00938             xtl_wrap< xtl_keyword< CTTL_STD_STRING > >
00939         >
00940         oppipe_T;
00941 
00942     return xtl_wrap< oppipe_T >( oppipe_T( lhs_expr_, xtl_keyword< CTTL_STD_STRING >( rhs_expr_ ) ) );
00943 }
00944 
00945 
00946 /* specialization for binary std::set< CTTL_STD_STRING > const& | expr */
00947 template< typename Right_exprT >
00948 inline
00949 xtl_wrap<
00950     xtl_opbinpipe<
00951         xtl_wrap< xtl_keyword< CTTL_STD_STRING > >,
00952         xtl_wrap< Right_exprT >
00953     >
00954 >
00955 operator| ( std::set< CTTL_STD_STRING > const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
00956 {
00957     typedef
00958         xtl_opbinpipe<
00959             xtl_wrap< xtl_keyword< CTTL_STD_STRING > >,
00960             xtl_wrap< Right_exprT >
00961         >
00962         oppipe_T;
00963 
00964     return xtl_wrap< oppipe_T >( oppipe_T( xtl_keyword< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
00965 }
00966 
00967 
00968 /* specialization for binary expr | std::set< CTTL_STD_WSTRING > const& */
00969 template< typename Left_exprT >
00970 inline
00971 xtl_wrap<
00972     xtl_opbinpipe<
00973         xtl_wrap< Left_exprT >,
00974         xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >
00975     >
00976 >
00977 operator| ( xtl_wrap< Left_exprT > const& lhs_expr_, std::set< CTTL_STD_WSTRING > const& rhs_expr_ )
00978 {
00979     typedef
00980         xtl_opbinpipe<
00981             xtl_wrap< Left_exprT >,
00982             xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >
00983         >
00984         oppipe_T;
00985 
00986     return xtl_wrap< oppipe_T >( oppipe_T( lhs_expr_, xtl_keyword< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
00987 }
00988 
00989 
00990 /* specialization for binary std::set< CTTL_STD_WSTRING > const& | expr */
00991 template< typename Right_exprT >
00992 inline
00993 xtl_wrap<
00994     xtl_opbinpipe<
00995         xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >,
00996         xtl_wrap< Right_exprT >
00997     >
00998 >
00999 operator| ( std::set< CTTL_STD_WSTRING > const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
01000 {
01001     typedef
01002         xtl_opbinpipe<
01003             xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >,
01004             xtl_wrap< Right_exprT >
01005         >
01006         oppipe_T;
01007 
01008     return xtl_wrap< oppipe_T >( oppipe_T( xtl_keyword< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
01009 }
01010 
01011 
01012 /* specialization for binary expr | iswhat_T */
01013 template< typename Left_exprT >
01014 inline
01015 xtl_wrap<
01016     xtl_opbinpipe<
01017         xtl_wrap< Left_exprT >,
01018         xtl_wrap< xtl_iswhat_entity >
01019     >
01020 >
01021 operator| ( xtl_wrap< Left_exprT > const& lhs_expr_, iswhat_T rhs_expr_ )
01022 {
01023     typedef
01024         xtl_opbinpipe<
01025             xtl_wrap< Left_exprT >,
01026             xtl_wrap< xtl_iswhat_entity >
01027         >
01028         oppipe_T;
01029 
01030     return xtl_wrap< oppipe_T >( oppipe_T( lhs_expr_, xtl_iswhat_entity( rhs_expr_ ) ) );
01031 }
01032 
01033 
01034 /* specialization for binary iswhat_T | expr */
01035 template< typename Right_exprT >
01036 inline
01037 xtl_wrap<
01038     xtl_opbinpipe<
01039         xtl_wrap< xtl_iswhat_entity >,
01040         xtl_wrap< Right_exprT >
01041     >
01042 >
01043 operator| ( iswhat_T lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
01044 {
01045     typedef
01046         xtl_opbinpipe<
01047             xtl_wrap< xtl_iswhat_entity >,
01048             xtl_wrap< Right_exprT >
01049         >
01050         oppipe_T;
01051 
01052     return xtl_wrap< oppipe_T >( oppipe_T( xtl_iswhat_entity( lhs_expr_ ), rhs_expr_ ) );
01053 }
01054 
01055 
01056 /* specialization for binary expr | iswwhat_T */
01057 template< typename Left_exprT >
01058 inline
01059 xtl_wrap<
01060     xtl_opbinpipe<
01061         xtl_wrap< Left_exprT >,
01062         xtl_wrap< xtl_iswwhat_entity >
01063     >
01064 >
01065 operator| ( xtl_wrap< Left_exprT > const& lhs_expr_, iswwhat_T rhs_expr_ )
01066 {
01067     typedef
01068         xtl_opbinpipe<
01069             xtl_wrap< Left_exprT >,
01070             xtl_wrap< xtl_iswwhat_entity >
01071         >
01072         oppipe_T;
01073 
01074     return xtl_wrap< oppipe_T >( oppipe_T( lhs_expr_, xtl_iswwhat_entity( rhs_expr_ ) ) );
01075 }
01076 
01077 
01078 /* specialization for binary iswwhat_T | expr */
01079 template< typename Right_exprT >
01080 inline
01081 xtl_wrap<
01082     xtl_opbinpipe<
01083         xtl_wrap< xtl_iswwhat_entity >,
01084         xtl_wrap< Right_exprT >
01085     >
01086 >
01087 operator| ( iswwhat_T lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
01088 {
01089     typedef
01090         xtl_opbinpipe<
01091             xtl_wrap< xtl_iswwhat_entity >,
01092             xtl_wrap< Right_exprT >
01093         >
01094         oppipe_T;
01095 
01096     return xtl_wrap< oppipe_T >( oppipe_T( xtl_iswwhat_entity( lhs_expr_ ), rhs_expr_ ) );
01097 }
01098 
01099 
01100 /* specialization for binary expr | CTTL_STD_STRING const* */
01101 template< typename Left_exprT >
01102 inline
01103 xtl_wrap<
01104     xtl_opbinpipe<
01105         xtl_wrap< Left_exprT >,
01106         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >
01107     >
01108 >
01109 operator| ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_STRING const* rhs_expr_ )
01110 {
01111     typedef
01112         xtl_opbinpipe<
01113             xtl_wrap< Left_exprT >,
01114             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >
01115         >
01116         oppipe_T;
01117 
01118     return xtl_wrap< oppipe_T >( oppipe_T( lhs_expr_, xtl_text_ref_symbol< CTTL_STD_STRING >( rhs_expr_ ) ) );
01119 }
01120 
01121 
01122 /* specialization for binary CTTL_STD_STRING const* | expr */
01123 template< typename Right_exprT >
01124 inline
01125 xtl_wrap<
01126     xtl_opbinpipe<
01127         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >,
01128         xtl_wrap< Right_exprT >
01129     >
01130 >
01131 operator| ( CTTL_STD_STRING const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
01132 {
01133     typedef
01134         xtl_opbinpipe<
01135             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >,
01136             xtl_wrap< Right_exprT >
01137         >
01138         oppipe_T;
01139 
01140     return xtl_wrap< oppipe_T >( oppipe_T( xtl_text_ref_symbol< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
01141 }
01142 
01143 
01144 /* specialization for binary expr | CTTL_STD_WSTRING const* */
01145 template< typename Left_exprT >
01146 inline
01147 xtl_wrap<
01148     xtl_opbinpipe<
01149         xtl_wrap< Left_exprT >,
01150         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >
01151     >
01152 >
01153 operator| ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WSTRING const* rhs_expr_ )
01154 {
01155     typedef
01156         xtl_opbinpipe<
01157             xtl_wrap< Left_exprT >,
01158             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >
01159         >
01160         oppipe_T;
01161 
01162     return xtl_wrap< oppipe_T >( oppipe_T( lhs_expr_, xtl_text_ref_symbol< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
01163 }
01164 
01165 
01166 /* specialization for binary CTTL_STD_WSTRING const* | expr */
01167 template< typename Right_exprT >
01168 inline
01169 xtl_wrap<
01170     xtl_opbinpipe<
01171         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >,
01172         xtl_wrap< Right_exprT >
01173     >
01174 >
01175 operator| ( CTTL_STD_WSTRING const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
01176 {
01177     typedef
01178         xtl_opbinpipe<
01179             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >,
01180             xtl_wrap< Right_exprT >
01181         >
01182         oppipe_T;
01183 
01184     return xtl_wrap< oppipe_T >( oppipe_T( xtl_text_ref_symbol< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
01185 }
01186 
01187 
01188 
01189 /* specialization for binary expr || CTTL_STD_CHAR */
01190 template< typename Left_exprT >
01191 inline
01192 xtl_wrap<
01193     xtl_opbin2pipe<
01194         xtl_wrap< Left_exprT >,
01195         xtl_wrap< xtl_char< CTTL_STD_CHAR > >
01196     >
01197 >
01198 operator|| ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_CHAR rhs_expr_ )
01199 {
01200     typedef
01201         xtl_opbin2pipe<
01202             xtl_wrap< Left_exprT >,
01203             xtl_wrap< xtl_char< CTTL_STD_CHAR > >
01204         >
01205         op2pipe_T;
01206 
01207     return xtl_wrap< op2pipe_T >( op2pipe_T( lhs_expr_, xtl_char< CTTL_STD_CHAR >( rhs_expr_ ) ) );
01208 }
01209 
01210 
01211 /* specialization for binary CTTL_STD_CHAR || expr */
01212 template< typename Right_exprT >
01213 inline
01214 xtl_wrap<
01215     xtl_opbin2pipe<
01216         xtl_wrap< xtl_char< CTTL_STD_CHAR > >,
01217         xtl_wrap< Right_exprT >
01218     >
01219 >
01220 operator|| ( CTTL_STD_CHAR lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
01221 {
01222     typedef
01223         xtl_opbin2pipe<
01224             xtl_wrap< xtl_char< CTTL_STD_CHAR > >,
01225             xtl_wrap< Right_exprT >
01226         >
01227         op2pipe_T;
01228 
01229     return xtl_wrap< op2pipe_T >( op2pipe_T( xtl_char< CTTL_STD_CHAR >( lhs_expr_ ), rhs_expr_ ) );
01230 }
01231 
01232 
01233 /* specialization for binary expr || CTTL_STD_WCHAR */
01234 template< typename Left_exprT >
01235 inline
01236 xtl_wrap<
01237     xtl_opbin2pipe<
01238         xtl_wrap< Left_exprT >,
01239         xtl_wrap< xtl_char< CTTL_STD_WCHAR > >
01240     >
01241 >
01242 operator|| ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WCHAR rhs_expr_ )
01243 {
01244     typedef
01245         xtl_opbin2pipe<
01246             xtl_wrap< Left_exprT >,
01247             xtl_wrap< xtl_char< CTTL_STD_WCHAR > >
01248         >
01249         op2pipe_T;
01250 
01251     return xtl_wrap< op2pipe_T >( op2pipe_T( lhs_expr_, xtl_char< CTTL_STD_WCHAR >( rhs_expr_ ) ) );
01252 }
01253 
01254 
01255 /* specialization for binary CTTL_STD_WCHAR || expr */
01256 template< typename Right_exprT >
01257 inline
01258 xtl_wrap<
01259     xtl_opbin2pipe<
01260         xtl_wrap< xtl_char< CTTL_STD_WCHAR > >,
01261         xtl_wrap< Right_exprT >
01262     >
01263 >
01264 operator|| ( CTTL_STD_WCHAR lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
01265 {
01266     typedef
01267         xtl_opbin2pipe<
01268             xtl_wrap< xtl_char< CTTL_STD_WCHAR > >,
01269             xtl_wrap< Right_exprT >
01270         >
01271         op2pipe_T;
01272 
01273     return xtl_wrap< op2pipe_T >( op2pipe_T( xtl_char< CTTL_STD_WCHAR >( lhs_expr_ ), rhs_expr_ ) );
01274 }
01275 
01276 
01277 /* specialization for binary expr || bool */
01278 template< typename Left_exprT >
01279 inline
01280 xtl_wrap<
01281     xtl_opbin2pipe<
01282         xtl_wrap< Left_exprT >,
01283         xtl_wrap< xtl_bool< false > >
01284     >
01285 >
01286 operator|| ( xtl_wrap< Left_exprT > const& lhs_expr_, bool rhs_expr_ )
01287 {
01288     typedef
01289         xtl_opbin2pipe<
01290             xtl_wrap< Left_exprT >,
01291             xtl_wrap< xtl_bool< false > >
01292         >
01293         op2pipe_T;
01294 
01295     return xtl_wrap< op2pipe_T >( op2pipe_T( lhs_expr_, xtl_bool< false >( rhs_expr_ ) ) );
01296 }
01297 
01298 
01299 /* specialization for binary bool || expr */
01300 template< typename Right_exprT >
01301 inline
01302 xtl_wrap<
01303     xtl_opbin2pipe<
01304         xtl_wrap< xtl_bool< false > >,
01305         xtl_wrap< Right_exprT >
01306     >
01307 >
01308 operator|| ( bool lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
01309 {
01310     typedef
01311         xtl_opbin2pipe<
01312             xtl_wrap< xtl_bool< false > >,
01313             xtl_wrap< Right_exprT >
01314         >
01315         op2pipe_T;
01316 
01317     return xtl_wrap< op2pipe_T >( op2pipe_T( xtl_bool< false >( lhs_expr_ ), rhs_expr_ ) );
01318 }
01319 
01320 
01321 /* specialization for binary expr || CTTL_STD_CHAR const* */
01322 template< typename Left_exprT >
01323 inline
01324 xtl_wrap<
01325     xtl_opbin2pipe<
01326         xtl_wrap< Left_exprT >,
01327         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
01328     >
01329 >
01330 operator|| ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_CHAR const* rhs_expr_ )
01331 {
01332     typedef
01333         xtl_opbin2pipe<
01334             xtl_wrap< Left_exprT >,
01335             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
01336         >
01337         op2pipe_T;
01338 
01339     return xtl_wrap< op2pipe_T >( op2pipe_T( lhs_expr_, xtl_text_symbol< CTTL_STD_STRING >( rhs_expr_ ) ) );
01340 }
01341 
01342 
01343 /* specialization for binary CTTL_STD_CHAR const* || expr */
01344 template< typename Right_exprT >
01345 inline
01346 xtl_wrap<
01347     xtl_opbin2pipe<
01348         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
01349         xtl_wrap< Right_exprT >
01350     >
01351 >
01352 operator|| ( CTTL_STD_CHAR const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
01353 {
01354     typedef
01355         xtl_opbin2pipe<
01356             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
01357             xtl_wrap< Right_exprT >
01358         >
01359         op2pipe_T;
01360 
01361     return xtl_wrap< op2pipe_T >( op2pipe_T( xtl_text_symbol< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
01362 }
01363 
01364 
01365 /* specialization for binary expr || CTTL_STD_STRING const& */
01366 template< typename Left_exprT >
01367 inline
01368 xtl_wrap<
01369     xtl_opbin2pipe<
01370         xtl_wrap< Left_exprT >,
01371         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
01372     >
01373 >
01374 operator|| ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_STRING const& rhs_expr_ )
01375 {
01376     typedef
01377         xtl_opbin2pipe<
01378             xtl_wrap< Left_exprT >,
01379             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
01380         >
01381         op2pipe_T;
01382 
01383     return xtl_wrap< op2pipe_T >( op2pipe_T( lhs_expr_, xtl_text_symbol< CTTL_STD_STRING >( rhs_expr_ ) ) );
01384 }
01385 
01386 
01387 /* specialization for binary CTTL_STD_STRING const& || expr */
01388 template< typename Right_exprT >
01389 inline
01390 xtl_wrap<
01391     xtl_opbin2pipe<
01392         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
01393         xtl_wrap< Right_exprT >
01394     >
01395 >
01396 operator|| ( CTTL_STD_STRING const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
01397 {
01398     typedef
01399         xtl_opbin2pipe<
01400             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
01401             xtl_wrap< Right_exprT >
01402         >
01403         op2pipe_T;
01404 
01405     return xtl_wrap< op2pipe_T >( op2pipe_T( xtl_text_symbol< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
01406 }
01407 
01408 
01409 /* specialization for binary expr || CTTL_STD_WCHAR const* */
01410 template< typename Left_exprT >
01411 inline
01412 xtl_wrap<
01413     xtl_opbin2pipe<
01414         xtl_wrap< Left_exprT >,
01415         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
01416     >
01417 >
01418 operator|| ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WCHAR const* rhs_expr_ )
01419 {
01420     typedef
01421         xtl_opbin2pipe<
01422             xtl_wrap< Left_exprT >,
01423             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
01424         >
01425         op2pipe_T;
01426 
01427     return xtl_wrap< op2pipe_T >( op2pipe_T( lhs_expr_, xtl_text_symbol< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
01428 }
01429 
01430 
01431 /* specialization for binary CTTL_STD_WCHAR const* || expr */
01432 template< typename Right_exprT >
01433 inline
01434 xtl_wrap<
01435     xtl_opbin2pipe<
01436         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
01437         xtl_wrap< Right_exprT >
01438     >
01439 >
01440 operator|| ( CTTL_STD_WCHAR const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
01441 {
01442     typedef
01443         xtl_opbin2pipe<
01444             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
01445             xtl_wrap< Right_exprT >
01446         >
01447         op2pipe_T;
01448 
01449     return xtl_wrap< op2pipe_T >( op2pipe_T( xtl_text_symbol< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
01450 }
01451 
01452 
01453 /* specialization for binary expr || CTTL_STD_WSTRING const& */
01454 template< typename Left_exprT >
01455 inline
01456 xtl_wrap<
01457     xtl_opbin2pipe<
01458         xtl_wrap< Left_exprT >,
01459         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
01460     >
01461 >
01462 operator|| ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WSTRING const& rhs_expr_ )
01463 {
01464     typedef
01465         xtl_opbin2pipe<
01466             xtl_wrap< Left_exprT >,
01467             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
01468         >
01469         op2pipe_T;
01470 
01471     return xtl_wrap< op2pipe_T >( op2pipe_T( lhs_expr_, xtl_text_symbol< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
01472 }
01473 
01474 
01475 /* specialization for binary CTTL_STD_WSTRING const& || expr */
01476 template< typename Right_exprT >
01477 inline
01478 xtl_wrap<
01479     xtl_opbin2pipe<
01480         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
01481         xtl_wrap< Right_exprT >
01482     >
01483 >
01484 operator|| ( CTTL_STD_WSTRING const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
01485 {
01486     typedef
01487         xtl_opbin2pipe<
01488             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
01489             xtl_wrap< Right_exprT >
01490         >
01491         op2pipe_T;
01492 
01493     return xtl_wrap< op2pipe_T >( op2pipe_T( xtl_text_symbol< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
01494 }
01495 
01496 
01497 /* specialization for binary expr || std::set< CTTL_STD_STRING > const& */
01498 template< typename Left_exprT >
01499 inline
01500 xtl_wrap<
01501     xtl_opbin2pipe<
01502         xtl_wrap< Left_exprT >,
01503         xtl_wrap< xtl_keyword< CTTL_STD_STRING > >
01504     >
01505 >
01506 operator|| ( xtl_wrap< Left_exprT > const& lhs_expr_, std::set< CTTL_STD_STRING > const& rhs_expr_ )
01507 {
01508     typedef
01509         xtl_opbin2pipe<
01510             xtl_wrap< Left_exprT >,
01511             xtl_wrap< xtl_keyword< CTTL_STD_STRING > >
01512         >
01513         op2pipe_T;
01514 
01515     return xtl_wrap< op2pipe_T >( op2pipe_T( lhs_expr_, xtl_keyword< CTTL_STD_STRING >( rhs_expr_ ) ) );
01516 }
01517 
01518 
01519 /* specialization for binary std::set< CTTL_STD_STRING > const& || expr */
01520 template< typename Right_exprT >
01521 inline
01522 xtl_wrap<
01523     xtl_opbin2pipe<
01524         xtl_wrap< xtl_keyword< CTTL_STD_STRING > >,
01525         xtl_wrap< Right_exprT >
01526     >
01527 >
01528 operator|| ( std::set< CTTL_STD_STRING > const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
01529 {
01530     typedef
01531         xtl_opbin2pipe<
01532             xtl_wrap< xtl_keyword< CTTL_STD_STRING > >,
01533             xtl_wrap< Right_exprT >
01534         >
01535         op2pipe_T;
01536 
01537     return xtl_wrap< op2pipe_T >( op2pipe_T( xtl_keyword< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
01538 }
01539 
01540 
01541 /* specialization for binary expr || std::set< CTTL_STD_WSTRING > const& */
01542 template< typename Left_exprT >
01543 inline
01544 xtl_wrap<
01545     xtl_opbin2pipe<
01546         xtl_wrap< Left_exprT >,
01547         xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >
01548     >
01549 >
01550 operator|| ( xtl_wrap< Left_exprT > const& lhs_expr_, std::set< CTTL_STD_WSTRING > const& rhs_expr_ )
01551 {
01552     typedef
01553         xtl_opbin2pipe<
01554             xtl_wrap< Left_exprT >,
01555             xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >
01556         >
01557         op2pipe_T;
01558 
01559     return xtl_wrap< op2pipe_T >( op2pipe_T( lhs_expr_, xtl_keyword< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
01560 }
01561 
01562 
01563 /* specialization for binary std::set< CTTL_STD_WSTRING > const& || expr */
01564 template< typename Right_exprT >
01565 inline
01566 xtl_wrap<
01567     xtl_opbin2pipe<
01568         xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >,
01569         xtl_wrap< Right_exprT >
01570     >
01571 >
01572 operator|| ( std::set< CTTL_STD_WSTRING > const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
01573 {
01574     typedef
01575         xtl_opbin2pipe<
01576             xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >,
01577             xtl_wrap< Right_exprT >
01578         >
01579         op2pipe_T;
01580 
01581     return xtl_wrap< op2pipe_T >( op2pipe_T( xtl_keyword< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
01582 }
01583 
01584 
01585 /* specialization for binary expr || iswhat_T */
01586 template< typename Left_exprT >
01587 inline
01588 xtl_wrap<
01589     xtl_opbin2pipe<
01590         xtl_wrap< Left_exprT >,
01591         xtl_wrap< xtl_iswhat_entity >
01592     >
01593 >
01594 operator|| ( xtl_wrap< Left_exprT > const& lhs_expr_, iswhat_T rhs_expr_ )
01595 {
01596     typedef
01597         xtl_opbin2pipe<
01598             xtl_wrap< Left_exprT >,
01599             xtl_wrap< xtl_iswhat_entity >
01600         >
01601         op2pipe_T;
01602 
01603     return xtl_wrap< op2pipe_T >( op2pipe_T( lhs_expr_, xtl_iswhat_entity( rhs_expr_ ) ) );
01604 }
01605 
01606 
01607 /* specialization for binary iswhat_T || expr */
01608 template< typename Right_exprT >
01609 inline
01610 xtl_wrap<
01611     xtl_opbin2pipe<
01612         xtl_wrap< xtl_iswhat_entity >,
01613         xtl_wrap< Right_exprT >
01614     >
01615 >
01616 operator|| ( iswhat_T lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
01617 {
01618     typedef
01619         xtl_opbin2pipe<
01620             xtl_wrap< xtl_iswhat_entity >,
01621             xtl_wrap< Right_exprT >
01622         >
01623         op2pipe_T;
01624 
01625     return xtl_wrap< op2pipe_T >( op2pipe_T( xtl_iswhat_entity( lhs_expr_ ), rhs_expr_ ) );
01626 }
01627 
01628 
01629 /* specialization for binary expr || iswwhat_T */
01630 template< typename Left_exprT >
01631 inline
01632 xtl_wrap<
01633     xtl_opbin2pipe<
01634         xtl_wrap< Left_exprT >,
01635         xtl_wrap< xtl_iswwhat_entity >
01636     >
01637 >
01638 operator|| ( xtl_wrap< Left_exprT > const& lhs_expr_, iswwhat_T rhs_expr_ )
01639 {
01640     typedef
01641         xtl_opbin2pipe<
01642             xtl_wrap< Left_exprT >,
01643             xtl_wrap< xtl_iswwhat_entity >
01644         >
01645         op2pipe_T;
01646 
01647     return xtl_wrap< op2pipe_T >( op2pipe_T( lhs_expr_, xtl_iswwhat_entity( rhs_expr_ ) ) );
01648 }
01649 
01650 
01651 /* specialization for binary iswwhat_T || expr */
01652 template< typename Right_exprT >
01653 inline
01654 xtl_wrap<
01655     xtl_opbin2pipe<
01656         xtl_wrap< xtl_iswwhat_entity >,
01657         xtl_wrap< Right_exprT >
01658     >
01659 >
01660 operator|| ( iswwhat_T lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
01661 {
01662     typedef
01663         xtl_opbin2pipe<
01664             xtl_wrap< xtl_iswwhat_entity >,
01665             xtl_wrap< Right_exprT >
01666         >
01667         op2pipe_T;
01668 
01669     return xtl_wrap< op2pipe_T >( op2pipe_T( xtl_iswwhat_entity( lhs_expr_ ), rhs_expr_ ) );
01670 }
01671 
01672 
01673 /* specialization for binary expr || CTTL_STD_STRING const* */
01674 template< typename Left_exprT >
01675 inline
01676 xtl_wrap<
01677     xtl_opbin2pipe<
01678         xtl_wrap< Left_exprT >,
01679         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >
01680     >
01681 >
01682 operator|| ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_STRING const* rhs_expr_ )
01683 {
01684     typedef
01685         xtl_opbin2pipe<
01686             xtl_wrap< Left_exprT >,
01687             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >
01688         >
01689         op2pipe_T;
01690 
01691     return xtl_wrap< op2pipe_T >( op2pipe_T( lhs_expr_, xtl_text_ref_symbol< CTTL_STD_STRING >( rhs_expr_ ) ) );
01692 }
01693 
01694 
01695 /* specialization for binary CTTL_STD_STRING const* || expr */
01696 template< typename Right_exprT >
01697 inline
01698 xtl_wrap<
01699     xtl_opbin2pipe<
01700         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >,
01701         xtl_wrap< Right_exprT >
01702     >
01703 >
01704 operator|| ( CTTL_STD_STRING const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
01705 {
01706     typedef
01707         xtl_opbin2pipe<
01708             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >,
01709             xtl_wrap< Right_exprT >
01710         >
01711         op2pipe_T;
01712 
01713     return xtl_wrap< op2pipe_T >( op2pipe_T( xtl_text_ref_symbol< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
01714 }
01715 
01716 
01717 /* specialization for binary expr || CTTL_STD_WSTRING const* */
01718 template< typename Left_exprT >
01719 inline
01720 xtl_wrap<
01721     xtl_opbin2pipe<
01722         xtl_wrap< Left_exprT >,
01723         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >
01724     >
01725 >
01726 operator|| ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WSTRING const* rhs_expr_ )
01727 {
01728     typedef
01729         xtl_opbin2pipe<
01730             xtl_wrap< Left_exprT >,
01731             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >
01732         >
01733         op2pipe_T;
01734 
01735     return xtl_wrap< op2pipe_T >( op2pipe_T( lhs_expr_, xtl_text_ref_symbol< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
01736 }
01737 
01738 
01739 /* specialization for binary CTTL_STD_WSTRING const* || expr */
01740 template< typename Right_exprT >
01741 inline
01742 xtl_wrap<
01743     xtl_opbin2pipe<
01744         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >,
01745         xtl_wrap< Right_exprT >
01746     >
01747 >
01748 operator|| ( CTTL_STD_WSTRING const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
01749 {
01750     typedef
01751         xtl_opbin2pipe<
01752             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >,
01753             xtl_wrap< Right_exprT >
01754         >
01755         op2pipe_T;
01756 
01757     return xtl_wrap< op2pipe_T >( op2pipe_T( xtl_text_ref_symbol< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
01758 }
01759 
01760 
01761 
01762 /* specialization for binary expr ^ CTTL_STD_CHAR */
01763 template< typename Left_exprT >
01764 inline
01765 xtl_wrap<
01766     xtl_opbinconcat<
01767         xtl_wrap< Left_exprT >,
01768         xtl_wrap< xtl_char< CTTL_STD_CHAR > >
01769     >
01770 >
01771 operator^ ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_CHAR rhs_expr_ )
01772 {
01773     typedef
01774         xtl_opbinconcat<
01775             xtl_wrap< Left_exprT >,
01776             xtl_wrap< xtl_char< CTTL_STD_CHAR > >
01777         >
01778         opconcat_T;
01779 
01780     return xtl_wrap< opconcat_T >( opconcat_T( lhs_expr_, xtl_char< CTTL_STD_CHAR >( rhs_expr_ ) ) );
01781 }
01782 
01783 
01784 /* specialization for binary CTTL_STD_CHAR ^ expr */
01785 template< typename Right_exprT >
01786 inline
01787 xtl_wrap<
01788     xtl_opbinconcat<
01789         xtl_wrap< xtl_char< CTTL_STD_CHAR > >,
01790         xtl_wrap< Right_exprT >
01791     >
01792 >
01793 operator^ ( CTTL_STD_CHAR lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
01794 {
01795     typedef
01796         xtl_opbinconcat<
01797             xtl_wrap< xtl_char< CTTL_STD_CHAR > >,
01798             xtl_wrap< Right_exprT >
01799         >
01800         opconcat_T;
01801 
01802     return xtl_wrap< opconcat_T >( opconcat_T( xtl_char< CTTL_STD_CHAR >( lhs_expr_ ), rhs_expr_ ) );
01803 }
01804 
01805 
01806 /* specialization for binary expr ^ CTTL_STD_WCHAR */
01807 template< typename Left_exprT >
01808 inline
01809 xtl_wrap<
01810     xtl_opbinconcat<
01811         xtl_wrap< Left_exprT >,
01812         xtl_wrap< xtl_char< CTTL_STD_WCHAR > >
01813     >
01814 >
01815 operator^ ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WCHAR rhs_expr_ )
01816 {
01817     typedef
01818         xtl_opbinconcat<
01819             xtl_wrap< Left_exprT >,
01820             xtl_wrap< xtl_char< CTTL_STD_WCHAR > >
01821         >
01822         opconcat_T;
01823 
01824     return xtl_wrap< opconcat_T >( opconcat_T( lhs_expr_, xtl_char< CTTL_STD_WCHAR >( rhs_expr_ ) ) );
01825 }
01826 
01827 
01828 /* specialization for binary CTTL_STD_WCHAR ^ expr */
01829 template< typename Right_exprT >
01830 inline
01831 xtl_wrap<
01832     xtl_opbinconcat<
01833         xtl_wrap< xtl_char< CTTL_STD_WCHAR > >,
01834         xtl_wrap< Right_exprT >
01835     >
01836 >
01837 operator^ ( CTTL_STD_WCHAR lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
01838 {
01839     typedef
01840         xtl_opbinconcat<
01841             xtl_wrap< xtl_char< CTTL_STD_WCHAR > >,
01842             xtl_wrap< Right_exprT >
01843         >
01844         opconcat_T;
01845 
01846     return xtl_wrap< opconcat_T >( opconcat_T( xtl_char< CTTL_STD_WCHAR >( lhs_expr_ ), rhs_expr_ ) );
01847 }
01848 
01849 
01850 /* specialization for binary expr ^ bool */
01851 template< typename Left_exprT >
01852 inline
01853 xtl_wrap<
01854     xtl_opbinconcat<
01855         xtl_wrap< Left_exprT >,
01856         xtl_wrap< xtl_bool< false > >
01857     >
01858 >
01859 operator^ ( xtl_wrap< Left_exprT > const& lhs_expr_, bool rhs_expr_ )
01860 {
01861     typedef
01862         xtl_opbinconcat<
01863             xtl_wrap< Left_exprT >,
01864             xtl_wrap< xtl_bool< false > >
01865         >
01866         opconcat_T;
01867 
01868     return xtl_wrap< opconcat_T >( opconcat_T( lhs_expr_, xtl_bool< false >( rhs_expr_ ) ) );
01869 }
01870 
01871 
01872 /* specialization for binary bool ^ expr */
01873 template< typename Right_exprT >
01874 inline
01875 xtl_wrap<
01876     xtl_opbinconcat<
01877         xtl_wrap< xtl_bool< false > >,
01878         xtl_wrap< Right_exprT >
01879     >
01880 >
01881 operator^ ( bool lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
01882 {
01883     typedef
01884         xtl_opbinconcat<
01885             xtl_wrap< xtl_bool< false > >,
01886             xtl_wrap< Right_exprT >
01887         >
01888         opconcat_T;
01889 
01890     return xtl_wrap< opconcat_T >( opconcat_T( xtl_bool< false >( lhs_expr_ ), rhs_expr_ ) );
01891 }
01892 
01893 
01894 /* specialization for binary expr ^ CTTL_STD_CHAR const* */
01895 template< typename Left_exprT >
01896 inline
01897 xtl_wrap<
01898     xtl_opbinconcat<
01899         xtl_wrap< Left_exprT >,
01900         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
01901     >
01902 >
01903 operator^ ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_CHAR const* rhs_expr_ )
01904 {
01905     typedef
01906         xtl_opbinconcat<
01907             xtl_wrap< Left_exprT >,
01908             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
01909         >
01910         opconcat_T;
01911 
01912     return xtl_wrap< opconcat_T >( opconcat_T( lhs_expr_, xtl_text_symbol< CTTL_STD_STRING >( rhs_expr_ ) ) );
01913 }
01914 
01915 
01916 /* specialization for binary CTTL_STD_CHAR const* ^ expr */
01917 template< typename Right_exprT >
01918 inline
01919 xtl_wrap<
01920     xtl_opbinconcat<
01921         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
01922         xtl_wrap< Right_exprT >
01923     >
01924 >
01925 operator^ ( CTTL_STD_CHAR const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
01926 {
01927     typedef
01928         xtl_opbinconcat<
01929             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
01930             xtl_wrap< Right_exprT >
01931         >
01932         opconcat_T;
01933 
01934     return xtl_wrap< opconcat_T >( opconcat_T( xtl_text_symbol< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
01935 }
01936 
01937 
01938 /* specialization for binary expr ^ CTTL_STD_STRING const& */
01939 template< typename Left_exprT >
01940 inline
01941 xtl_wrap<
01942     xtl_opbinconcat<
01943         xtl_wrap< Left_exprT >,
01944         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
01945     >
01946 >
01947 operator^ ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_STRING const& rhs_expr_ )
01948 {
01949     typedef
01950         xtl_opbinconcat<
01951             xtl_wrap< Left_exprT >,
01952             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
01953         >
01954         opconcat_T;
01955 
01956     return xtl_wrap< opconcat_T >( opconcat_T( lhs_expr_, xtl_text_symbol< CTTL_STD_STRING >( rhs_expr_ ) ) );
01957 }
01958 
01959 
01960 /* specialization for binary CTTL_STD_STRING const& ^ expr */
01961 template< typename Right_exprT >
01962 inline
01963 xtl_wrap<
01964     xtl_opbinconcat<
01965         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
01966         xtl_wrap< Right_exprT >
01967     >
01968 >
01969 operator^ ( CTTL_STD_STRING const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
01970 {
01971     typedef
01972         xtl_opbinconcat<
01973             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
01974             xtl_wrap< Right_exprT >
01975         >
01976         opconcat_T;
01977 
01978     return xtl_wrap< opconcat_T >( opconcat_T( xtl_text_symbol< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
01979 }
01980 
01981 
01982 /* specialization for binary expr ^ CTTL_STD_WCHAR const* */
01983 template< typename Left_exprT >
01984 inline
01985 xtl_wrap<
01986     xtl_opbinconcat<
01987         xtl_wrap< Left_exprT >,
01988         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
01989     >
01990 >
01991 operator^ ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WCHAR const* rhs_expr_ )
01992 {
01993     typedef
01994         xtl_opbinconcat<
01995             xtl_wrap< Left_exprT >,
01996             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
01997         >
01998         opconcat_T;
01999 
02000     return xtl_wrap< opconcat_T >( opconcat_T( lhs_expr_, xtl_text_symbol< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
02001 }
02002 
02003 
02004 /* specialization for binary CTTL_STD_WCHAR const* ^ expr */
02005 template< typename Right_exprT >
02006 inline
02007 xtl_wrap<
02008     xtl_opbinconcat<
02009         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
02010         xtl_wrap< Right_exprT >
02011     >
02012 >
02013 operator^ ( CTTL_STD_WCHAR const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
02014 {
02015     typedef
02016         xtl_opbinconcat<
02017             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
02018             xtl_wrap< Right_exprT >
02019         >
02020         opconcat_T;
02021 
02022     return xtl_wrap< opconcat_T >( opconcat_T( xtl_text_symbol< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
02023 }
02024 
02025 
02026 /* specialization for binary expr ^ CTTL_STD_WSTRING const& */
02027 template< typename Left_exprT >
02028 inline
02029 xtl_wrap<
02030     xtl_opbinconcat<
02031         xtl_wrap< Left_exprT >,
02032         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
02033     >
02034 >
02035 operator^ ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WSTRING const& rhs_expr_ )
02036 {
02037     typedef
02038         xtl_opbinconcat<
02039             xtl_wrap< Left_exprT >,
02040             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
02041         >
02042         opconcat_T;
02043 
02044     return xtl_wrap< opconcat_T >( opconcat_T( lhs_expr_, xtl_text_symbol< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
02045 }
02046 
02047 
02048 /* specialization for binary CTTL_STD_WSTRING const& ^ expr */
02049 template< typename Right_exprT >
02050 inline
02051 xtl_wrap<
02052     xtl_opbinconcat<
02053         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
02054         xtl_wrap< Right_exprT >
02055     >
02056 >
02057 operator^ ( CTTL_STD_WSTRING const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
02058 {
02059     typedef
02060         xtl_opbinconcat<
02061             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
02062             xtl_wrap< Right_exprT >
02063         >
02064         opconcat_T;
02065 
02066     return xtl_wrap< opconcat_T >( opconcat_T( xtl_text_symbol< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
02067 }
02068 
02069 
02070 /* specialization for binary expr ^ std::set< CTTL_STD_STRING > const& */
02071 template< typename Left_exprT >
02072 inline
02073 xtl_wrap<
02074     xtl_opbinconcat<
02075         xtl_wrap< Left_exprT >,
02076         xtl_wrap< xtl_keyword< CTTL_STD_STRING > >
02077     >
02078 >
02079 operator^ ( xtl_wrap< Left_exprT > const& lhs_expr_, std::set< CTTL_STD_STRING > const& rhs_expr_ )
02080 {
02081     typedef
02082         xtl_opbinconcat<
02083             xtl_wrap< Left_exprT >,
02084             xtl_wrap< xtl_keyword< CTTL_STD_STRING > >
02085         >
02086         opconcat_T;
02087 
02088     return xtl_wrap< opconcat_T >( opconcat_T( lhs_expr_, xtl_keyword< CTTL_STD_STRING >( rhs_expr_ ) ) );
02089 }
02090 
02091 
02092 /* specialization for binary std::set< CTTL_STD_STRING > const& ^ expr */
02093 template< typename Right_exprT >
02094 inline
02095 xtl_wrap<
02096     xtl_opbinconcat<
02097         xtl_wrap< xtl_keyword< CTTL_STD_STRING > >,
02098         xtl_wrap< Right_exprT >
02099     >
02100 >
02101 operator^ ( std::set< CTTL_STD_STRING > const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
02102 {
02103     typedef
02104         xtl_opbinconcat<
02105             xtl_wrap< xtl_keyword< CTTL_STD_STRING > >,
02106             xtl_wrap< Right_exprT >
02107         >
02108         opconcat_T;
02109 
02110     return xtl_wrap< opconcat_T >( opconcat_T( xtl_keyword< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
02111 }
02112 
02113 
02114 /* specialization for binary expr ^ std::set< CTTL_STD_WSTRING > const& */
02115 template< typename Left_exprT >
02116 inline
02117 xtl_wrap<
02118     xtl_opbinconcat<
02119         xtl_wrap< Left_exprT >,
02120         xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >
02121     >
02122 >
02123 operator^ ( xtl_wrap< Left_exprT > const& lhs_expr_, std::set< CTTL_STD_WSTRING > const& rhs_expr_ )
02124 {
02125     typedef
02126         xtl_opbinconcat<
02127             xtl_wrap< Left_exprT >,
02128             xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >
02129         >
02130         opconcat_T;
02131 
02132     return xtl_wrap< opconcat_T >( opconcat_T( lhs_expr_, xtl_keyword< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
02133 }
02134 
02135 
02136 /* specialization for binary std::set< CTTL_STD_WSTRING > const& ^ expr */
02137 template< typename Right_exprT >
02138 inline
02139 xtl_wrap<
02140     xtl_opbinconcat<
02141         xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >,
02142         xtl_wrap< Right_exprT >
02143     >
02144 >
02145 operator^ ( std::set< CTTL_STD_WSTRING > const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
02146 {
02147     typedef
02148         xtl_opbinconcat<
02149             xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >,
02150             xtl_wrap< Right_exprT >
02151         >
02152         opconcat_T;
02153 
02154     return xtl_wrap< opconcat_T >( opconcat_T( xtl_keyword< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
02155 }
02156 
02157 
02158 /* specialization for binary expr ^ iswhat_T */
02159 template< typename Left_exprT >
02160 inline
02161 xtl_wrap<
02162     xtl_opbinconcat<
02163         xtl_wrap< Left_exprT >,
02164         xtl_wrap< xtl_iswhat_entity >
02165     >
02166 >
02167 operator^ ( xtl_wrap< Left_exprT > const& lhs_expr_, iswhat_T rhs_expr_ )
02168 {
02169     typedef
02170         xtl_opbinconcat<
02171             xtl_wrap< Left_exprT >,
02172             xtl_wrap< xtl_iswhat_entity >
02173         >
02174         opconcat_T;
02175 
02176     return xtl_wrap< opconcat_T >( opconcat_T( lhs_expr_, xtl_iswhat_entity( rhs_expr_ ) ) );
02177 }
02178 
02179 
02180 /* specialization for binary iswhat_T ^ expr */
02181 template< typename Right_exprT >
02182 inline
02183 xtl_wrap<
02184     xtl_opbinconcat<
02185         xtl_wrap< xtl_iswhat_entity >,
02186         xtl_wrap< Right_exprT >
02187     >
02188 >
02189 operator^ ( iswhat_T lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
02190 {
02191     typedef
02192         xtl_opbinconcat<
02193             xtl_wrap< xtl_iswhat_entity >,
02194             xtl_wrap< Right_exprT >
02195         >
02196         opconcat_T;
02197 
02198     return xtl_wrap< opconcat_T >( opconcat_T( xtl_iswhat_entity( lhs_expr_ ), rhs_expr_ ) );
02199 }
02200 
02201 
02202 /* specialization for binary expr ^ iswwhat_T */
02203 template< typename Left_exprT >
02204 inline
02205 xtl_wrap<
02206     xtl_opbinconcat<
02207         xtl_wrap< Left_exprT >,
02208         xtl_wrap< xtl_iswwhat_entity >
02209     >
02210 >
02211 operator^ ( xtl_wrap< Left_exprT > const& lhs_expr_, iswwhat_T rhs_expr_ )
02212 {
02213     typedef
02214         xtl_opbinconcat<
02215             xtl_wrap< Left_exprT >,
02216             xtl_wrap< xtl_iswwhat_entity >
02217         >
02218         opconcat_T;
02219 
02220     return xtl_wrap< opconcat_T >( opconcat_T( lhs_expr_, xtl_iswwhat_entity( rhs_expr_ ) ) );
02221 }
02222 
02223 
02224 /* specialization for binary iswwhat_T ^ expr */
02225 template< typename Right_exprT >
02226 inline
02227 xtl_wrap<
02228     xtl_opbinconcat<
02229         xtl_wrap< xtl_iswwhat_entity >,
02230         xtl_wrap< Right_exprT >
02231     >
02232 >
02233 operator^ ( iswwhat_T lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
02234 {
02235     typedef
02236         xtl_opbinconcat<
02237             xtl_wrap< xtl_iswwhat_entity >,
02238             xtl_wrap< Right_exprT >
02239         >
02240         opconcat_T;
02241 
02242     return xtl_wrap< opconcat_T >( opconcat_T( xtl_iswwhat_entity( lhs_expr_ ), rhs_expr_ ) );
02243 }
02244 
02245 
02246 /* specialization for binary expr ^ CTTL_STD_STRING const* */
02247 template< typename Left_exprT >
02248 inline
02249 xtl_wrap<
02250     xtl_opbinconcat<
02251         xtl_wrap< Left_exprT >,
02252         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >
02253     >
02254 >
02255 operator^ ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_STRING const* rhs_expr_ )
02256 {
02257     typedef
02258         xtl_opbinconcat<
02259             xtl_wrap< Left_exprT >,
02260             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >
02261         >
02262         opconcat_T;
02263 
02264     return xtl_wrap< opconcat_T >( opconcat_T( lhs_expr_, xtl_text_ref_symbol< CTTL_STD_STRING >( rhs_expr_ ) ) );
02265 }
02266 
02267 
02268 /* specialization for binary CTTL_STD_STRING const* ^ expr */
02269 template< typename Right_exprT >
02270 inline
02271 xtl_wrap<
02272     xtl_opbinconcat<
02273         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >,
02274         xtl_wrap< Right_exprT >
02275     >
02276 >
02277 operator^ ( CTTL_STD_STRING const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
02278 {
02279     typedef
02280         xtl_opbinconcat<
02281             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >,
02282             xtl_wrap< Right_exprT >
02283         >
02284         opconcat_T;
02285 
02286     return xtl_wrap< opconcat_T >( opconcat_T( xtl_text_ref_symbol< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
02287 }
02288 
02289 
02290 /* specialization for binary expr ^ CTTL_STD_WSTRING const* */
02291 template< typename Left_exprT >
02292 inline
02293 xtl_wrap<
02294     xtl_opbinconcat<
02295         xtl_wrap< Left_exprT >,
02296         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >
02297     >
02298 >
02299 operator^ ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WSTRING const* rhs_expr_ )
02300 {
02301     typedef
02302         xtl_opbinconcat<
02303             xtl_wrap< Left_exprT >,
02304             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >
02305         >
02306         opconcat_T;
02307 
02308     return xtl_wrap< opconcat_T >( opconcat_T( lhs_expr_, xtl_text_ref_symbol< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
02309 }
02310 
02311 
02312 /* specialization for binary CTTL_STD_WSTRING const* ^ expr */
02313 template< typename Right_exprT >
02314 inline
02315 xtl_wrap<
02316     xtl_opbinconcat<
02317         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >,
02318         xtl_wrap< Right_exprT >
02319     >
02320 >
02321 operator^ ( CTTL_STD_WSTRING const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
02322 {
02323     typedef
02324         xtl_opbinconcat<
02325             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >,
02326             xtl_wrap< Right_exprT >
02327         >
02328         opconcat_T;
02329 
02330     return xtl_wrap< opconcat_T >( opconcat_T( xtl_text_ref_symbol< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
02331 }
02332 
02333 
02334 
02335 /* specialization for binary expr - CTTL_STD_CHAR */
02336 template< typename Left_exprT >
02337 inline
02338 xtl_wrap<
02339     xtl_opbinminus<
02340         xtl_wrap< Left_exprT >,
02341         xtl_wrap< xtl_char< CTTL_STD_CHAR > >
02342     >
02343 >
02344 operator- ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_CHAR rhs_expr_ )
02345 {
02346     typedef
02347         xtl_opbinminus<
02348             xtl_wrap< Left_exprT >,
02349             xtl_wrap< xtl_char< CTTL_STD_CHAR > >
02350         >
02351         opminus_T;
02352 
02353     return xtl_wrap< opminus_T >( opminus_T( lhs_expr_, xtl_char< CTTL_STD_CHAR >( rhs_expr_ ) ) );
02354 }
02355 
02356 
02357 /* specialization for binary CTTL_STD_CHAR - expr */
02358 template< typename Right_exprT >
02359 inline
02360 xtl_wrap<
02361     xtl_opbinminus<
02362         xtl_wrap< xtl_char< CTTL_STD_CHAR > >,
02363         xtl_wrap< Right_exprT >
02364     >
02365 >
02366 operator- ( CTTL_STD_CHAR lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
02367 {
02368     typedef
02369         xtl_opbinminus<
02370             xtl_wrap< xtl_char< CTTL_STD_CHAR > >,
02371             xtl_wrap< Right_exprT >
02372         >
02373         opminus_T;
02374 
02375     return xtl_wrap< opminus_T >( opminus_T( xtl_char< CTTL_STD_CHAR >( lhs_expr_ ), rhs_expr_ ) );
02376 }
02377 
02378 
02379 /* specialization for binary expr - CTTL_STD_WCHAR */
02380 template< typename Left_exprT >
02381 inline
02382 xtl_wrap<
02383     xtl_opbinminus<
02384         xtl_wrap< Left_exprT >,
02385         xtl_wrap< xtl_char< CTTL_STD_WCHAR > >
02386     >
02387 >
02388 operator- ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WCHAR rhs_expr_ )
02389 {
02390     typedef
02391         xtl_opbinminus<
02392             xtl_wrap< Left_exprT >,
02393             xtl_wrap< xtl_char< CTTL_STD_WCHAR > >
02394         >
02395         opminus_T;
02396 
02397     return xtl_wrap< opminus_T >( opminus_T( lhs_expr_, xtl_char< CTTL_STD_WCHAR >( rhs_expr_ ) ) );
02398 }
02399 
02400 
02401 /* specialization for binary CTTL_STD_WCHAR - expr */
02402 template< typename Right_exprT >
02403 inline
02404 xtl_wrap<
02405     xtl_opbinminus<
02406         xtl_wrap< xtl_char< CTTL_STD_WCHAR > >,
02407         xtl_wrap< Right_exprT >
02408     >
02409 >
02410 operator- ( CTTL_STD_WCHAR lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
02411 {
02412     typedef
02413         xtl_opbinminus<
02414             xtl_wrap< xtl_char< CTTL_STD_WCHAR > >,
02415             xtl_wrap< Right_exprT >
02416         >
02417         opminus_T;
02418 
02419     return xtl_wrap< opminus_T >( opminus_T( xtl_char< CTTL_STD_WCHAR >( lhs_expr_ ), rhs_expr_ ) );
02420 }
02421 
02422 
02423 /* specialization for binary expr - bool */
02424 template< typename Left_exprT >
02425 inline
02426 xtl_wrap<
02427     xtl_opbinminus<
02428         xtl_wrap< Left_exprT >,
02429         xtl_wrap< xtl_bool< false > >
02430     >
02431 >
02432 operator- ( xtl_wrap< Left_exprT > const& lhs_expr_, bool rhs_expr_ )
02433 {
02434     typedef
02435         xtl_opbinminus<
02436             xtl_wrap< Left_exprT >,
02437             xtl_wrap< xtl_bool< false > >
02438         >
02439         opminus_T;
02440 
02441     return xtl_wrap< opminus_T >( opminus_T( lhs_expr_, xtl_bool< false >( rhs_expr_ ) ) );
02442 }
02443 
02444 
02445 /* specialization for binary bool - expr */
02446 template< typename Right_exprT >
02447 inline
02448 xtl_wrap<
02449     xtl_opbinminus<
02450         xtl_wrap< xtl_bool< false > >,
02451         xtl_wrap< Right_exprT >
02452     >
02453 >
02454 operator- ( bool lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
02455 {
02456     typedef
02457         xtl_opbinminus<
02458             xtl_wrap< xtl_bool< false > >,
02459             xtl_wrap< Right_exprT >
02460         >
02461         opminus_T;
02462 
02463     return xtl_wrap< opminus_T >( opminus_T( xtl_bool< false >( lhs_expr_ ), rhs_expr_ ) );
02464 }
02465 
02466 
02467 /* specialization for binary expr - CTTL_STD_CHAR const* */
02468 template< typename Left_exprT >
02469 inline
02470 xtl_wrap<
02471     xtl_opbinminus<
02472         xtl_wrap< Left_exprT >,
02473         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
02474     >
02475 >
02476 operator- ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_CHAR const* rhs_expr_ )
02477 {
02478     typedef
02479         xtl_opbinminus<
02480             xtl_wrap< Left_exprT >,
02481             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
02482         >
02483         opminus_T;
02484 
02485     return xtl_wrap< opminus_T >( opminus_T( lhs_expr_, xtl_text_symbol< CTTL_STD_STRING >( rhs_expr_ ) ) );
02486 }
02487 
02488 
02489 /* specialization for binary CTTL_STD_CHAR const* - expr */
02490 template< typename Right_exprT >
02491 inline
02492 xtl_wrap<
02493     xtl_opbinminus<
02494         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
02495         xtl_wrap< Right_exprT >
02496     >
02497 >
02498 operator- ( CTTL_STD_CHAR const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
02499 {
02500     typedef
02501         xtl_opbinminus<
02502             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
02503             xtl_wrap< Right_exprT >
02504         >
02505         opminus_T;
02506 
02507     return xtl_wrap< opminus_T >( opminus_T( xtl_text_symbol< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
02508 }
02509 
02510 
02511 /* specialization for binary expr - CTTL_STD_STRING const& */
02512 template< typename Left_exprT >
02513 inline
02514 xtl_wrap<
02515     xtl_opbinminus<
02516         xtl_wrap< Left_exprT >,
02517         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
02518     >
02519 >
02520 operator- ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_STRING const& rhs_expr_ )
02521 {
02522     typedef
02523         xtl_opbinminus<
02524             xtl_wrap< Left_exprT >,
02525             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
02526         >
02527         opminus_T;
02528 
02529     return xtl_wrap< opminus_T >( opminus_T( lhs_expr_, xtl_text_symbol< CTTL_STD_STRING >( rhs_expr_ ) ) );
02530 }
02531 
02532 
02533 /* specialization for binary CTTL_STD_STRING const& - expr */
02534 template< typename Right_exprT >
02535 inline
02536 xtl_wrap<
02537     xtl_opbinminus<
02538         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
02539         xtl_wrap< Right_exprT >
02540     >
02541 >
02542 operator- ( CTTL_STD_STRING const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
02543 {
02544     typedef
02545         xtl_opbinminus<
02546             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
02547             xtl_wrap< Right_exprT >
02548         >
02549         opminus_T;
02550 
02551     return xtl_wrap< opminus_T >( opminus_T( xtl_text_symbol< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
02552 }
02553 
02554 
02555 /* specialization for binary expr - CTTL_STD_WCHAR const* */
02556 template< typename Left_exprT >
02557 inline
02558 xtl_wrap<
02559     xtl_opbinminus<
02560         xtl_wrap< Left_exprT >,
02561         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
02562     >
02563 >
02564 operator- ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WCHAR const* rhs_expr_ )
02565 {
02566     typedef
02567         xtl_opbinminus<
02568             xtl_wrap< Left_exprT >,
02569             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
02570         >
02571         opminus_T;
02572 
02573     return xtl_wrap< opminus_T >( opminus_T( lhs_expr_, xtl_text_symbol< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
02574 }
02575 
02576 
02577 /* specialization for binary CTTL_STD_WCHAR const* - expr */
02578 template< typename Right_exprT >
02579 inline
02580 xtl_wrap<
02581     xtl_opbinminus<
02582         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
02583         xtl_wrap< Right_exprT >
02584     >
02585 >
02586 operator- ( CTTL_STD_WCHAR const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
02587 {
02588     typedef
02589         xtl_opbinminus<
02590             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
02591             xtl_wrap< Right_exprT >
02592         >
02593         opminus_T;
02594 
02595     return xtl_wrap< opminus_T >( opminus_T( xtl_text_symbol< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
02596 }
02597 
02598 
02599 /* specialization for binary expr - CTTL_STD_WSTRING const& */
02600 template< typename Left_exprT >
02601 inline
02602 xtl_wrap<
02603     xtl_opbinminus<
02604         xtl_wrap< Left_exprT >,
02605         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
02606     >
02607 >
02608 operator- ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WSTRING const& rhs_expr_ )
02609 {
02610     typedef
02611         xtl_opbinminus<
02612             xtl_wrap< Left_exprT >,
02613             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
02614         >
02615         opminus_T;
02616 
02617     return xtl_wrap< opminus_T >( opminus_T( lhs_expr_, xtl_text_symbol< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
02618 }
02619 
02620 
02621 /* specialization for binary CTTL_STD_WSTRING const& - expr */
02622 template< typename Right_exprT >
02623 inline
02624 xtl_wrap<
02625     xtl_opbinminus<
02626         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
02627         xtl_wrap< Right_exprT >
02628     >
02629 >
02630 operator- ( CTTL_STD_WSTRING const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
02631 {
02632     typedef
02633         xtl_opbinminus<
02634             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
02635             xtl_wrap< Right_exprT >
02636         >
02637         opminus_T;
02638 
02639     return xtl_wrap< opminus_T >( opminus_T( xtl_text_symbol< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
02640 }
02641 
02642 
02643 /* specialization for binary expr - std::set< CTTL_STD_STRING > const& */
02644 template< typename Left_exprT >
02645 inline
02646 xtl_wrap<
02647     xtl_opbinminus<
02648         xtl_wrap< Left_exprT >,
02649         xtl_wrap< xtl_keyword< CTTL_STD_STRING > >
02650     >
02651 >
02652 operator- ( xtl_wrap< Left_exprT > const& lhs_expr_, std::set< CTTL_STD_STRING > const& rhs_expr_ )
02653 {
02654     typedef
02655         xtl_opbinminus<
02656             xtl_wrap< Left_exprT >,
02657             xtl_wrap< xtl_keyword< CTTL_STD_STRING > >
02658         >
02659         opminus_T;
02660 
02661     return xtl_wrap< opminus_T >( opminus_T( lhs_expr_, xtl_keyword< CTTL_STD_STRING >( rhs_expr_ ) ) );
02662 }
02663 
02664 
02665 /* specialization for binary std::set< CTTL_STD_STRING > const& - expr */
02666 template< typename Right_exprT >
02667 inline
02668 xtl_wrap<
02669     xtl_opbinminus<
02670         xtl_wrap< xtl_keyword< CTTL_STD_STRING > >,
02671         xtl_wrap< Right_exprT >
02672     >
02673 >
02674 operator- ( std::set< CTTL_STD_STRING > const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
02675 {
02676     typedef
02677         xtl_opbinminus<
02678             xtl_wrap< xtl_keyword< CTTL_STD_STRING > >,
02679             xtl_wrap< Right_exprT >
02680         >
02681         opminus_T;
02682 
02683     return xtl_wrap< opminus_T >( opminus_T( xtl_keyword< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
02684 }
02685 
02686 
02687 /* specialization for binary expr - std::set< CTTL_STD_WSTRING > const& */
02688 template< typename Left_exprT >
02689 inline
02690 xtl_wrap<
02691     xtl_opbinminus<
02692         xtl_wrap< Left_exprT >,
02693         xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >
02694     >
02695 >
02696 operator- ( xtl_wrap< Left_exprT > const& lhs_expr_, std::set< CTTL_STD_WSTRING > const& rhs_expr_ )
02697 {
02698     typedef
02699         xtl_opbinminus<
02700             xtl_wrap< Left_exprT >,
02701             xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >
02702         >
02703         opminus_T;
02704 
02705     return xtl_wrap< opminus_T >( opminus_T( lhs_expr_, xtl_keyword< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
02706 }
02707 
02708 
02709 /* specialization for binary std::set< CTTL_STD_WSTRING > const& - expr */
02710 template< typename Right_exprT >
02711 inline
02712 xtl_wrap<
02713     xtl_opbinminus<
02714         xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >,
02715         xtl_wrap< Right_exprT >
02716     >
02717 >
02718 operator- ( std::set< CTTL_STD_WSTRING > const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
02719 {
02720     typedef
02721         xtl_opbinminus<
02722             xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >,
02723             xtl_wrap< Right_exprT >
02724         >
02725         opminus_T;
02726 
02727     return xtl_wrap< opminus_T >( opminus_T( xtl_keyword< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
02728 }
02729 
02730 
02731 /* specialization for binary expr - iswhat_T */
02732 template< typename Left_exprT >
02733 inline
02734 xtl_wrap<
02735     xtl_opbinminus<
02736         xtl_wrap< Left_exprT >,
02737         xtl_wrap< xtl_iswhat_entity >
02738     >
02739 >
02740 operator- ( xtl_wrap< Left_exprT > const& lhs_expr_, iswhat_T rhs_expr_ )
02741 {
02742     typedef
02743         xtl_opbinminus<
02744             xtl_wrap< Left_exprT >,
02745             xtl_wrap< xtl_iswhat_entity >
02746         >
02747         opminus_T;
02748 
02749     return xtl_wrap< opminus_T >( opminus_T( lhs_expr_, xtl_iswhat_entity( rhs_expr_ ) ) );
02750 }
02751 
02752 
02753 /* specialization for binary iswhat_T - expr */
02754 template< typename Right_exprT >
02755 inline
02756 xtl_wrap<
02757     xtl_opbinminus<
02758         xtl_wrap< xtl_iswhat_entity >,
02759         xtl_wrap< Right_exprT >
02760     >
02761 >
02762 operator- ( iswhat_T lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
02763 {
02764     typedef
02765         xtl_opbinminus<
02766             xtl_wrap< xtl_iswhat_entity >,
02767             xtl_wrap< Right_exprT >
02768         >
02769         opminus_T;
02770 
02771     return xtl_wrap< opminus_T >( opminus_T( xtl_iswhat_entity( lhs_expr_ ), rhs_expr_ ) );
02772 }
02773 
02774 
02775 /* specialization for binary expr - iswwhat_T */
02776 template< typename Left_exprT >
02777 inline
02778 xtl_wrap<
02779     xtl_opbinminus<
02780         xtl_wrap< Left_exprT >,
02781         xtl_wrap< xtl_iswwhat_entity >
02782     >
02783 >
02784 operator- ( xtl_wrap< Left_exprT > const& lhs_expr_, iswwhat_T rhs_expr_ )
02785 {
02786     typedef
02787         xtl_opbinminus<
02788             xtl_wrap< Left_exprT >,
02789             xtl_wrap< xtl_iswwhat_entity >
02790         >
02791         opminus_T;
02792 
02793     return xtl_wrap< opminus_T >( opminus_T( lhs_expr_, xtl_iswwhat_entity( rhs_expr_ ) ) );
02794 }
02795 
02796 
02797 /* specialization for binary iswwhat_T - expr */
02798 template< typename Right_exprT >
02799 inline
02800 xtl_wrap<
02801     xtl_opbinminus<
02802         xtl_wrap< xtl_iswwhat_entity >,
02803         xtl_wrap< Right_exprT >
02804     >
02805 >
02806 operator- ( iswwhat_T lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
02807 {
02808     typedef
02809         xtl_opbinminus<
02810             xtl_wrap< xtl_iswwhat_entity >,
02811             xtl_wrap< Right_exprT >
02812         >
02813         opminus_T;
02814 
02815     return xtl_wrap< opminus_T >( opminus_T( xtl_iswwhat_entity( lhs_expr_ ), rhs_expr_ ) );
02816 }
02817 
02818 
02819 /* specialization for binary expr - CTTL_STD_STRING const* */
02820 template< typename Left_exprT >
02821 inline
02822 xtl_wrap<
02823     xtl_opbinminus<
02824         xtl_wrap< Left_exprT >,
02825         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >
02826     >
02827 >
02828 operator- ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_STRING const* rhs_expr_ )
02829 {
02830     typedef
02831         xtl_opbinminus<
02832             xtl_wrap< Left_exprT >,
02833             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >
02834         >
02835         opminus_T;
02836 
02837     return xtl_wrap< opminus_T >( opminus_T( lhs_expr_, xtl_text_ref_symbol< CTTL_STD_STRING >( rhs_expr_ ) ) );
02838 }
02839 
02840 
02841 /* specialization for binary CTTL_STD_STRING const* - expr */
02842 template< typename Right_exprT >
02843 inline
02844 xtl_wrap<
02845     xtl_opbinminus<
02846         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >,
02847         xtl_wrap< Right_exprT >
02848     >
02849 >
02850 operator- ( CTTL_STD_STRING const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
02851 {
02852     typedef
02853         xtl_opbinminus<
02854             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >,
02855             xtl_wrap< Right_exprT >
02856         >
02857         opminus_T;
02858 
02859     return xtl_wrap< opminus_T >( opminus_T( xtl_text_ref_symbol< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
02860 }
02861 
02862 
02863 /* specialization for binary expr - CTTL_STD_WSTRING const* */
02864 template< typename Left_exprT >
02865 inline
02866 xtl_wrap<
02867     xtl_opbinminus<
02868         xtl_wrap< Left_exprT >,
02869         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >
02870     >
02871 >
02872 operator- ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WSTRING const* rhs_expr_ )
02873 {
02874     typedef
02875         xtl_opbinminus<
02876             xtl_wrap< Left_exprT >,
02877             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >
02878         >
02879         opminus_T;
02880 
02881     return xtl_wrap< opminus_T >( opminus_T( lhs_expr_, xtl_text_ref_symbol< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
02882 }
02883 
02884 
02885 /* specialization for binary CTTL_STD_WSTRING const* - expr */
02886 template< typename Right_exprT >
02887 inline
02888 xtl_wrap<
02889     xtl_opbinminus<
02890         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >,
02891         xtl_wrap< Right_exprT >
02892     >
02893 >
02894 operator- ( CTTL_STD_WSTRING const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
02895 {
02896     typedef
02897         xtl_opbinminus<
02898             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >,
02899             xtl_wrap< Right_exprT >
02900         >
02901         opminus_T;
02902 
02903     return xtl_wrap< opminus_T >( opminus_T( xtl_text_ref_symbol< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
02904 }
02905 
02906 
02907 
02908 /* specialization for binary expr & CTTL_STD_CHAR */
02909 template< typename Left_exprT >
02910 inline
02911 xtl_wrap<
02912     xtl_opbinand<
02913         xtl_wrap< Left_exprT >,
02914         xtl_wrap< xtl_char< CTTL_STD_CHAR > >
02915     >
02916 >
02917 operator& ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_CHAR rhs_expr_ )
02918 {
02919     typedef
02920         xtl_opbinand<
02921             xtl_wrap< Left_exprT >,
02922             xtl_wrap< xtl_char< CTTL_STD_CHAR > >
02923         >
02924         opand_T;
02925 
02926     return xtl_wrap< opand_T >( opand_T( lhs_expr_, xtl_char< CTTL_STD_CHAR >( rhs_expr_ ) ) );
02927 }
02928 
02929 
02930 /* specialization for binary CTTL_STD_CHAR & expr */
02931 template< typename Right_exprT >
02932 inline
02933 xtl_wrap<
02934     xtl_opbinand<
02935         xtl_wrap< xtl_char< CTTL_STD_CHAR > >,
02936         xtl_wrap< Right_exprT >
02937     >
02938 >
02939 operator& ( CTTL_STD_CHAR lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
02940 {
02941     typedef
02942         xtl_opbinand<
02943             xtl_wrap< xtl_char< CTTL_STD_CHAR > >,
02944             xtl_wrap< Right_exprT >
02945         >
02946         opand_T;
02947 
02948     return xtl_wrap< opand_T >( opand_T( xtl_char< CTTL_STD_CHAR >( lhs_expr_ ), rhs_expr_ ) );
02949 }
02950 
02951 
02952 /* specialization for binary expr & CTTL_STD_WCHAR */
02953 template< typename Left_exprT >
02954 inline
02955 xtl_wrap<
02956     xtl_opbinand<
02957         xtl_wrap< Left_exprT >,
02958         xtl_wrap< xtl_char< CTTL_STD_WCHAR > >
02959     >
02960 >
02961 operator& ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WCHAR rhs_expr_ )
02962 {
02963     typedef
02964         xtl_opbinand<
02965             xtl_wrap< Left_exprT >,
02966             xtl_wrap< xtl_char< CTTL_STD_WCHAR > >
02967         >
02968         opand_T;
02969 
02970     return xtl_wrap< opand_T >( opand_T( lhs_expr_, xtl_char< CTTL_STD_WCHAR >( rhs_expr_ ) ) );
02971 }
02972 
02973 
02974 /* specialization for binary CTTL_STD_WCHAR & expr */
02975 template< typename Right_exprT >
02976 inline
02977 xtl_wrap<
02978     xtl_opbinand<
02979         xtl_wrap< xtl_char< CTTL_STD_WCHAR > >,
02980         xtl_wrap< Right_exprT >
02981     >
02982 >
02983 operator& ( CTTL_STD_WCHAR lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
02984 {
02985     typedef
02986         xtl_opbinand<
02987             xtl_wrap< xtl_char< CTTL_STD_WCHAR > >,
02988             xtl_wrap< Right_exprT >
02989         >
02990         opand_T;
02991 
02992     return xtl_wrap< opand_T >( opand_T( xtl_char< CTTL_STD_WCHAR >( lhs_expr_ ), rhs_expr_ ) );
02993 }
02994 
02995 
02996 /* specialization for binary expr & bool */
02997 template< typename Left_exprT >
02998 inline
02999 xtl_wrap<
03000     xtl_opbinand<
03001         xtl_wrap< Left_exprT >,
03002         xtl_wrap< xtl_bool< false > >
03003     >
03004 >
03005 operator& ( xtl_wrap< Left_exprT > const& lhs_expr_, bool rhs_expr_ )
03006 {
03007     typedef
03008         xtl_opbinand<
03009             xtl_wrap< Left_exprT >,
03010             xtl_wrap< xtl_bool< false > >
03011         >
03012         opand_T;
03013 
03014     return xtl_wrap< opand_T >( opand_T( lhs_expr_, xtl_bool< false >( rhs_expr_ ) ) );
03015 }
03016 
03017 
03018 /* specialization for binary bool & expr */
03019 template< typename Right_exprT >
03020 inline
03021 xtl_wrap<
03022     xtl_opbinand<
03023         xtl_wrap< xtl_bool< false > >,
03024         xtl_wrap< Right_exprT >
03025     >
03026 >
03027 operator& ( bool lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
03028 {
03029     typedef
03030         xtl_opbinand<
03031             xtl_wrap< xtl_bool< false > >,
03032             xtl_wrap< Right_exprT >
03033         >
03034         opand_T;
03035 
03036     return xtl_wrap< opand_T >( opand_T( xtl_bool< false >( lhs_expr_ ), rhs_expr_ ) );
03037 }
03038 
03039 
03040 /* specialization for binary expr & CTTL_STD_CHAR const* */
03041 template< typename Left_exprT >
03042 inline
03043 xtl_wrap<
03044     xtl_opbinand<
03045         xtl_wrap< Left_exprT >,
03046         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
03047     >
03048 >
03049 operator& ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_CHAR const* rhs_expr_ )
03050 {
03051     typedef
03052         xtl_opbinand<
03053             xtl_wrap< Left_exprT >,
03054             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
03055         >
03056         opand_T;
03057 
03058     return xtl_wrap< opand_T >( opand_T( lhs_expr_, xtl_text_symbol< CTTL_STD_STRING >( rhs_expr_ ) ) );
03059 }
03060 
03061 
03062 /* specialization for binary CTTL_STD_CHAR const* & expr */
03063 template< typename Right_exprT >
03064 inline
03065 xtl_wrap<
03066     xtl_opbinand<
03067         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
03068         xtl_wrap< Right_exprT >
03069     >
03070 >
03071 operator& ( CTTL_STD_CHAR const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
03072 {
03073     typedef
03074         xtl_opbinand<
03075             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
03076             xtl_wrap< Right_exprT >
03077         >
03078         opand_T;
03079 
03080     return xtl_wrap< opand_T >( opand_T( xtl_text_symbol< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
03081 }
03082 
03083 
03084 /* specialization for binary expr & CTTL_STD_STRING const& */
03085 template< typename Left_exprT >
03086 inline
03087 xtl_wrap<
03088     xtl_opbinand<
03089         xtl_wrap< Left_exprT >,
03090         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
03091     >
03092 >
03093 operator& ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_STRING const& rhs_expr_ )
03094 {
03095     typedef
03096         xtl_opbinand<
03097             xtl_wrap< Left_exprT >,
03098             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >
03099         >
03100         opand_T;
03101 
03102     return xtl_wrap< opand_T >( opand_T( lhs_expr_, xtl_text_symbol< CTTL_STD_STRING >( rhs_expr_ ) ) );
03103 }
03104 
03105 
03106 /* specialization for binary CTTL_STD_STRING const& & expr */
03107 template< typename Right_exprT >
03108 inline
03109 xtl_wrap<
03110     xtl_opbinand<
03111         xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
03112         xtl_wrap< Right_exprT >
03113     >
03114 >
03115 operator& ( CTTL_STD_STRING const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
03116 {
03117     typedef
03118         xtl_opbinand<
03119             xtl_wrap< xtl_text_symbol< CTTL_STD_STRING > >,
03120             xtl_wrap< Right_exprT >
03121         >
03122         opand_T;
03123 
03124     return xtl_wrap< opand_T >( opand_T( xtl_text_symbol< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
03125 }
03126 
03127 
03128 /* specialization for binary expr & CTTL_STD_WCHAR const* */
03129 template< typename Left_exprT >
03130 inline
03131 xtl_wrap<
03132     xtl_opbinand<
03133         xtl_wrap< Left_exprT >,
03134         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
03135     >
03136 >
03137 operator& ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WCHAR const* rhs_expr_ )
03138 {
03139     typedef
03140         xtl_opbinand<
03141             xtl_wrap< Left_exprT >,
03142             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
03143         >
03144         opand_T;
03145 
03146     return xtl_wrap< opand_T >( opand_T( lhs_expr_, xtl_text_symbol< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
03147 }
03148 
03149 
03150 /* specialization for binary CTTL_STD_WCHAR const* & expr */
03151 template< typename Right_exprT >
03152 inline
03153 xtl_wrap<
03154     xtl_opbinand<
03155         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
03156         xtl_wrap< Right_exprT >
03157     >
03158 >
03159 operator& ( CTTL_STD_WCHAR const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
03160 {
03161     typedef
03162         xtl_opbinand<
03163             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
03164             xtl_wrap< Right_exprT >
03165         >
03166         opand_T;
03167 
03168     return xtl_wrap< opand_T >( opand_T( xtl_text_symbol< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
03169 }
03170 
03171 
03172 /* specialization for binary expr & CTTL_STD_WSTRING const& */
03173 template< typename Left_exprT >
03174 inline
03175 xtl_wrap<
03176     xtl_opbinand<
03177         xtl_wrap< Left_exprT >,
03178         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
03179     >
03180 >
03181 operator& ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WSTRING const& rhs_expr_ )
03182 {
03183     typedef
03184         xtl_opbinand<
03185             xtl_wrap< Left_exprT >,
03186             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >
03187         >
03188         opand_T;
03189 
03190     return xtl_wrap< opand_T >( opand_T( lhs_expr_, xtl_text_symbol< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
03191 }
03192 
03193 
03194 /* specialization for binary CTTL_STD_WSTRING const& & expr */
03195 template< typename Right_exprT >
03196 inline
03197 xtl_wrap<
03198     xtl_opbinand<
03199         xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
03200         xtl_wrap< Right_exprT >
03201     >
03202 >
03203 operator& ( CTTL_STD_WSTRING const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
03204 {
03205     typedef
03206         xtl_opbinand<
03207             xtl_wrap< xtl_text_symbol< CTTL_STD_WSTRING > >,
03208             xtl_wrap< Right_exprT >
03209         >
03210         opand_T;
03211 
03212     return xtl_wrap< opand_T >( opand_T( xtl_text_symbol< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
03213 }
03214 
03215 
03216 /* specialization for binary expr & std::set< CTTL_STD_STRING > const& */
03217 template< typename Left_exprT >
03218 inline
03219 xtl_wrap<
03220     xtl_opbinand<
03221         xtl_wrap< Left_exprT >,
03222         xtl_wrap< xtl_keyword< CTTL_STD_STRING > >
03223     >
03224 >
03225 operator& ( xtl_wrap< Left_exprT > const& lhs_expr_, std::set< CTTL_STD_STRING > const& rhs_expr_ )
03226 {
03227     typedef
03228         xtl_opbinand<
03229             xtl_wrap< Left_exprT >,
03230             xtl_wrap< xtl_keyword< CTTL_STD_STRING > >
03231         >
03232         opand_T;
03233 
03234     return xtl_wrap< opand_T >( opand_T( lhs_expr_, xtl_keyword< CTTL_STD_STRING >( rhs_expr_ ) ) );
03235 }
03236 
03237 
03238 /* specialization for binary std::set< CTTL_STD_STRING > const& & expr */
03239 template< typename Right_exprT >
03240 inline
03241 xtl_wrap<
03242     xtl_opbinand<
03243         xtl_wrap< xtl_keyword< CTTL_STD_STRING > >,
03244         xtl_wrap< Right_exprT >
03245     >
03246 >
03247 operator& ( std::set< CTTL_STD_STRING > const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
03248 {
03249     typedef
03250         xtl_opbinand<
03251             xtl_wrap< xtl_keyword< CTTL_STD_STRING > >,
03252             xtl_wrap< Right_exprT >
03253         >
03254         opand_T;
03255 
03256     return xtl_wrap< opand_T >( opand_T( xtl_keyword< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
03257 }
03258 
03259 
03260 /* specialization for binary expr & std::set< CTTL_STD_WSTRING > const& */
03261 template< typename Left_exprT >
03262 inline
03263 xtl_wrap<
03264     xtl_opbinand<
03265         xtl_wrap< Left_exprT >,
03266         xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >
03267     >
03268 >
03269 operator& ( xtl_wrap< Left_exprT > const& lhs_expr_, std::set< CTTL_STD_WSTRING > const& rhs_expr_ )
03270 {
03271     typedef
03272         xtl_opbinand<
03273             xtl_wrap< Left_exprT >,
03274             xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >
03275         >
03276         opand_T;
03277 
03278     return xtl_wrap< opand_T >( opand_T( lhs_expr_, xtl_keyword< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
03279 }
03280 
03281 
03282 /* specialization for binary std::set< CTTL_STD_WSTRING > const& & expr */
03283 template< typename Right_exprT >
03284 inline
03285 xtl_wrap<
03286     xtl_opbinand<
03287         xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >,
03288         xtl_wrap< Right_exprT >
03289     >
03290 >
03291 operator& ( std::set< CTTL_STD_WSTRING > const& lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
03292 {
03293     typedef
03294         xtl_opbinand<
03295             xtl_wrap< xtl_keyword< CTTL_STD_WSTRING > >,
03296             xtl_wrap< Right_exprT >
03297         >
03298         opand_T;
03299 
03300     return xtl_wrap< opand_T >( opand_T( xtl_keyword< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
03301 }
03302 
03303 
03304 /* specialization for binary expr & iswhat_T */
03305 template< typename Left_exprT >
03306 inline
03307 xtl_wrap<
03308     xtl_opbinand<
03309         xtl_wrap< Left_exprT >,
03310         xtl_wrap< xtl_iswhat_entity >
03311     >
03312 >
03313 operator& ( xtl_wrap< Left_exprT > const& lhs_expr_, iswhat_T rhs_expr_ )
03314 {
03315     typedef
03316         xtl_opbinand<
03317             xtl_wrap< Left_exprT >,
03318             xtl_wrap< xtl_iswhat_entity >
03319         >
03320         opand_T;
03321 
03322     return xtl_wrap< opand_T >( opand_T( lhs_expr_, xtl_iswhat_entity( rhs_expr_ ) ) );
03323 }
03324 
03325 
03326 /* specialization for binary iswhat_T & expr */
03327 template< typename Right_exprT >
03328 inline
03329 xtl_wrap<
03330     xtl_opbinand<
03331         xtl_wrap< xtl_iswhat_entity >,
03332         xtl_wrap< Right_exprT >
03333     >
03334 >
03335 operator& ( iswhat_T lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
03336 {
03337     typedef
03338         xtl_opbinand<
03339             xtl_wrap< xtl_iswhat_entity >,
03340             xtl_wrap< Right_exprT >
03341         >
03342         opand_T;
03343 
03344     return xtl_wrap< opand_T >( opand_T( xtl_iswhat_entity( lhs_expr_ ), rhs_expr_ ) );
03345 }
03346 
03347 
03348 /* specialization for binary expr & iswwhat_T */
03349 template< typename Left_exprT >
03350 inline
03351 xtl_wrap<
03352     xtl_opbinand<
03353         xtl_wrap< Left_exprT >,
03354         xtl_wrap< xtl_iswwhat_entity >
03355     >
03356 >
03357 operator& ( xtl_wrap< Left_exprT > const& lhs_expr_, iswwhat_T rhs_expr_ )
03358 {
03359     typedef
03360         xtl_opbinand<
03361             xtl_wrap< Left_exprT >,
03362             xtl_wrap< xtl_iswwhat_entity >
03363         >
03364         opand_T;
03365 
03366     return xtl_wrap< opand_T >( opand_T( lhs_expr_, xtl_iswwhat_entity( rhs_expr_ ) ) );
03367 }
03368 
03369 
03370 /* specialization for binary iswwhat_T & expr */
03371 template< typename Right_exprT >
03372 inline
03373 xtl_wrap<
03374     xtl_opbinand<
03375         xtl_wrap< xtl_iswwhat_entity >,
03376         xtl_wrap< Right_exprT >
03377     >
03378 >
03379 operator& ( iswwhat_T lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
03380 {
03381     typedef
03382         xtl_opbinand<
03383             xtl_wrap< xtl_iswwhat_entity >,
03384             xtl_wrap< Right_exprT >
03385         >
03386         opand_T;
03387 
03388     return xtl_wrap< opand_T >( opand_T( xtl_iswwhat_entity( lhs_expr_ ), rhs_expr_ ) );
03389 }
03390 
03391 
03392 /* specialization for binary expr & CTTL_STD_STRING const* */
03393 template< typename Left_exprT >
03394 inline
03395 xtl_wrap<
03396     xtl_opbinand<
03397         xtl_wrap< Left_exprT >,
03398         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >
03399     >
03400 >
03401 operator& ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_STRING const* rhs_expr_ )
03402 {
03403     typedef
03404         xtl_opbinand<
03405             xtl_wrap< Left_exprT >,
03406             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >
03407         >
03408         opand_T;
03409 
03410     return xtl_wrap< opand_T >( opand_T( lhs_expr_, xtl_text_ref_symbol< CTTL_STD_STRING >( rhs_expr_ ) ) );
03411 }
03412 
03413 
03414 /* specialization for binary CTTL_STD_STRING const* & expr */
03415 template< typename Right_exprT >
03416 inline
03417 xtl_wrap<
03418     xtl_opbinand<
03419         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >,
03420         xtl_wrap< Right_exprT >
03421     >
03422 >
03423 operator& ( CTTL_STD_STRING const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
03424 {
03425     typedef
03426         xtl_opbinand<
03427             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_STRING > >,
03428             xtl_wrap< Right_exprT >
03429         >
03430         opand_T;
03431 
03432     return xtl_wrap< opand_T >( opand_T( xtl_text_ref_symbol< CTTL_STD_STRING >( lhs_expr_ ), rhs_expr_ ) );
03433 }
03434 
03435 
03436 /* specialization for binary expr & CTTL_STD_WSTRING const* */
03437 template< typename Left_exprT >
03438 inline
03439 xtl_wrap<
03440     xtl_opbinand<
03441         xtl_wrap< Left_exprT >,
03442         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >
03443     >
03444 >
03445 operator& ( xtl_wrap< Left_exprT > const& lhs_expr_, CTTL_STD_WSTRING const* rhs_expr_ )
03446 {
03447     typedef
03448         xtl_opbinand<
03449             xtl_wrap< Left_exprT >,
03450             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >
03451         >
03452         opand_T;
03453 
03454     return xtl_wrap< opand_T >( opand_T( lhs_expr_, xtl_text_ref_symbol< CTTL_STD_WSTRING >( rhs_expr_ ) ) );
03455 }
03456 
03457 
03458 /* specialization for binary CTTL_STD_WSTRING const* & expr */
03459 template< typename Right_exprT >
03460 inline
03461 xtl_wrap<
03462     xtl_opbinand<
03463         xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >,
03464         xtl_wrap< Right_exprT >
03465     >
03466 >
03467 operator& ( CTTL_STD_WSTRING const* lhs_expr_, xtl_wrap< Right_exprT > const& rhs_expr_ )
03468 {
03469     typedef
03470         xtl_opbinand<
03471             xtl_wrap< xtl_text_ref_symbol< CTTL_STD_WSTRING > >,
03472             xtl_wrap< Right_exprT >
03473         >
03474         opand_T;
03475 
03476     return xtl_wrap< opand_T >( opand_T( xtl_text_ref_symbol< CTTL_STD_WSTRING >( lhs_expr_ ), rhs_expr_ ) );
03477 }
03478 
03479 
03480 }/* namespace cttl */
03481 
03482 #endif /* _CTTL_XTL_OP_SPECLZD_H_INCLUDED_ */
Generated on Thu Nov 2 17:44:07 2006 for Common Text Transformation Library by  doxygen 1.3.9.1