casa  $Rev:20696$
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
ExprLogicNode.h
Go to the documentation of this file.
00001 //# ExprLogicNode.h: Nodes representing scalar logical operators in table select expression tree
00002 //# Copyright (C) 1994,1995,1996,1997,1999,2000
00003 //# Associated Universities, Inc. Washington DC, USA.
00004 //#
00005 //# This library is free software; you can redistribute it and/or modify it
00006 //# under the terms of the GNU Library General Public License as published by
00007 //# the Free Software Foundation; either version 2 of the License, or (at your
00008 //# option) any later version.
00009 //#
00010 //# This library is distributed in the hope that it will be useful, but WITHOUT
00011 //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
00012 //# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
00013 //# License for more details.
00014 //#
00015 //# You should have received a copy of the GNU Library General Public License
00016 //# along with this library; if not, write to the Free Software Foundation,
00017 //# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
00018 //#
00019 //# Correspondence concerning AIPS++ should be addressed as follows:
00020 //#        Internet email: aips2-request@nrao.edu.
00021 //#        Postal address: AIPS++ Project Office
00022 //#                        National Radio Astronomy Observatory
00023 //#                        520 Edgemont Road
00024 //#                        Charlottesville, VA 22903-2475 USA
00025 //#
00026 //# $Id: ExprLogicNode.h 20652 2009-07-06 05:04:32Z Malte.Marquarding $
00027 
00028 #ifndef TABLES_EXPRLOGICNODE_H
00029 #define TABLES_EXPRLOGICNODE_H
00030 
00031 //# Includes
00032 #include <casa/aips.h>
00033 #include <tables/Tables/ExprNodeRep.h>
00034 
00035 
00036 namespace casa { //# NAMESPACE CASA - BEGIN
00037 
00038 //# This file defines classes derived from TableExprNode representing
00039 //# the data type and operator in a table expression.
00040 //#
00041 //# Data types Bool, Int64, Double, DComplex and String are used.
00042 //# Char, uChar, Short, uShort, Int, and uInt are converted to Int64,
00043 //# Float to Double, and Complex to DComplex.
00044 //# Binary operators ==, >=, >, <, <=, !=, and IN are recognized.
00045 //# Also &&, ||, and unary ! are recognized.
00046 
00047 
00048 
00049 // <summary>
00050 // Bool comparison == in table select expression tree
00051 // </summary>
00052 
00053 // <use visibility=local>
00054 
00055 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00056 // </reviewed>
00057 
00058 // <prerequisite>
00059 //# Classes you should understand before using this one.
00060 //   <li> TableExprNode
00061 // </prerequisite>
00062 
00063 // <synopsis> 
00064 // This class represents an == comparison in a table select expression tree.
00065 // This is defined for all data types.
00066 // Only the Bool get function is defined, because the result of a
00067 // compare is always a Bool.
00068 // </synopsis> 
00069 
00070 class TableExprNodeEQBool : public TableExprNodeBinary
00071 {
00072 public:
00073     TableExprNodeEQBool (const TableExprNodeRep&);
00074     ~TableExprNodeEQBool();
00075     Bool getBool (const TableExprId& id);
00076 };
00077 
00078 
00079 // <summary>
00080 // Int comparison == in table select expression tree
00081 // </summary>
00082 
00083 // <use visibility=local>
00084 
00085 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00086 // </reviewed>
00087 
00088 // <prerequisite>
00089 //# Classes you should understand before using this one.
00090 //   <li> TableExprNode
00091 // </prerequisite>
00092 
00093 // <synopsis> 
00094 // This class represents an == comparison in a table select expression tree.
00095 // This is defined for all data types.
00096 // Only the Bool get function is defined, because the result of a
00097 // compare is always a Bool.
00098 // </synopsis> 
00099 
00100 class TableExprNodeEQInt : public TableExprNodeBinary
00101 {
00102 public:
00103     TableExprNodeEQInt (const TableExprNodeRep&);
00104     ~TableExprNodeEQInt();
00105     Bool getBool (const TableExprId& id);
00106 };
00107 
00108 
00109 // <summary>
00110 // Double comparison == in table select expression tree
00111 // </summary>
00112 
00113 // <use visibility=local>
00114 
00115 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00116 // </reviewed>
00117 
00118 // <prerequisite>
00119 //# Classes you should understand before using this one.
00120 //   <li> TableExprNode
00121 // </prerequisite>
00122 
00123 // <synopsis> 
00124 // This class represents an == comparison in a table select expression tree.
00125 // This is defined for all data types.
00126 // Only the Bool get function is defined, because the result of a
00127 // compare is always a Bool.
00128 // </synopsis> 
00129 
00130 class TableExprNodeEQDouble : public TableExprNodeBinary
00131 {
00132 public:
00133     TableExprNodeEQDouble (const TableExprNodeRep&);
00134     ~TableExprNodeEQDouble();
00135     Bool getBool (const TableExprId& id);
00136     void ranges (Block<TableExprRange>&);
00137 };
00138 
00139 
00140 // <summary>
00141 // DComplex comparison == in table select expression tree
00142 // </summary>
00143 
00144 // <use visibility=local>
00145 
00146 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00147 // </reviewed>
00148 
00149 // <prerequisite>
00150 //# Classes you should understand before using this one.
00151 //   <li> TableExprNode
00152 // </prerequisite>
00153 
00154 // <synopsis> 
00155 // This class represents an == comparison in a table select expression tree.
00156 // This is defined for all data types.
00157 // Only the Bool get function is defined, because the result of a
00158 // compare is always a Bool.
00159 // </synopsis> 
00160 
00161 class TableExprNodeEQDComplex : public TableExprNodeBinary
00162 {
00163 public:
00164     TableExprNodeEQDComplex (const TableExprNodeRep&);
00165     ~TableExprNodeEQDComplex();
00166     Bool getBool (const TableExprId& id);
00167 };
00168 
00169 
00170 // <summary>
00171 // String comparison == in table select expression tree
00172 // </summary>
00173 
00174 // <use visibility=local>
00175 
00176 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00177 // </reviewed>
00178 
00179 // <prerequisite>
00180 //# Classes you should understand before using this one.
00181 //   <li> TableExprNode
00182 // </prerequisite>
00183 
00184 // <synopsis> 
00185 // This class represents an == comparison in a table select expression tree.
00186 // This is defined for all data types.
00187 // Only the Bool get function is defined, because the result of a
00188 // compare is always a Bool.
00189 // </synopsis> 
00190 
00191 class TableExprNodeEQString : public TableExprNodeBinary
00192 {
00193 public:
00194     TableExprNodeEQString (const TableExprNodeRep&);
00195     ~TableExprNodeEQString();
00196     Bool getBool (const TableExprId& id);
00197 };
00198 
00199 
00200 // <summary>
00201 // Regex comparison == in table select expression tree
00202 // </summary>
00203 
00204 // <use visibility=local>
00205 
00206 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00207 // </reviewed>
00208 
00209 // <prerequisite>
00210 //# Classes you should understand before using this one.
00211 //   <li> TableExprNode
00212 // </prerequisite>
00213 
00214 // <synopsis> 
00215 // This class represents an == comparison in a table select expression tree.
00216 // This is defined for all data types.
00217 // Only the Bool get function is defined, because the result of a
00218 // compare is always a Bool.
00219 // </synopsis> 
00220 
00221 class TableExprNodeEQRegex : public TableExprNodeBinary
00222 {
00223 public:
00224     TableExprNodeEQRegex (const TableExprNodeRep&);
00225     ~TableExprNodeEQRegex();
00226     Bool getBool (const TableExprId& id);
00227 };
00228 
00229 
00230 // <summary>
00231 // Date comparison == in table select expression tree
00232 // </summary>
00233 
00234 // <use visibility=local>
00235 
00236 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00237 // </reviewed>
00238 
00239 // <prerequisite>
00240 //# Classes you should understand before using this one.
00241 //   <li> TableExprNode
00242 // </prerequisite>
00243 
00244 // <synopsis> 
00245 // This class represents an == comparison in a table select expression tree.
00246 // This is defined for all data types.
00247 // Only the Bool get function is defined, because the result of a
00248 // compare is always a Bool.
00249 // </synopsis> 
00250 
00251 class TableExprNodeEQDate : public TableExprNodeBinary
00252 {
00253 public:
00254     TableExprNodeEQDate (const TableExprNodeRep&);
00255     ~TableExprNodeEQDate();
00256     Bool getBool (const TableExprId& id);
00257 };
00258 
00259 
00260 
00261 // <summary>
00262 // Bool comparison != in table select expression tree
00263 // </summary>
00264 
00265 // <use visibility=local>
00266 
00267 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00268 // </reviewed>
00269 
00270 // <prerequisite>
00271 //# Classes you should understand before using this one.
00272 //   <li> TableExprNode
00273 // </prerequisite>
00274 
00275 // <synopsis> 
00276 // This class represents an != comparison in a table select expression tree.
00277 // This is defined for all data types.
00278 // Only the Bool get function is defined, because the result of a
00279 // compare is always a Bool.
00280 // </synopsis> 
00281 
00282 class TableExprNodeNEBool : public TableExprNodeBinary
00283 {
00284 public:
00285     TableExprNodeNEBool (const TableExprNodeRep&);
00286     ~TableExprNodeNEBool();
00287     Bool getBool (const TableExprId& id);
00288 };
00289 
00290 
00291 // <summary>
00292 // Int comparison != in table select expression tree
00293 // </summary>
00294 
00295 // <use visibility=local>
00296 
00297 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00298 // </reviewed>
00299 
00300 // <prerequisite>
00301 //# Classes you should understand before using this one.
00302 //   <li> TableExprNode
00303 // </prerequisite>
00304 
00305 // <synopsis> 
00306 // This class represents an != comparison in a table select expression tree.
00307 // This is defined for all data types.
00308 // Only the Bool get function is defined, because the result of a
00309 // compare is always a Bool.
00310 // </synopsis> 
00311 
00312 class TableExprNodeNEInt : public TableExprNodeBinary
00313 {
00314 public:
00315     TableExprNodeNEInt (const TableExprNodeRep&);
00316     ~TableExprNodeNEInt();
00317     Bool getBool (const TableExprId& id);
00318 };
00319 
00320 
00321 // <summary>
00322 // Double comparison != in table select expression tree
00323 // </summary>
00324 
00325 // <use visibility=local>
00326 
00327 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00328 // </reviewed>
00329 
00330 // <prerequisite>
00331 //# Classes you should understand before using this one.
00332 //   <li> TableExprNode
00333 // </prerequisite>
00334 
00335 // <synopsis> 
00336 // This class represents an != comparison in a table select expression tree.
00337 // This is defined for all data types.
00338 // Only the Bool get function is defined, because the result of a
00339 // compare is always a Bool.
00340 // </synopsis> 
00341 
00342 class TableExprNodeNEDouble : public TableExprNodeBinary
00343 {
00344 public:
00345     TableExprNodeNEDouble (const TableExprNodeRep&);
00346     ~TableExprNodeNEDouble();
00347     Bool getBool (const TableExprId& id);
00348 };
00349 
00350 
00351 // <summary>
00352 // DComplex comparison != in table select expression tree
00353 // </summary>
00354 
00355 // <use visibility=local>
00356 
00357 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00358 // </reviewed>
00359 
00360 // <prerequisite>
00361 //# Classes you should understand before using this one.
00362 //   <li> TableExprNode
00363 // </prerequisite>
00364 
00365 // <synopsis> 
00366 // This class represents an != comparison in a table select expression tree.
00367 // This is defined for all data types.
00368 // Only the Bool get function is defined, because the result of a
00369 // compare is always a Bool.
00370 // </synopsis> 
00371 
00372 class TableExprNodeNEDComplex : public TableExprNodeBinary
00373 {
00374 public:
00375     TableExprNodeNEDComplex (const TableExprNodeRep&);
00376     ~TableExprNodeNEDComplex();
00377     Bool getBool (const TableExprId& id);
00378 };
00379 
00380 
00381 // <summary>
00382 // String comparison != in table select expression tree
00383 // </summary>
00384 
00385 // <use visibility=local>
00386 
00387 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00388 // </reviewed>
00389 
00390 // <prerequisite>
00391 //# Classes you should understand before using this one.
00392 //   <li> TableExprNode
00393 // </prerequisite>
00394 
00395 // <synopsis> 
00396 // This class represents an != comparison in a table select expression tree.
00397 // This is defined for all data types.
00398 // Only the Bool get function is defined, because the result of a
00399 // compare is always a Bool.
00400 // </synopsis> 
00401 
00402 class TableExprNodeNEString : public TableExprNodeBinary
00403 {
00404 public:
00405     TableExprNodeNEString (const TableExprNodeRep&);
00406     ~TableExprNodeNEString();
00407     Bool getBool (const TableExprId& id);
00408 };
00409 
00410 
00411 // <summary>
00412 // Regex comparison != in table select expression tree
00413 // </summary>
00414 
00415 // <use visibility=local>
00416 
00417 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00418 // </reviewed>
00419 
00420 // <prerequisite>
00421 //# Classes you should understand before using this one.
00422 //   <li> TableExprNode
00423 // </prerequisite>
00424 
00425 // <synopsis> 
00426 // This class represents an != comparison in a table select expression tree.
00427 // This is defined for all data types.
00428 // Only the Bool get function is defined, because the result of a
00429 // compare is always a Bool.
00430 // </synopsis> 
00431 
00432 class TableExprNodeNERegex : public TableExprNodeBinary
00433 {
00434 public:
00435     TableExprNodeNERegex (const TableExprNodeRep&);
00436     ~TableExprNodeNERegex();
00437     Bool getBool (const TableExprId& id);
00438 };
00439 
00440 
00441 // <summary>
00442 // Date comparison != in table select expression tree
00443 // </summary>
00444 
00445 // <use visibility=local>
00446 
00447 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00448 // </reviewed>
00449 
00450 // <prerequisite>
00451 //# Classes you should understand before using this one.
00452 //   <li> TableExprNode
00453 // </prerequisite>
00454 
00455 // <synopsis> 
00456 // This class represents an != comparison in a table select expression tree.
00457 // This is defined for all data types.
00458 // Only the Bool get function is defined, because the result of a
00459 // compare is always a Bool.
00460 // </synopsis> 
00461 
00462 class TableExprNodeNEDate : public TableExprNodeBinary
00463 {
00464 public:
00465     TableExprNodeNEDate (const TableExprNodeRep&);
00466     ~TableExprNodeNEDate();
00467     Bool getBool (const TableExprId& id);
00468 };
00469 
00470 
00471 
00472 // <summary>
00473 // Int comparison > in table select expression tree
00474 // </summary>
00475 
00476 // <use visibility=local>
00477 
00478 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00479 // </reviewed>
00480 
00481 // <prerequisite>
00482 //# Classes you should understand before using this one.
00483 //   <li> TableExprNode
00484 // </prerequisite>
00485 
00486 // <synopsis> 
00487 // This class represents an > comparison in a table select expression tree.
00488 // This is defined for all data types.
00489 // Only the Bool get function is defined, because the result of a
00490 // compare is always a Bool.
00491 // </synopsis> 
00492 
00493 class TableExprNodeGTInt : public TableExprNodeBinary
00494 {
00495 public:
00496     TableExprNodeGTInt (const TableExprNodeRep&);
00497     ~TableExprNodeGTInt();
00498     Bool getBool (const TableExprId& id);
00499 };
00500 
00501 
00502 // <summary>
00503 // Double comparison > in table select expression tree
00504 // </summary>
00505 
00506 // <use visibility=local>
00507 
00508 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00509 // </reviewed>
00510 
00511 // <prerequisite>
00512 //# Classes you should understand before using this one.
00513 //   <li> TableExprNode
00514 // </prerequisite>
00515 
00516 // <synopsis> 
00517 // This class represents an > comparison in a table select expression tree.
00518 // This is defined for all data types.
00519 // Only the Bool get function is defined, because the result of a
00520 // compare is always a Bool.
00521 // </synopsis> 
00522 
00523 class TableExprNodeGTDouble : public TableExprNodeBinary
00524 {
00525 public:
00526     TableExprNodeGTDouble (const TableExprNodeRep&);
00527     ~TableExprNodeGTDouble();
00528     Bool getBool (const TableExprId& id);
00529     void ranges (Block<TableExprRange>&);
00530 };
00531 
00532 
00533 // <summary>
00534 // DComplex comparison > in table select expression tree
00535 // </summary>
00536 
00537 // <use visibility=local>
00538 
00539 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00540 // </reviewed>
00541 
00542 // <prerequisite>
00543 //# Classes you should understand before using this one.
00544 //   <li> TableExprNode
00545 // </prerequisite>
00546 
00547 // <synopsis> 
00548 // This class represents an > comparison in a table select expression tree.
00549 // This is defined for all data types.
00550 // Only the Bool get function is defined, because the result of a
00551 // compare is always a Bool.
00552 // </synopsis> 
00553 
00554 class TableExprNodeGTDComplex : public TableExprNodeBinary
00555 {
00556 public:
00557     TableExprNodeGTDComplex (const TableExprNodeRep&);
00558     ~TableExprNodeGTDComplex();
00559     Bool getBool (const TableExprId& id);
00560 };
00561 
00562 
00563 // <summary>
00564 // String comparison > in table select expression tree
00565 // </summary>
00566 
00567 // <use visibility=local>
00568 
00569 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00570 // </reviewed>
00571 
00572 // <prerequisite>
00573 //# Classes you should understand before using this one.
00574 //   <li> TableExprNode
00575 // </prerequisite>
00576 
00577 // <synopsis> 
00578 // This class represents an > comparison in a table select expression tree.
00579 // This is defined for all data types.
00580 // Only the Bool get function is defined, because the result of a
00581 // compare is always a Bool.
00582 // </synopsis> 
00583 
00584 class TableExprNodeGTString : public TableExprNodeBinary
00585 {
00586 public:
00587     TableExprNodeGTString (const TableExprNodeRep&);
00588     ~TableExprNodeGTString();
00589     Bool getBool (const TableExprId& id);
00590 };
00591 
00592 
00593 // <summary>
00594 // Date comparison > in table select expression tree
00595 // </summary>
00596 
00597 // <use visibility=local>
00598 
00599 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00600 // </reviewed>
00601 
00602 // <prerequisite>
00603 //# Classes you should understand before using this one.
00604 //   <li> TableExprNode
00605 // </prerequisite>
00606 
00607 // <synopsis> 
00608 // This class represents an > comparison in a table select expression tree.
00609 // This is defined for all data types.
00610 // Only the Bool get function is defined, because the result of a
00611 // compare is always a Bool.
00612 // </synopsis> 
00613 
00614 class TableExprNodeGTDate : public TableExprNodeBinary
00615 {
00616 public:
00617     TableExprNodeGTDate (const TableExprNodeRep&);
00618     ~TableExprNodeGTDate();
00619     Bool getBool (const TableExprId& id);
00620 };
00621 
00622 
00623 
00624 // <summary>
00625 // Int comparison >= in table select expression tree
00626 // </summary>
00627 
00628 // <use visibility=local>
00629 
00630 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00631 // </reviewed>
00632 
00633 // <prerequisite>
00634 //# Classes you should understand before using this one.
00635 //   <li> TableExprNode
00636 // </prerequisite>
00637 
00638 // <synopsis> 
00639 // This class represents an >= comparison in a table select expression tree.
00640 // This is defined for all data types.
00641 // Only the Bool get function is defined, because the result of a
00642 // compare is always a Bool.
00643 // </synopsis> 
00644 
00645 class TableExprNodeGEInt : public TableExprNodeBinary
00646 {
00647 public:
00648     TableExprNodeGEInt (const TableExprNodeRep&);
00649     ~TableExprNodeGEInt();
00650     Bool getBool (const TableExprId& id);
00651 };
00652 
00653 
00654 // <summary>
00655 // Double comparison >= in table select expression tree
00656 // </summary>
00657 
00658 // <use visibility=local>
00659 
00660 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00661 // </reviewed>
00662 
00663 // <prerequisite>
00664 //# Classes you should understand before using this one.
00665 //   <li> TableExprNode
00666 // </prerequisite>
00667 
00668 // <synopsis> 
00669 // This class represents an >= comparison in a table select expression tree.
00670 // This is defined for all data types.
00671 // Only the Bool get function is defined, because the result of a
00672 // compare is always a Bool.
00673 // </synopsis> 
00674 
00675 class TableExprNodeGEDouble : public TableExprNodeBinary
00676 {
00677 public:
00678     TableExprNodeGEDouble (const TableExprNodeRep&);
00679     ~TableExprNodeGEDouble();
00680     Bool getBool (const TableExprId& id);
00681     void ranges (Block<TableExprRange>&);
00682 };
00683 
00684 
00685 // <summary>
00686 // DComplex comparison >= in table select expression tree
00687 // </summary>
00688 
00689 // <use visibility=local>
00690 
00691 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00692 // </reviewed>
00693 
00694 // <prerequisite>
00695 //# Classes you should understand before using this one.
00696 //   <li> TableExprNode
00697 // </prerequisite>
00698 
00699 // <synopsis> 
00700 // This class represents an >= comparison in a table select expression tree.
00701 // This is defined for all data types.
00702 // Only the Bool get function is defined, because the result of a
00703 // compare is always a Bool.
00704 // </synopsis> 
00705 
00706 class TableExprNodeGEDComplex : public TableExprNodeBinary
00707 {
00708 public:
00709     TableExprNodeGEDComplex (const TableExprNodeRep&);
00710     ~TableExprNodeGEDComplex();
00711     Bool getBool (const TableExprId& id);
00712 };
00713 
00714 
00715 // <summary>
00716 // String comparison >= in table select expression tree
00717 // </summary>
00718 
00719 // <use visibility=local>
00720 
00721 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00722 // </reviewed>
00723 
00724 // <prerequisite>
00725 //# Classes you should understand before using this one.
00726 //   <li> TableExprNode
00727 // </prerequisite>
00728 
00729 // <synopsis> 
00730 // This class represents an >= comparison in a table select expression tree.
00731 // This is defined for all data types.
00732 // Only the Bool get function is defined, because the result of a
00733 // compare is always a Bool.
00734 // </synopsis> 
00735 
00736 class TableExprNodeGEString : public TableExprNodeBinary
00737 {
00738 public:
00739     TableExprNodeGEString (const TableExprNodeRep&);
00740     ~TableExprNodeGEString();
00741     Bool getBool (const TableExprId& id);
00742 };
00743 
00744 
00745 // <summary>
00746 // Date comparison >= in table select expression tree
00747 // </summary>
00748 
00749 // <use visibility=local>
00750 
00751 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00752 // </reviewed>
00753 
00754 // <prerequisite>
00755 //# Classes you should understand before using this one.
00756 //   <li> TableExprNode
00757 // </prerequisite>
00758 
00759 // <synopsis> 
00760 // This class represents an >= comparison in a table select expression tree.
00761 // This is defined for all data types.
00762 // Only the Bool get function is defined, because the result of a
00763 // compare is always a Bool.
00764 // </synopsis> 
00765 
00766 class TableExprNodeGEDate : public TableExprNodeBinary
00767 {
00768 public:
00769     TableExprNodeGEDate (const TableExprNodeRep&);
00770     ~TableExprNodeGEDate();
00771     Bool getBool (const TableExprId& id);
00772 };
00773 
00774 
00775 
00776 // <summary>
00777 // Int comparison IN in table select expression tree
00778 // </summary>
00779 
00780 // <use visibility=local>
00781 
00782 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00783 // </reviewed>
00784 
00785 // <prerequisite>
00786 //# Classes you should understand before using this one.
00787 //   <li> TableExprNode
00788 // </prerequisite>
00789 
00790 // <synopsis> 
00791 // This class represents an IN comparison in a table select expression tree.
00792 // This is defined for all data types.
00793 // Only the Bool get function is defined, because the result of a
00794 // compare is always a Bool.
00795 // </synopsis> 
00796 
00797 class TableExprNodeINInt : public TableExprNodeBinary
00798 {
00799 public:
00800     TableExprNodeINInt (const TableExprNodeRep&);
00801     ~TableExprNodeINInt();
00802     Bool getBool (const TableExprId& id);
00803 };
00804 
00805 
00806 // <summary>
00807 // Double comparison IN in table select expression tree
00808 // </summary>
00809 
00810 // <use visibility=local>
00811 
00812 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00813 // </reviewed>
00814 
00815 // <prerequisite>
00816 //# Classes you should understand before using this one.
00817 //   <li> TableExprNode
00818 // </prerequisite>
00819 
00820 // <synopsis> 
00821 // This class represents an IN comparison in a table select expression tree.
00822 // This is defined for all data types.
00823 // Only the Bool get function is defined, because the result of a
00824 // compare is always a Bool.
00825 // </synopsis> 
00826 
00827 class TableExprNodeINDouble : public TableExprNodeBinary
00828 {
00829 public:
00830     TableExprNodeINDouble (const TableExprNodeRep&);
00831     ~TableExprNodeINDouble();
00832     Bool getBool (const TableExprId& id);
00833 };
00834 
00835 
00836 // <summary>
00837 // DComplex comparison IN in table select expression tree
00838 // </summary>
00839 
00840 // <use visibility=local>
00841 
00842 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00843 // </reviewed>
00844 
00845 // <prerequisite>
00846 //# Classes you should understand before using this one.
00847 //   <li> TableExprNode
00848 // </prerequisite>
00849 
00850 // <synopsis> 
00851 // This class represents an IN comparison in a table select expression tree.
00852 // This is defined for all data types.
00853 // Only the Bool get function is defined, because the result of a
00854 // compare is always a Bool.
00855 // </synopsis> 
00856 
00857 class TableExprNodeINDComplex : public TableExprNodeBinary
00858 {
00859 public:
00860     TableExprNodeINDComplex (const TableExprNodeRep&);
00861     ~TableExprNodeINDComplex();
00862     Bool getBool (const TableExprId& id);
00863 };
00864 
00865 
00866 // <summary>
00867 // String comparison IN in table select expression tree
00868 // </summary>
00869 
00870 // <use visibility=local>
00871 
00872 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00873 // </reviewed>
00874 
00875 // <prerequisite>
00876 //# Classes you should understand before using this one.
00877 //   <li> TableExprNode
00878 // </prerequisite>
00879 
00880 // <synopsis> 
00881 // This class represents an IN comparison in a table select expression tree.
00882 // This is defined for all data types.
00883 // Only the Bool get function is defined, because the result of a
00884 // compare is always a Bool.
00885 // </synopsis> 
00886 
00887 class TableExprNodeINString : public TableExprNodeBinary
00888 {
00889 public:
00890     TableExprNodeINString (const TableExprNodeRep&);
00891     ~TableExprNodeINString();
00892     Bool getBool (const TableExprId& id);
00893 };
00894 
00895 
00896 // <summary>
00897 // Date comparison IN in table select expression tree
00898 // </summary>
00899 
00900 // <use visibility=local>
00901 
00902 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00903 // </reviewed>
00904 
00905 // <prerequisite>
00906 //# Classes you should understand before using this one.
00907 //   <li> TableExprNode
00908 // </prerequisite>
00909 
00910 // <synopsis> 
00911 // This class represents an IN comparison in a table select expression tree.
00912 // This is defined for all data types.
00913 // Only the Bool get function is defined, because the result of a
00914 // compare is always a Bool.
00915 // </synopsis> 
00916 
00917 class TableExprNodeINDate : public TableExprNodeBinary
00918 {
00919 public:
00920     TableExprNodeINDate (const TableExprNodeRep&);
00921     ~TableExprNodeINDate();
00922     Bool getBool (const TableExprId& id);
00923 };
00924 
00925 
00926 
00927 // <summary>
00928 // Logical or in table select expression tree
00929 // </summary>
00930 
00931 // <use visibility=local>
00932 
00933 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00934 // </reviewed>
00935 
00936 // <prerequisite>
00937 //# Classes you should understand before using this one.
00938 //   <li> TableExprNode
00939 // </prerequisite>
00940 
00941 // <synopsis> 
00942 // This class represents a logical or in a table select expression tree.
00943 // This is defined for Bool only.
00944 // </synopsis> 
00945 
00946 class TableExprNodeOR : public TableExprNodeBinary
00947 {
00948 public:
00949     TableExprNodeOR (const TableExprNodeRep&);
00950     ~TableExprNodeOR();
00951     Bool getBool (const TableExprId& id);
00952     void ranges (Block<TableExprRange>&);
00953 };
00954 
00955 
00956 // <summary>
00957 // Logical and in table select expression tree
00958 // </summary>
00959 
00960 // <use visibility=local>
00961 
00962 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00963 // </reviewed>
00964 
00965 // <prerequisite>
00966 //# Classes you should understand before using this one.
00967 //   <li> TableExprNode
00968 // </prerequisite>
00969 
00970 // <synopsis> 
00971 // This class represents a logical and in a table select expression tree.
00972 // This is defined for Bool only.
00973 // </synopsis> 
00974 
00975 class TableExprNodeAND: public TableExprNodeBinary
00976 {
00977 public:
00978     TableExprNodeAND (const TableExprNodeRep&);
00979     ~TableExprNodeAND();
00980     Bool getBool (const TableExprId& id);
00981     void ranges (Block<TableExprRange>&);
00982 };
00983 
00984 
00985 // <summary>
00986 // Logical not in table select expression tree
00987 // </summary>
00988 
00989 // <use visibility=local>
00990 
00991 // <reviewed reviewer="UNKNOWN" date="before2004/08/25" tests="">
00992 // </reviewed>
00993 
00994 // <prerequisite>
00995 //# Classes you should understand before using this one.
00996 //   <li> TableExprNode
00997 // </prerequisite>
00998 
00999 // <synopsis> 
01000 // This class represents a logical not in a table select expression tree.
01001 // This is defined for Bool only.
01002 // </synopsis> 
01003 
01004 class TableExprNodeNOT: public TableExprNodeBinary
01005 {
01006 public:
01007     TableExprNodeNOT (const TableExprNodeRep&);
01008     ~TableExprNodeNOT();
01009     Bool getBool (const TableExprId& id);
01010 };
01011 
01012 
01013 
01014 
01015 } //# NAMESPACE CASA - END
01016 
01017 #endif