1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
#ifndef _QTNARYOPERATION_
#define _QTNARYOPERATION_
#ifndef CPPSTDLIB
#include <ospace/string.h> // STL<ToolKit>
#else
#include <string>
#endif
#include <stdio.h>
#include "qlparser/qtoperation.hh"
/*
* This file is part of rasdaman community.
*
* Rasdaman community is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Rasdaman community is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with rasdaman community. If not, see <http://www.gnu.org/licenses/>.
*
* Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009 Peter Baumann /
rasdaman GmbH.
*
* For more information please see <http://www.rasdaman.org>
* or contact Peter Baumann via <baumann@rasdaman.com>.
*/
/**************************************************************
*
*
* COMMENTS:
*
************************************************************/
//@ManMemo: Module: {\bf qlparser}
/*@Doc:
The class serves as superclass for all operation classes taking n
(more than two) arguments.
*/
class QtNaryOperation : public QtOperation
{
public:
/// default constructor
QtNaryOperation();
/// constructor getting the node to the parent
QtNaryOperation( QtNode* node );
/// constructor getting a list of operands
QtNaryOperation( QtOperationList* opList );
/// virtual destructor
virtual ~QtNaryOperation();
/// simplifies the tree
virtual void simplify();
/// test if the two nodes have an equal meaning in the query tree
virtual bool equalMeaning( QtNode* node );
/**
The meaning of a binary operation is equal, iff all operands have
the same meaning.
*/
/// return childs of the node
virtual QtNodeList* getChilds( QtChildType flag );
/// creates a unique name for a subexpression
virtual std::string getSpelling();
/// method for query rewrite
virtual void setInput( QtOperation*, QtOperation* inputNew );
/// tests if the edge to the parent node is of type mdd or atomic
virtual QtAreaType getAreaType();
/// method for checking idempotency rules
// virtual void checkIdempotency();
/// optimizing load access
virtual void optimizeLoad( QtTrimList* trimList );
/**
The method deletes the given {\tt trimList} and passes the {\tt optimizeLoad}
message with empty triming lists to its input trees.
*/
/// debugging method
virtual void printTree( int tab, std::ostream& s = std::cout, QtChildType mode = QT_ALL_NODES );
/// prints the algebraic expression
virtual void printAlgebraicExpression( std::ostream& s = std::cout );
//@Man: read/write methods for the operands
//@{
///
///
inline void setInputs( QtOperationList* opList );
///
inline QtNode::QtOperationList* getInputs();
///
//@}
protected:
/// method for testing and evaluating the input branches
bool getOperands( QtDataList* inputList, QtDataList* &operandList );
/**
The method checks if the input branches are valid. Then it passes the evaluate message to its two
operands with the {\tt inputList} as argument. The returned results are provided through the arguments
{\tt operand1} and {\tt operand2} called by reference. The method returns {\tt true} if the operands are
valid, otherwise {\tt false}.
*/
/// operation trees
QtOperationList* operationList;
private:
/// atribute for identification of nodes
static const QtNodeType nodeType;
};
#include "qlparser/qtnaryoperation.icc"
#endif
|
