rasdaman complete source
autogen_ops.hh
Go to the documentation of this file.
1 /*
2 * This file is part of rasdaman community.
3 *
4 * Rasdaman community is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation, either version 3 of the License, or
7 * (at your option) any later version.
8 *
9 * Rasdaman community is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with rasdaman community. If not, see <http://www.gnu.org/licenses/>.
16 *
17 * Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009 Peter Baumann /
18 rasdaman GmbH.
19 *
20 * For more information please see <http://www.rasdaman.org>
21 * or contact Peter Baumann via <baumann@rasdaman.com>.
22 /
23 /*************************************************************
24  *
25  *
26  *
27  *
28  * COMMENTS: Automaticaly generated
29  *
30  ************************************************************/
31 
32 
33 //@ManMemo: Module: {\bf catalogmgr}
34 
35 /*@Doc:
36 
37 */
38 
39 // class declaration
43 class OpABSCDouble : public UnaryOp
44 {
45 public:
47  const BaseType* newResType,
48  const BaseType* newOpType,
49  unsigned int newResOff = 0,
50  unsigned int newOpOff = 0
51  );
52  virtual void operator() (char* result, const char* op);
53 };
54 
55 //@ManMemo: Module: {\bf catalogmgr}
56 
57 /*@Doc:
58 
59 */
60 
61 // class declaration
65 class OpSQRTCDouble : public UnaryOp
66 {
67 public:
69  const BaseType* newResType,
70  const BaseType* newOpType,
71  unsigned int newResOff = 0,
72  unsigned int newOpOff = 0
73  );
74  virtual void operator() (char* result, const char* op);
75 };
76 
77 //@ManMemo: Module: {\bf catalogmgr}
78 
79 /*@Doc:
80 
81 */
82 
83 // class declaration
87 class OpEXPCDouble : public UnaryOp
88 {
89 public:
91  const BaseType* newResType,
92  const BaseType* newOpType,
93  unsigned int newResOff = 0,
94  unsigned int newOpOff = 0
95  );
96  virtual void operator() (char* result, const char* op);
97 };
98 
99 //@ManMemo: Module: {\bf catalogmgr}
100 
101 /*@Doc:
102 
103 */
104 
105 // class declaration
109 class OpLOGCDouble : public UnaryOp
110 {
111 public:
112  OpLOGCDouble(
113  const BaseType* newResType,
114  const BaseType* newOpType,
115  unsigned int newResOff = 0,
116  unsigned int newOpOff = 0
117  );
118  virtual void operator() (char* result, const char* op);
119 };
120 
121 //@ManMemo: Module: {\bf catalogmgr}
122 
123 /*@Doc:
124 
125 */
126 
127 // class declaration
131 class OpLNCDouble : public UnaryOp
132 {
133 public:
134  OpLNCDouble(
135  const BaseType* newResType,
136  const BaseType* newOpType,
137  unsigned int newResOff = 0,
138  unsigned int newOpOff = 0
139  );
140  virtual void operator() (char* result, const char* op);
141 };
142 
143 //@ManMemo: Module: {\bf catalogmgr}
144 
145 /*@Doc:
146 
147 */
148 
149 // class declaration
153 class OpSINCDouble : public UnaryOp
154 {
155 public:
156  OpSINCDouble(
157  const BaseType* newResType,
158  const BaseType* newOpType,
159  unsigned int newResOff = 0,
160  unsigned int newOpOff = 0
161  );
162  virtual void operator() (char* result, const char* op);
163 };
164 
165 //@ManMemo: Module: {\bf catalogmgr}
166 
167 /*@Doc:
168 
169 */
170 
171 // class declaration
175 class OpCOSCDouble : public UnaryOp
176 {
177 public:
178  OpCOSCDouble(
179  const BaseType* newResType,
180  const BaseType* newOpType,
181  unsigned int newResOff = 0,
182  unsigned int newOpOff = 0
183  );
184  virtual void operator() (char* result, const char* op);
185 };
186 
187 //@ManMemo: Module: {\bf catalogmgr}
188 
189 /*@Doc:
190 
191 */
192 
193 // class declaration
197 class OpTANCDouble : public UnaryOp
198 {
199 public:
200  OpTANCDouble(
201  const BaseType* newResType,
202  const BaseType* newOpType,
203  unsigned int newResOff = 0,
204  unsigned int newOpOff = 0
205  );
206  virtual void operator() (char* result, const char* op);
207 };
208 
209 //@ManMemo: Module: {\bf catalogmgr}
210 
211 /*@Doc:
212 
213 */
214 
215 // class declaration
219 class OpSINHCDouble : public UnaryOp
220 {
221 public:
223  const BaseType* newResType,
224  const BaseType* newOpType,
225  unsigned int newResOff = 0,
226  unsigned int newOpOff = 0
227  );
228  virtual void operator() (char* result, const char* op);
229 };
230 
231 //@ManMemo: Module: {\bf catalogmgr}
232 
233 /*@Doc:
234 
235 */
236 
237 // class declaration
241 class OpCOSHCDouble : public UnaryOp
242 {
243 public:
245  const BaseType* newResType,
246  const BaseType* newOpType,
247  unsigned int newResOff = 0,
248  unsigned int newOpOff = 0
249  );
250  virtual void operator() (char* result, const char* op);
251 };
252 
253 //@ManMemo: Module: {\bf catalogmgr}
254 
255 /*@Doc:
256 
257 */
258 
259 // class declaration
263 class OpTANHCDouble : public UnaryOp
264 {
265 public:
267  const BaseType* newResType,
268  const BaseType* newOpType,
269  unsigned int newResOff = 0,
270  unsigned int newOpOff = 0
271  );
272  virtual void operator() (char* result, const char* op);
273 };
274 
275 //@ManMemo: Module: {\bf catalogmgr}
276 
277 /*@Doc:
278 
279 */
280 
281 // class declaration
285 class OpARCSINCDouble : public UnaryOp
286 {
287 public:
289  const BaseType* newResType,
290  const BaseType* newOpType,
291  unsigned int newResOff = 0,
292  unsigned int newOpOff = 0
293  );
294  virtual void operator() (char* result, const char* op);
295 };
296 
297 //@ManMemo: Module: {\bf catalogmgr}
298 
299 /*@Doc:
300 
301 */
302 
303 // class declaration
307 class OpARCCOSCDouble : public UnaryOp
308 {
309 public:
311  const BaseType* newResType,
312  const BaseType* newOpType,
313  unsigned int newResOff = 0,
314  unsigned int newOpOff = 0
315  );
316  virtual void operator() (char* result, const char* op);
317 };
318 
319 //@ManMemo: Module: {\bf catalogmgr}
320 
321 /*@Doc:
322 
323 */
324 
325 // class declaration
329 class OpARCTANCDouble : public UnaryOp
330 {
331 public:
333  const BaseType* newResType,
334  const BaseType* newOpType,
335  unsigned int newResOff = 0,
336  unsigned int newOpOff = 0
337  );
338  virtual void operator() (char* result, const char* op);
339 };
340 
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op}.
OpCOSCDouble(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
Definition: autogen_ops.hh:219
Definition: autogen_ops.hh:131
OpTANHCDouble(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
Definition: autogen_ops.hh:329
Definition: autogen_ops.hh:87
OpLOGCDouble(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op}.
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op}.
OpARCCOSCDouble(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op}.
OpCOSHCDouble(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
OpSQRTCDouble(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
Definition: autogen_ops.hh:65
OpABSCDouble(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
Definition: autogen_ops.hh:285
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op}.
OpARCSINCDouble(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
OpTANCDouble(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
Definition: autogen_ops.hh:153
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op}.
Definition: ops.hh:614
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op}.
OpARCTANCDouble(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
Definition: autogen_ops.hh:263
Definition: autogen_ops.hh:109
OpSINHCDouble(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
Definition: autogen_ops.hh:197
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op}.
Definition: autogen_ops.hh:43
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op}.
Definition: relcatalogif/basetype.hh:66
Definition: autogen_ops.hh:175
Definition: autogen_ops.hh:241
OpEXPCDouble(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
Definition: autogen_ops.hh:307
OpLNCDouble(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op}.
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op}.
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op}.
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op}.
OpSINCDouble(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op}.