rasdaman complete source
Main Page
Modules
Namespaces
Classes
Files
File List
File Members
catalogmgr
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
:
46
OpABSCDouble(
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
:
68
OpSQRTCDouble(
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
:
90
OpEXPCDouble(
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
:
222
OpSINHCDouble(
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
:
244
OpCOSHCDouble(
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
:
266
OpTANHCDouble(
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
:
288
OpARCSINCDouble(
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
:
310
OpARCCOSCDouble(
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
:
332
OpARCTANCDouble(
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
BaseType
Definition:
relcatalogif/basetype.hh:66
Generated on Sun Jun 8 2014 16:57:07 for rasdaman complete source by
1.8.6