rasdaman complete source
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  * PURPOSE:
27  * Ops contains an enum for identifying all possible
28  * operations.
29  *
30  *
31  * COMMENTS:
32  *
33  ************************************************************/
34 
35 #ifndef _OPS_HH_
36 #define _OPS_HH_
37 
38 #include <limits.h>
39 
40 class CondenseOp;
41 class UnaryOp;
42 class BinaryOp;
43 class BaseType;
44 class StructType;
45 class Tile;
46 class r_Point;
47 
48 //@Man: TypeEnum
49 //@Type: typedef
50 //@Memo: Module: {\bf catalogif}.
51 
53 {
55  COMPLEXTYPE1, // COMPLEX already defined as token !!!
59 };
60 
61 /*@Doc: This is an enum used for handling types instead of using the
62  string representation of the name. For some strange reason
63  I did not manage to define it in Ops scope. I had to use BOOLTYPE
64  instead of BOOL because of name conflicts.
65 
66  Attention: DO NOT change the sequence because some code relies on it.
67 This is the ops code and the persistence code: from the typenum the oids are generated. changing the order of the enums makes old databases incompatible. there is already a migration tool which shows how to adapt the database schema.
68  */
69 
70 //@ManMemo: Module: {\bf catalogif}.
71 
72 /*@Doc:
73  The class Ops is contains an enumeration type giving symbolic names
74  to all implemented operations. These names are given as parameters
75  to functions concerning operations in \Ref{Tile} and
76  \Ref{BaseType}. The selection of operations is actually done in
77  functions of this class, called by the classes mentioned above. The
78  operations are implemented in subclasses of \Ref{CondenseOp},
79  \Ref{UnaryOp} and \Ref{BinaryOp}.
80 
81  The operations in the following table are defined at the moment.
82  They can be used in expressions like {\tt Ops::OP_EQUAL}.
83 
84  \begin{tabular}{cl}
85 
86  symbolic name && operation \\
87 
88  && {\bf condense operations} \\
89  OP_SOME && condense boolean tile with OR \\
90  OP_ALL && condense boolean tile with AND \\
91 
92  && {\bf unary operations} \\
93  OP_NOT && negation (bitwise for ints, logical for bools) \\
94  OP_SQRT && square root (for doubles) \\
95  OP_IDENTITY && used for copying cells \\
96 
97  && {\bf binary operations} \\
98  OP_MINUS && subtraction \\
99  OP_PLUS && addition \\
100  OP_MULT && multiplication \\
101  OP_DIV && division \\
102  OP_IS && not implemented yet \\
103  OP_AND && bitwise resp. logical AND \\
104  OP_OR && bitwise resp. logical OR \\
105  OP_XOR && bitwise resp. logical XOR \\
106  OP_EQUAL && equality (result Bool) \\
107  OP_LESS && less than (result Bool) \\
108  OP_LESSEQUAL && less than or equal (result Bool) \\
109  OP_NOTEQUAL && inequality (result Bool) \\
110  OP_GREATER && greater than (result Bool) \\
111  OP_GREATEREQUAL && greater than or equal (result Bool) \\
112 
113  \end{tabular}
114 */
118 class Ops
119 {
120 public:
121  enum OpType
122  {
123  // condense operations.
125  /* insert new condense ops before this line */ OP_ALL,
126  // unary operations.
128 
129  //*******************
137 
140 
152  //*******************
153 
154  /* insert new unary ops before this line */ OP_IDENTITY,
155  // binary operations.
158  /* insert new binary ops before this line */
161 
162  };
163 
164 
165 //@Man: methods for getting functions
167  static UnaryOp* getUnaryOp( Ops::OpType op, const BaseType* restype,
169  const BaseType* optype, unsigned int resOff = 0,
170  unsigned int opOff = 0 );
171  /*@Doc:
172  An \Ref{UnaryOp} carrying out #op# on the given types is
173  returned. If #op# is not applicable to the given types,
174  0 is returned.
175  */
177  static BinaryOp* getBinaryOp( Ops::OpType op, const BaseType* resType,
178  const BaseType* op1Type, const BaseType* op2Type,
179  unsigned int resOff = 0,
180  unsigned int op1Off = 0,
181  unsigned int op2Off = 0 );
182  /*@Doc:
183  An \Ref{BinaryOp} carrying out #op# on the given types is
184  returned. If #op# is not applicable to the given types,
185  0 is returned.
186  */
187  static CondenseOp* getCondenseOp( Ops::OpType op, const BaseType* resType,
188  const BaseType* opType = 0,
189  unsigned int resOff = 0,
190  unsigned int opOff = 0);
192  static CondenseOp* getCondenseOp( Ops::OpType op, const BaseType* resType,
193  char* newAccu, const BaseType* opType = 0,
194  unsigned int resOff = 0,
195  unsigned int opOff = 0 );
196  /*@Doc:
197  An \Ref{CondenseOp} carrying out #op# on the given types is
198  returned. If #op# is not applicable to the given types,
199  0 is returned.
200  */
202 
203 //@Man: methods for checking applicability of functions.
205  static int isApplicable( Ops::OpType op, const BaseType* op1Type,
207  const BaseType* op2Type = 0 );
208  /*@Doc:
209  For unary or condense operations, just leave out #op2Type# (or
210  set it to 0).
211  */
213  static const BaseType* getResultType( Ops::OpType op, const BaseType* op1,
214  const BaseType* op2 = 0 );
215  /*@Doc:
216  This usually gives back the "stronger" type of #op1Type# or #op2Type#
217  (e.g. for a function like OP_PLUS). Usually the operation can also
218  be applied to another type, loosing information if the type is
219  "weaker". At the moment, only comparison operations (e.g. OP_EQUAL)
220  have a well defined return type, which is Bool. No other return type
221  can be used for these operations. If the operation is not applicable
222  to the given type, 0 is returned.
223  */
225  static void execUnaryConstOp( Ops::OpType op, const BaseType* resType,
226  const BaseType* opType, char* res,
227  const char* op1, unsigned int resOff = 0,
228  unsigned int opOff = 0 );
230  static void execBinaryConstOp( Ops::OpType op, const BaseType* resType,
231  const BaseType* op1Type,
232  const BaseType* op2Type, char* res,
233  const char* op1, const char* op2,
234  unsigned int resOff = 0,
235  unsigned int op1Off = 0,
236  unsigned int op2Off = 0 );
238 
239 private:
241  static int isApplicableOnStruct( Ops::OpType op, const BaseType* opType );
242  /*@ManMemo: checks, if #op# is applicable on struct of type op1Type
243  and value of type op2Type.*/
244  static int isApplicableOnStructConst( Ops::OpType op,
245  const BaseType* op1Type,
246  const BaseType* op2Type );
248  static int isSignedType( const BaseType* type );
249  // these functions aren't even used for the time being, but may
250  // be important for better implementations of isApplicable and
251  // getResultType.
252  static int isCondenseOp( Ops::OpType op );
253  static int isUnaryOp( Ops::OpType op );
254  static int isBinaryOp( Ops::OpType op );
255 };
256 
257 //@ManMemo: Module: {\bf catalogif}.
258 
259 /*@Doc:
260  CondenseOp is the superclass for all condense operations. The
261  operator() carries out a condense operation on one cell {\tt op},
262  which is accumulated into {\tt accu}. {\tt accu} is returned as a
263  result. Remember to always initialize {\tt accu} correctly according
264  to the condense operation used (e.g. 0 for \Ref{OpSOMEBool} or 1 for
265  \Ref{OpALLBool}).
266 */
271 {
272 public:
273  /*@ManMemo: constructor gets RasDaMan base type of result and operand
274  and offsets to result and operand (for structs). */
275  CondenseOp( const BaseType* newResType, const BaseType* newOpType,
276  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
277  /*@ManMemo: constructor gets RasDaMan base type of result and operand,
278  initial value, and offsets to result and operand (for structs) . */
279  CondenseOp( const BaseType* newResType, char* newAccu, const BaseType* newOpType,
280  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
282  virtual char* operator()( const char* op, char* myAccu ) = 0;
284  virtual char* operator()( const char* op ) = 0;
286  virtual char* getAccuVal();
287  /*@ManMemo: virtual destructor because subclasse OpCondenseStruct has
288  non-trivial destructor. */
289  virtual ~CondenseOp();
290 
291 protected:
292  char* accu;
293  const BaseType* opType;
295  unsigned int resOff;
296  unsigned int opOff;
297 };
298 
299 //@ManMemo: Module: {\bf catalogif}.
300 //@Doc: OP_SOME on C type #char#.
304 class OpSOMECChar : public CondenseOp
305 {
306 public:
307  /*@ManMemo: constructor gets RasDaMan base type of result and operand
308  and offsets to result and operand (for structs). */
309  OpSOMECChar( const BaseType* newResType, const BaseType* newOpType,
310  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
312  OpSOMECChar( const BaseType* newResType, char* newAccu,
313  const BaseType* newOpType, unsigned int newResOff,
314  unsigned int newOpOff );
316  virtual char* operator()( const char* op, char* myAccu );
318  virtual char* operator()( const char* op );
319 };
320 
321 //@ManMemo: Module: {\bf catalogif}.
322 //@Doc: OP_ALL on C type #char#.
326 class OpALLCChar : public CondenseOp
327 {
328 public:
329  /*@ManMemo: constructor gets RasDaMan base type of result and operand
330  and offsets to result and operand (for structs). */
331  OpALLCChar( const BaseType* newResType, const BaseType* newOpType,
332  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
334  OpALLCChar( const BaseType* newResType, char* newAccu,
335  const BaseType* newOpType, unsigned int newResOff,
336  unsigned int newOpOff );
338  virtual char* operator()( const char* op, char* myAccu );
340  virtual char* operator()( const char* op );
341 };
342 
343 //@ManMemo: Module: {\bf catalogif}.
344 //@Doc: OP_COUNT on C type #char#.
348 class OpCOUNTCChar : public CondenseOp
349 {
350 public:
351  /*@ManMemo: constructor gets RasDaMan base type of result and operand
352  and offsets to result and operand (for structs). */
353  OpCOUNTCChar( const BaseType* newResType, const BaseType* newOpType,
354  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
356  OpCOUNTCChar( const BaseType* newResType, char* newAccu,
357  const BaseType* newOpType, unsigned int newResOff,
358  unsigned int newOpOff );
360  virtual char* operator()( const char* op, char* myAccu );
362  virtual char* operator()( const char* op );
363 };
364 
365 //@ManMemo: Module: {\bf catalogif}.
366 //@Doc: OP_MAX on C type #char#.
370 class OpMAXCULong : public CondenseOp
371 {
372 public:
373  /*@ManMemo: constructor gets RasDaMan base type of result and operand
374  and offsets to result and operand (for structs). */
375  OpMAXCULong( const BaseType* newResType, const BaseType* newOpType,
376  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
378  OpMAXCULong( const BaseType* newResType, char* newAccu,
379  const BaseType* newOpType, unsigned int newResOff,
380  unsigned int newOpOff );
382  virtual char* operator()( const char* op, char* myAccu );
384  virtual char* operator()( const char* op );
385 };
386 
387 //@ManMemo: Module: {\bf catalogif}.
388 //@Doc: OP_MAX on C type #char#.
392 class OpMAXCLong : public CondenseOp
393 {
394 public:
395  /*@ManMemo: constructor gets RasDaMan base type of result and operand
396  and offsets to result and operand (for structs). */
397  OpMAXCLong( const BaseType* newResType, const BaseType* newOpType,
398  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
400  OpMAXCLong( const BaseType* newResType, char* newAccu,
401  const BaseType* newOpType, unsigned int newResOff,
402  unsigned int newOpOff );
404  virtual char* operator()( const char* op, char* myAccu );
406  virtual char* operator()( const char* op );
407 };
408 
409 //@ManMemo: Module: {\bf catalogif}.
410 //@Doc: OP_MAX on C type #char#.
414 class OpMAXCDouble : public CondenseOp
415 {
416 public:
417  /*@ManMemo: constructor gets RasDaMan base type of result and operand
418  and offsets to result and operand (for structs). */
419  OpMAXCDouble( const BaseType* newResType, const BaseType* newOpType,
420  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
422  OpMAXCDouble( const BaseType* newResType, char* newAccu,
423  const BaseType* newOpType, unsigned int newResOff,
424  unsigned int newOpOff );
426  virtual char* operator()( const char* op, char* myAccu );
428  virtual char* operator()( const char* op );
429 };
430 
431 //@ManMemo: Module: {\bf catalogif}.
432 //@Doc: OP_MIN on C type #char#.
436 class OpMINCULong : public CondenseOp
437 {
438 public:
439  /*@ManMemo: constructor gets RasDaMan base type of result and operand
440  and offsets to result and operand (for structs). */
441  OpMINCULong( const BaseType* newResType, const BaseType* newOpType,
442  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
444  OpMINCULong( const BaseType* newResType, char* newAccu,
445  const BaseType* newOpType, unsigned int newResOff,
446  unsigned int newOpOff );
448  virtual char* operator()( const char* op, char* myAccu );
450  virtual char* operator()( const char* op );
451 };
452 
453 //@ManMemo: Module: {\bf catalogif}.
454 //@Doc: OP_MIN on C type #char#.
458 class OpMINCLong : public CondenseOp
459 {
460 public:
461  /*@ManMemo: constructor gets RasDaMan base type of result and operand
462  and offsets to result and operand (for structs). */
463  OpMINCLong( const BaseType* newResType, const BaseType* newOpType,
464  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
466  OpMINCLong( const BaseType* newResType, char* newAccu,
467  const BaseType* newOpType, unsigned int newResOff,
468  unsigned int newOpOff );
470  virtual char* operator()( const char* op, char* myAccu );
472  virtual char* operator()( const char* op );
473 };
474 
475 //@ManMemo: Module: {\bf catalogif}.
476 //@Doc: OP_MIN on C type #char#.
480 class OpMINCDouble : public CondenseOp
481 {
482 public:
483  /*@ManMemo: constructor gets RasDaMan base type of result and operand
484  and offsets to result and operand (for structs). */
485  OpMINCDouble( const BaseType* newResType, const BaseType* newOpType,
486  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
488  OpMINCDouble( const BaseType* newResType, char* newAccu,
489  const BaseType* newOpType, unsigned int newResOff,
490  unsigned int newOpOff );
492  virtual char* operator()( const char* op, char* myAccu );
494  virtual char* operator()( const char* op );
495 };
496 
497 //@ManMemo: Module: {\bf catalogif}.
498 //@Doc: OP_SUM on C type #char#.
502 class OpSUMCULong : public CondenseOp
503 {
504 public:
505  /*@ManMemo: constructor gets RasDaMan base type of result and operand
506  and offsets to result and operand (for structs). */
507  OpSUMCULong(const BaseType* newResType,const BaseType* newOpType,
508  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
510  OpSUMCULong(const BaseType* newResType, char* newAccu,
511  const BaseType* newOpType, unsigned int newResOff,
512  unsigned int newOpOff );
514  virtual char* operator()( const char* op, char* myAccu );
516  virtual char* operator()( const char* op );
517 };
518 
519 //@ManMemo: Module: {\bf catalogif}.
520 //@Doc: OP_SUM on C type #char#.
524 class OpSUMCLong : public CondenseOp
525 {
526 public:
527  /*@ManMemo: constructor gets RasDaMan base type of result and operand
528  and offsets to result and operand (for structs). */
529  OpSUMCLong(const BaseType* newResType,const BaseType* newOpType,
530  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
532  OpSUMCLong(const BaseType* newResType, char* newAccu,
533  const BaseType* newOpType, unsigned int newResOff,
534  unsigned int newOpOff );
536  virtual char* operator()( const char* op, char* myAccu );
538  virtual char* operator()( const char* op );
539 };
540 
541 //@ManMemo: Module: {\bf catalogif}.
542 //@Doc: OP_SUM on C type #char#.
546 class OpSUMCDouble : public CondenseOp
547 {
548 public:
549  /*@ManMemo: constructor gets RasDaMan base type of result and operand
550  and offsets to result and operand (for structs). */
551  OpSUMCDouble(const BaseType* newResType,const BaseType* newOpType,
552  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
554  OpSUMCDouble(const BaseType* newResType, char* newAccu,
555  const BaseType* newOpType, unsigned int newResOff,
556  unsigned int newOpOff );
558  virtual char* operator()( const char* op, char* myAccu );
560  virtual char* operator()( const char* op );
561 };
562 
563 //@ManMemo: Module: {\bf catalogif}.
564 //@Doc: Class for carrying out condense operations on structs.
565 
566 // Inherits some useless members from CondenseOp, don't want to
567 // change this now.
572 {
573 public:
576  const BaseType* newResType,
577  const BaseType* newOpType,
578  Ops::OpType op,
579  unsigned int newResOff = 0, unsigned int newOpOff = 0
580  );
583  const BaseType* newResType,
584  char* newAccu,
585  const BaseType* newOpType,
586  Ops::OpType op,
587  unsigned int newResOff,
588  unsigned int newOpOff
589  );
591  virtual ~OpCondenseStruct();
593  virtual char* operator()( const char* op, char* myAccu );
595  virtual char* operator()( const char* op );
596 protected:
599  unsigned int numElems;
600  // array of operations on the elements.
602 };
603 
604 //@ManMemo: Module: {\bf catalogif}.
605 
606 /*@Doc:
607  UnaryOp is the superclass for all unary operations. The
608  operator() carries out a unary operation on one cell {\tt op} and
609  stores the result in the cell {\tt result}.
610 */
614 class UnaryOp
615 {
616 public:
617  /*@ManMemo: constructor gets RasDaMan base type of result and operand
618  and offsets to result and operand (for structs). */
619  UnaryOp(const BaseType* newResType,const BaseType* newOpType,
620  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
622  virtual void operator()( char* result, const char* op ) = 0;
623  /*@ManMemo: virtual destructor because subclasse OpUnaryStruct has
624  non-trivial destructor. */
625  virtual ~UnaryOp() { };
626 
627 protected:
628  const BaseType* opType;
630  unsigned int resOff;
631  unsigned int opOff;
632 };
633 
634 //@ManMemo: Module: {\bf catalogif}.
635 //@Doc: Class for carrying out binary operations on structs.
636 
637 // Inherits some useless members from UnaryOp, don't want to
638 // change this now.
642 class OpUnaryStruct : public UnaryOp
643 {
644 public:
647  const BaseType* newResType,
648  const BaseType* newOpType,
649  Ops::OpType op,
650  unsigned int newResOff = 0,
651  unsigned int newOpOff = 0
652  );
654  virtual ~OpUnaryStruct();
656  virtual void operator()( char* result, const char* op );
657 
658 protected:
661  unsigned int numElems;
662  // array of operations on the elements.
664 };
665 
666 //@ManMemo: Module: {\bf catalogif}.
667 //@Doc: OP_IDENTITY on structs. Works, if struct types are identical.
671 class OpIDENTITYStruct : public UnaryOp
672 {
673 public:
675  OpIDENTITYStruct(const BaseType* newResType,const BaseType* newOpType,
676  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
678  virtual void operator()( char* result, const char* op );
679 };
680 
681 //@ManMemo: Module: {\bf catalogif}.
682 //@Doc: OP_NOT on C type #unsigned long#, result #unsigned long#.
686 class OpNOTCULong : public UnaryOp
687 {
688 public:
690  OpNOTCULong(const BaseType* newResType,const BaseType* newOpType,
691  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
693  virtual void operator()( char* result, const char* op );
694 };
695 
696 //@ManMemo: Module: {\bf catalogif}.
697 //@Doc: OP_IDENTITY on C type #unsigned long#, result #unsigned long#.
701 class OpIDENTITYCULong : public UnaryOp
702 {
703 public:
705  OpIDENTITYCULong(const BaseType* newResType,const BaseType* newOpType,
706  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
708  virtual void operator()( char* result, const char* op );
709 };
710 
711 //@ManMemo: Module: {\bf catalogif}.
712 //@Doc: OP_NOT on C type #unsigned long#, result #unsigned long#.
716 class OpNOTCLong : public UnaryOp
717 {
718 public:
720  OpNOTCLong(const BaseType* newResType,const BaseType* newOpType,
721  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
723  virtual void operator()( char* result, const char* op );
724 };
725 
726 //@ManMemo: Module: {\bf catalogif}.
727 //@Doc: OP_NOT on Bools (logical NOT as opposed to bitwise NOT).
731 class OpNOTBool : public UnaryOp
732 {
733 public:
735  OpNOTBool(const BaseType* newResType,const BaseType* newOpType,
736  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
738  virtual void operator()( char* result, const char* op );
739 };
740 
741 //@ManMemo: Module: {\bf catalogif}.
742 //@Doc: OP_IDENTITY on C type #unsigned long#, result #unsigned long#.
746 class OpIDENTITYCLong : public UnaryOp
747 {
748 public:
750  OpIDENTITYCLong(const BaseType* newResType,const BaseType* newOpType,
751  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
753  virtual void operator()( char* result, const char* op );
754 };
755 
756 //@ManMemo: Module: {\bf catalogif}.
757 //@Doc: OP_IDENTITY on C type #unsigned long#, result #unsigned long#.
762 {
763 public:
765  OpIDENTITYCDouble(const BaseType* newResType,const BaseType* newOpType,
766  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
768  virtual void operator()( char* result, const char* op );
769 };
770 
771 //@ManMemo: Module: {\bf catalogif}.
772 /*@Doc:
773  BinaryOp is the superclass for all binary operations. The operator()
774  carries out a binary operation on cells {\tt op1} and {\tt op2}. The
775  result is stored in the cell {\tt res}.
776 */
780 class BinaryOp
781 {
782 public:
783  /*@ManMemo: constructor gets RasDaMan base type of result and operands
784  and offsets to result and operands (for structs). */
785  BinaryOp(const BaseType* newResType,const BaseType* newOp1Type,
786  const BaseType* newOp2Type, unsigned int newResOff = 0,
787  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
788  /*@ManMemo: operator to carry out operation on {\tt op1} and
789  {\tt op2} with result {\tt res}. */
790  virtual void operator()( char* res, const char* op1,
791  const char* op2 ) = 0;
793  virtual void getCondenseInit(char* init);
794  /*@ManMemo: virtual destructor because subclasse OpBinaryStruct has
795  non-trivial destructor. */
796  virtual ~BinaryOp() { };
797 
798 protected:
799  const BaseType* op1Type;
802  unsigned int resOff;
803  unsigned int op1Off;
804  unsigned int op2Off;
805 };
806 
807 //@ManMemo: Module: {\bf catalogif}.
808 //@Doc: Class for carrying out binary operations on structs.
809 
810 // Inherits some useless members from BinaryOp, don't want to
811 // change this now.
815 class OpBinaryStruct : public BinaryOp
816 {
817 public:
819  OpBinaryStruct(const BaseType* newStructType, Ops::OpType op,
820  unsigned int newResOff = 0, unsigned int newOp1Off = 0,
821  unsigned int newOp2Off = 0 );
823  virtual ~OpBinaryStruct();
825  virtual void operator()( char* res, const char* op1,
826  const char* op2 );
827 protected:
829  unsigned int numElems;
830  // array of operations on the elements.
832 };
833 
834 //@ManMemo: Module: {\bf catalogif}.
835 /*@Doc: Class for carrying out binary operations on structs where the
836  second operand is a value. */
841 {
842 public:
845  const BaseType* resType,
846  const BaseType* op1Type,
847  const BaseType* op2Type,
848  Ops::OpType op, unsigned int newResOff = 0,
849  unsigned int newOp1Off = 0,
850  unsigned int newOp2Off = 0 );
852  virtual ~OpBinaryStructConst();
854  virtual void operator()( char* res, const char* op1,
855  const char* op2 );
856 protected:
859  unsigned int numElems;
860  // array of operations on the elements.
862 };
863 
864 //@ManMemo: Module: {\bf catalogif}.
865 /*@Doc: Class for carrying out binary operations on structs where the
866  first operand is a value. */
871 {
872 public:
875  const BaseType* resType,
876  const BaseType* op1Type,
877  const BaseType* op2Type,
878  Ops::OpType op, unsigned int newResOff = 0,
879  unsigned int newOp1Off = 0,
880  unsigned int newOp2Off = 0 );
882  virtual ~OpBinaryConstStruct();
884  virtual void operator()( char* res, const char* op1,
885  const char* op2 );
886 protected:
889  unsigned int numElems;
890  // array of operations on the elements.
892 };
896 class OpEQUALStruct : public BinaryOp
897 {
898 public:
900  OpEQUALStruct(const BaseType* newResType,const BaseType* newOp1Type,
901  const BaseType* newOp2Type, unsigned int newResOff = 0,
902  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
904  virtual ~OpEQUALStruct();
905  /*@ManMemo: operator to carry out operation on {\tt op1} and
906  {\tt op2} with result {\tt res}. */
907  virtual void operator()( char* res, const char* op1,
908  const char* op2 );
909 protected:
910  unsigned int numElems;
911  // array of operations on the elements.
913 };
918 {
919 public:
921  OpNOTEQUALStruct(const BaseType* newResType,const BaseType* newOp1Type,
922  const BaseType* newOp2Type, unsigned int newResOff = 0,
923  unsigned int newOp1Off = 0,
924  unsigned int newOp2Off = 0 );
926  virtual ~OpNOTEQUALStruct();
927  /*@ManMemo: operator to carry out operation on {\tt op1} and
928  {\tt op2} with result {\tt res}. */
929  virtual void operator()( char* res, const char* op1,
930  const char* op2 );
931 protected:
932  unsigned int numElems;
933  // array of operations on the elements.
935 };
936 
937 //@ManMemo: Module: {\bf catalogif}.
938 //@Doc: OP_PLUS on C type #unsigned long# and #unsigned long#, result #unsigned long#.
942 class OpPLUSCULong : public BinaryOp
943 {
944 public:
946  OpPLUSCULong(const BaseType* newResType,const BaseType* newOp1Type,
947  const BaseType* newOp2Type, unsigned int newResOff = 0,
948  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
949  /*@ManMemo: operator to carry out operation on {\tt op1} and
950  {\tt op2} with result {\tt res}. */
951  virtual void operator()( char* res, const char* op1,
952  const char* op2 );
953  virtual void getCondenseInit(char* init);
954 };
958 class OpPLUSULong : public BinaryOp
959 {
960 public:
962  OpPLUSULong(const BaseType* newResType,const BaseType* newOp1Type,
963  const BaseType* newOp2Type, unsigned int newResOff = 0,
964  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
965  /*@ManMemo: operator to carry out operation on {\tt op1} and
966  {\tt op2} with result {\tt res}. */
967  virtual void operator()( char* res, const char* op1,
968  const char* op2 );
969  virtual void getCondenseInit(char* init);
970 };
971 
972 //@ManMemo: Module: {\bf catalogif}.
973 //@Doc: OP_MINUS on C type #unsigned long# and #unsigned long#, result #unsigned long#.
977 class OpMINUSCULong : public BinaryOp
978 {
979 public:
981  OpMINUSCULong(const BaseType* newResType,const BaseType* newOp1Type,
982  const BaseType* newOp2Type, unsigned int newResOff = 0,
983  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
984  /*@ManMemo: operator to carry out operation on {\tt op1} and
985  {\tt op2} with result {\tt res}. */
986  virtual void operator()( char* res, const char* op1,
987  const char* op2 );
988 };
989 
990 //@ManMemo: Module: {\bf catalogif}.
991 //@Doc: OP_DIV on C type #unsigned long# and #unsigned long#, result #unsigned long#.
995 class OpDIVCULong : public BinaryOp
996 {
997 public:
999  OpDIVCULong(const BaseType* newResType,const BaseType* newOp1Type,
1000  const BaseType* newOp2Type, unsigned int newResOff = 0,
1001  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1002  /*@ManMemo: operator to carry out operation on {\tt op1} and
1003  {\tt op2} with result {\tt res}. */
1004  virtual void operator()( char* res, const char* op1,
1005  const char* op2 );
1006 };
1007 
1008 //@ManMemo: Module: {\bf catalogif}.
1009 //@Doc: OP_MULT on C type #unsigned long# and #unsigned long#, result #unsigned long#.
1013 class OpMULTCULong : public BinaryOp
1014 {
1015 public:
1017  OpMULTCULong(const BaseType* newResType,const BaseType* newOp1Type,
1018  const BaseType* newOp2Type, unsigned int newResOff = 0,
1019  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1020  /*@ManMemo: operator to carry out operation on {\tt op1} and
1021  {\tt op2} with result {\tt res}. */
1022  virtual void operator()( char* res, const char* op1,
1023  const char* op2 );
1024  virtual void getCondenseInit(char* init);
1025 };
1026 
1027 //@ManMemo: Module: {\bf catalogif}.
1028 //@Doc: OP_AND on C type #unsigned long# and #unsigned long#, result #unsigned long#.
1032 class OpANDCULong : public BinaryOp
1033 {
1034 public:
1036  OpANDCULong(const BaseType* newResType,const BaseType* newOp1Type,
1037  const BaseType* newOp2Type, unsigned int newResOff = 0,
1038  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1039  /*@ManMemo: operator to carry out operation on {\tt op1} and
1040  {\tt op2} with result {\tt res}. */
1041  virtual void operator()( char* res, const char* op1,
1042  const char* op2 );
1043  virtual void getCondenseInit(char* init);
1044 };
1045 
1046 //@ManMemo: Module: {\bf catalogif}.
1047 //@Doc: OP_AND on Bools (logical as opposed to bitwise)
1051 class OpANDBool : public BinaryOp
1052 {
1053 public:
1055  OpANDBool(const BaseType* newResType,const BaseType* newOp1Type,
1056  const BaseType* newOp2Type, unsigned int newResOff = 0,
1057  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1058  /*@ManMemo: operator to carry out operation on {\tt op1} and
1059  {\tt op2} with result {\tt res}. */
1060  virtual void operator()( char* res, const char* op1,
1061  const char* op2 );
1062  virtual void getCondenseInit(char* init);
1063 };
1064 
1065 //@ManMemo: Module: {\bf catalogif}.
1066 //@Doc: OP_OR on C type #unsigned long# and #unsigned long#, result #unsigned long#.
1070 class OpORCULong : public BinaryOp
1071 {
1072 public:
1074  OpORCULong(const BaseType* newResType,const BaseType* newOp1Type,
1075  const BaseType* newOp2Type, unsigned int newResOff = 0,
1076  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1077  /*@ManMemo: operator to carry out operation on {\tt op1} and
1078  {\tt op2} with result {\tt res}. */
1079  virtual void operator()( char* res, const char* op1,
1080  const char* op2 );
1081  virtual void getCondenseInit(char* init);
1082 };
1083 
1084 //@ManMemo: Module: {\bf catalogif}.
1085 //@Doc: OP_OR on Bools (logical as opposed to bitwise)
1089 class OpORBool : public BinaryOp
1090 {
1091 public:
1093  OpORBool(const BaseType* newResType,const BaseType* newOp1Type,
1094  const BaseType* newOp2Type, unsigned int newResOff = 0,
1095  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1096  /*@ManMemo: operator to carry out operation on {\tt op1} and
1097  {\tt op2} with result {\tt res}. */
1098  virtual void operator()( char* res, const char* op1,
1099  const char* op2 );
1100  virtual void getCondenseInit(char* init);
1101 };
1102 
1103 //@ManMemo: Module: {\bf catalogif}.
1104 //@Doc: OP_XOR on C type #unsigned long# and #unsigned long#, result #unsigned long#.
1108 class OpXORCULong : public BinaryOp
1109 {
1110 public:
1112  OpXORCULong(const BaseType* newResType,const BaseType* newOp1Type,
1113  const BaseType* newOp2Type, unsigned int newResOff = 0,
1114  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1115  /*@ManMemo: operator to carry out operation on {\tt op1} and
1116  {\tt op2} with result {\tt res}. */
1117  virtual void operator()( char* res, const char* op1,
1118  const char* op2 );
1119 };
1120 
1121 //@ManMemo: Module: {\bf catalogif}.
1122 //@Doc: OP_XOR on Bools (logical as opposed to bitwise)
1126 class OpXORBool : public BinaryOp
1127 {
1128 public:
1130  OpXORBool(const BaseType* newResType,const BaseType* newOp1Type,
1131  const BaseType* newOp2Type, unsigned int newResOff = 0,
1132  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1133  /*@ManMemo: operator to carry out operation on {\tt op1} and
1134  {\tt op2} with result {\tt res}. */
1135  virtual void operator()( char* res, const char* op1,
1136  const char* op2 );
1137 };
1138 
1139 //@ManMemo: Module: {\bf catalogif}.
1140 //@Doc: OP_PLUS on C type #long# and #long#, result #long#.
1144 class OpPLUSCLong : public BinaryOp
1145 {
1146 public:
1148  OpPLUSCLong(const BaseType* newResType,const BaseType* newOp1Type,
1149  const BaseType* newOp2Type, unsigned int newResOff = 0,
1150  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1151  /*@ManMemo: operator to carry out operation on {\tt op1} and
1152  {\tt op2} with result {\tt res}. */
1153  virtual void operator()( char* res, const char* op1,
1154  const char* op2 );
1155  virtual void getCondenseInit(char* init);
1156 };
1157 
1158 //@ManMemo: Module: {\bf catalogif}.
1159 //@Doc: OP_MINUS on C type #long# and #long#, result #long#.
1163 class OpMINUSCLong : public BinaryOp
1164 {
1165 public:
1167  OpMINUSCLong(const BaseType* newResType,const BaseType* newOp1Type,
1168  const BaseType* newOp2Type, unsigned int newResOff = 0,
1169  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1170  /*@ManMemo: operator to carry out operation on {\tt op1} and
1171  {\tt op2} with result {\tt res}. */
1172  virtual void operator()( char* res, const char* op1,
1173  const char* op2 );
1174 };
1175 
1176 //@ManMemo: Module: {\bf catalogif}.
1177 //@Doc: OP_DIV on C type #long# and #long#, result #long#.
1181 class OpDIVCLong : public BinaryOp
1182 {
1183 public:
1185  OpDIVCLong(const BaseType* newResType,const BaseType* newOp1Type,
1186  const BaseType* newOp2Type, unsigned int newResOff = 0,
1187  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1188  /*@ManMemo: operator to carry out operation on {\tt op1} and
1189  {\tt op2} with result {\tt res}. */
1190  virtual void operator()( char* res, const char* op1,
1191  const char* op2 );
1192 };
1193 
1194 //@ManMemo: Module: {\bf catalogif}.
1195 //@Doc: OP_MULT on C type #long# and #long#, result #long#.
1199 class OpMULTCLong : public BinaryOp
1200 {
1201 public:
1203  OpMULTCLong(const BaseType* newResType,const BaseType* newOp1Type,
1204  const BaseType* newOp2Type, unsigned int newResOff = 0,
1205  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1206  /*@ManMemo: operator to carry out operation on {\tt op1} and
1207  {\tt op2} with result {\tt res}. */
1208  virtual void operator()( char* res, const char* op1,
1209  const char* op2 );
1210  virtual void getCondenseInit(char* init);
1211 };
1212 
1213 //@ManMemo: Module: {\bf catalogif}.
1214 //@Doc: OP_AND on C type #long# and #long#, result #long#.
1218 class OpANDCLong : public BinaryOp
1219 {
1220 public:
1222  OpANDCLong(const BaseType* newResType,const BaseType* newOp1Type,
1223  const BaseType* newOp2Type, unsigned int newResOff = 0,
1224  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1225  /*@ManMemo: operator to carry out operation on {\tt op1} and
1226  {\tt op2} with result {\tt res}. */
1227  virtual void operator()( char* res, const char* op1,
1228  const char* op2 );
1229  virtual void getCondenseInit(char* init);
1230 };
1231 
1232 //@ManMemo: Module: {\bf catalogif}.
1233 //@Doc: OP_OR on C type #long# and #long#, result #long#.
1237 class OpORCLong : public BinaryOp
1238 {
1239 public:
1241  OpORCLong(const BaseType* newResType,const BaseType* newOp1Type,
1242  const BaseType* newOp2Type, unsigned int newResOff = 0,
1243  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1244  /*@ManMemo: operator to carry out operation on {\tt op1} and
1245  {\tt op2} with result {\tt res}. */
1246  virtual void operator()( char* res, const char* op1,
1247  const char* op2 );
1248  virtual void getCondenseInit(char* init);
1249 };
1250 
1251 //@ManMemo: Module: {\bf catalogif}.
1252 //@Doc: OP_XOR on C type #long# and #long#, result #long#.
1256 class OpXORCLong : public BinaryOp
1257 {
1258 public:
1260  OpXORCLong(const BaseType* newResType,const BaseType* newOp1Type,
1261  const BaseType* newOp2Type, unsigned int newResOff = 0,
1262  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1263  /*@ManMemo: operator to carry out operation on {\tt op1} and
1264  {\tt op2} with result {\tt res}. */
1265  virtual void operator()( char* res, const char* op1,
1266  const char* op2 );
1267 };
1268 
1269 //@ManMemo: Module: {\bf catalogif}.
1270 //@Doc: OP_PLUS on C type #double# and #double#, result #double#.
1274 class OpPLUSCDouble : public BinaryOp
1275 {
1276 public:
1278  OpPLUSCDouble(const BaseType* newResType,const BaseType* newOp1Type,
1279  const BaseType* newOp2Type, unsigned int newResOff = 0,
1280  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1281  /*@ManMemo: operator to carry out operation on {\tt op1} and
1282  {\tt op2} with result {\tt res}. */
1283  virtual void operator()( char* res, const char* op1,
1284  const char* op2 );
1285  virtual void getCondenseInit(char* init);
1286 };
1287 
1288 //@ManMemo: Module: {\bf catalogif}.
1289 //@Doc: OP_MINUS on C type #double# and #double#, result #double#.
1293 class OpMINUSCDouble : public BinaryOp
1294 {
1295 public:
1297  OpMINUSCDouble(const BaseType* newResType,const BaseType* newOp1Type,
1298  const BaseType* newOp2Type, unsigned int newResOff = 0,
1299  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1300  /*@ManMemo: operator to carry out operation on {\tt op1} and
1301  {\tt op2} with result {\tt res}. */
1302  virtual void operator()( char* res, const char* op1,
1303  const char* op2 );
1304 };
1305 
1306 //@ManMemo: Module: {\bf catalogif}.
1307 //@Doc: OP_DIV on C type #double# and #double#, result #double#.
1311 class OpDIVCDouble : public BinaryOp
1312 {
1313 public:
1315  OpDIVCDouble(const BaseType* newResType,const BaseType* newOp1Type,
1316  const BaseType* newOp2Type, unsigned int newResOff = 0,
1317  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1318  /*@ManMemo: operator to carry out operation on {\tt op1} and
1319  {\tt op2} with result {\tt res}. */
1320  virtual void operator()( char* res, const char* op1,
1321  const char* op2 );
1322 };
1323 
1324 //@ManMemo: Module: {\bf catalogif}.
1325 //@Doc: OP_MULT on C type #double# and #double#, result #double#.
1329 class OpMULTCDouble : public BinaryOp
1330 {
1331 public:
1333  OpMULTCDouble(const BaseType* newResType,const BaseType* newOp1Type,
1334  const BaseType* newOp2Type, unsigned int newResOff = 0,
1335  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1336  /*@ManMemo: operator to carry out operation on {\tt op1} and
1337  {\tt op2} with result {\tt res}. */
1338  virtual void operator()( char* res, const char* op1,
1339  const char* op2 );
1340  virtual void getCondenseInit(char* init);
1341 };
1342 
1343 //@ManMemo: Module: {\bf catalogif}.
1344 //@Doc: OP_EQUAL on C type #unsigned long# and #unsigned long#, result #char#.
1349 {
1350 public:
1352  OpEQUALCCharCULong(const BaseType* newResType,const BaseType* newOp1Type,
1353  const BaseType* newOp2Type, unsigned int newResOff = 0,
1354  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1355  /*@ManMemo: operator to carry out operation on {\tt op1} and
1356  {\tt op2} with result {\tt res}. */
1357  virtual void operator()( char* res, const char* op1,
1358  const char* op2 );
1359 };
1360 
1361 //@ManMemo: Module: {\bf catalogif}.
1362 //@Doc: OP_LESS on C type #unsigned long# and #unsigned long#, result #char#.
1367 {
1368 public:
1370  OpLESSCCharCULong(const BaseType* newResType,const BaseType* newOp1Type,
1371  const BaseType* newOp2Type, unsigned int newResOff = 0,
1372  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1373  /*@ManMemo: operator to carry out operation on {\tt op1} and
1374  {\tt op2} with result {\tt res}. */
1375  virtual void operator()( char* res, const char* op1,
1376  const char* op2 );
1377 };
1378 
1379 //@ManMemo: Module: {\bf catalogif}.
1380 //@Doc: OP_LESSEQUAL on C type #unsigned long# and #unsigned long#, result #char#.
1385 {
1386 public:
1388  OpLESSEQUALCCharCULong(const BaseType* newResType,const BaseType* newOp1Type,
1389  const BaseType* newOp2Type, unsigned int newResOff = 0,
1390  unsigned int newOp1Off = 0,
1391  unsigned int newOp2Off = 0 );
1392  /*@ManMemo: operator to carry out operation on {\tt op1} and
1393  {\tt op2} with result {\tt res}. */
1394  virtual void operator()( char* res, const char* op1,
1395  const char* op2 );
1396 };
1397 
1398 //@ManMemo: Module: {\bf catalogif}.
1399 //@Doc: OP_NOTEQUAL on C type #unsigned long# and #unsigned long#, result #char#.
1404 {
1405 public:
1407  OpNOTEQUALCCharCULong(const BaseType* newResType,const BaseType* newOp1Type,
1408  const BaseType* newOp2Type, unsigned int newResOff = 0,
1409  unsigned int newOp1Off = 0,
1410  unsigned int newOp2Off = 0 );
1411  /*@ManMemo: operator to carry out operation on {\tt op1} and
1412  {\tt op2} with result {\tt res}. */
1413  virtual void operator()( char* res, const char* op1,
1414  const char* op2 );
1415 };
1416 
1417 //@ManMemo: Module: {\bf catalogif}.
1418 //@Doc: OP_GREATER on C type #unsigned long# and #unsigned long#, result #char#.
1423 {
1424 public:
1426  OpGREATERCCharCULong(const BaseType* newResType,const BaseType* newOp1Type,
1427  const BaseType* newOp2Type, unsigned int newResOff = 0,
1428  unsigned int newOp1Off = 0,
1429  unsigned int newOp2Off = 0 );
1430  /*@ManMemo: operator to carry out operation on {\tt op1} and
1431  {\tt op2} with result {\tt res}. */
1432  virtual void operator()( char* res, const char* op1,
1433  const char* op2 );
1434 };
1435 
1436 //@ManMemo: Module: {\bf catalogif}.
1437 //@Doc: OP_GREATEREQUAL on \Ref{ULong} and \Ref{ULong}, result \Ref{Bool}.
1442 {
1443 public:
1445  OpGREATEREQUALCCharCULong(const BaseType* newResType,const BaseType* newOp1Type,
1446  const BaseType* newOp2Type, unsigned int newResOff = 0,
1447  unsigned int newOp1Off = 0,
1448  unsigned int newOp2Off = 0 );
1449  /*@ManMemo: operator to carry out operation on {\tt op1} and
1450  {\tt op2} with result {\tt res}. */
1451  virtual void operator()( char* res, const char* op1,
1452  const char* op2 );
1453 };
1454 
1455 //@ManMemo: Module: {\bf catalogif}.
1456 //@Doc: OP_EQUAL on C type #unsigned long# and #unsigned long#, result #char#.
1461 {
1462 public:
1464  OpEQUALCCharCLong(const BaseType* newResType,const BaseType* newOp1Type,
1465  const BaseType* newOp2Type, unsigned int newResOff = 0,
1466  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1467  /*@ManMemo: operator to carry out operation on {\tt op1} and
1468  {\tt op2} with result {\tt res}. */
1469  virtual void operator()( char* res, const char* op1,
1470  const char* op2 );
1471 };
1472 
1473 //@ManMemo: Module: {\bf catalogif}.
1474 //@Doc: OP_LESS on C type #long# and #long#, result #char#.
1479 {
1480 public:
1482  OpLESSCCharCLong(const BaseType* newResType,const BaseType* newOp1Type,
1483  const BaseType* newOp2Type, unsigned int newResOff = 0,
1484  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1485  /*@ManMemo: operator to carry out operation on {\tt op1} and
1486  {\tt op2} with result {\tt res}. */
1487  virtual void operator()( char* res, const char* op1,
1488  const char* op2 );
1489 };
1490 
1491 //@ManMemo: Module: {\bf catalogif}.
1492 //@Doc: OP_LESSEQUAL on C type #long# and #long#, result #char#.
1497 {
1498 public:
1500  OpLESSEQUALCCharCLong(const BaseType* newResType,const BaseType* newOp1Type,
1501  const BaseType* newOp2Type, unsigned int newResOff = 0,
1502  unsigned int newOp1Off = 0,
1503  unsigned int newOp2Off = 0 );
1504  /*@ManMemo: operator to carry out operation on {\tt op1} and
1505  {\tt op2} with result {\tt res}. */
1506  virtual void operator()( char* res, const char* op1,
1507  const char* op2 );
1508 };
1509 
1510 //@ManMemo: Module: {\bf catalogif}.
1511 //@Doc: OP_NOTEQUAL on C type #long# and #long#, result #char#.
1516 {
1517 public:
1519  OpNOTEQUALCCharCLong(const BaseType* newResType,const BaseType* newOp1Type,
1520  const BaseType* newOp2Type, unsigned int newResOff = 0,
1521  unsigned int newOp1Off = 0,
1522  unsigned int newOp2Off = 0 );
1523  /*@ManMemo: operator to carry out operation on {\tt op1} and
1524  {\tt op2} with result {\tt res}. */
1525  virtual void operator()( char* res, const char* op1,
1526  const char* op2 );
1527 };
1528 
1529 //@ManMemo: Module: {\bf catalogif}.
1530 //@Doc: OP_GREATER on C type #long# and #long#, result #char#.
1535 {
1536 public:
1538  OpGREATERCCharCLong(const BaseType* newResType,const BaseType* newOp1Type,
1539  const BaseType* newOp2Type, unsigned int newResOff = 0,
1540  unsigned int newOp1Off = 0,
1541  unsigned int newOp2Off = 0 );
1542  /*@ManMemo: operator to carry out operation on {\tt op1} and
1543  {\tt op2} with result {\tt res}. */
1544  virtual void operator()( char* res, const char* op1,
1545  const char* op2 );
1546 };
1547 
1548 //@ManMemo: Module: {\bf catalogif}.
1549 //@Doc: OP_GREATEREQUAL on C type #long# and #long#, result #char#.
1554 {
1555 public:
1557  OpGREATEREQUALCCharCLong(const BaseType* newResType,const BaseType* newOp1Type,
1558  const BaseType* newOp2Type, unsigned int newResOff = 0,
1559  unsigned int newOp1Off = 0,
1560  unsigned int newOp2Off = 0 );
1561  /*@ManMemo: operator to carry out operation on {\tt op1} and
1562  {\tt op2} with result {\tt res}. */
1563  virtual void operator()( char* res, const char* op1,
1564  const char* op2 );
1565 };
1566 
1567 //@ManMemo: Module: {\bf catalogif}.
1568 //@Doc: OP_EQUAL on C type #double# and #double#, result #char#.
1573 {
1574 public:
1576  OpEQUALCCharCDouble(const BaseType* newResType,const BaseType* newOp1Type,
1577  const BaseType* newOp2Type, unsigned int newResOff = 0,
1578  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1579  /*@ManMemo: operator to carry out operation on {\tt op1} and
1580  {\tt op2} with result {\tt res}. */
1581  virtual void operator()( char* res, const char* op1,
1582  const char* op2 );
1583 };
1584 
1585 //@ManMemo: Module: {\bf catalogif}.
1586 //@Doc: OP_LESS on C type #double# and #double#, result #char#.
1591 {
1592 public:
1594  OpLESSCCharCDouble(const BaseType* newResType,const BaseType* newOp1Type,
1595  const BaseType* newOp2Type, unsigned int newResOff = 0,
1596  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1597  /*@ManMemo: operator to carry out operation on {\tt op1} and
1598  {\tt op2} with result {\tt res}. */
1599  virtual void operator()( char* res, const char* op1,
1600  const char* op2 );
1601 };
1602 
1603 //@ManMemo: Module: {\bf catalogif}.
1604 //@Doc: OP_LESSEQUAL on C type #double# and #double#, result #char#.
1609 {
1610 public:
1612  OpLESSEQUALCCharCDouble(const BaseType* newResType,const BaseType* newOp1Type,
1613  const BaseType* newOp2Type, unsigned int newResOff = 0,
1614  unsigned int newOp1Off = 0,
1615  unsigned int newOp2Off = 0 );
1616  /*@ManMemo: operator to carry out operation on {\tt op1} and
1617  {\tt op2} with result {\tt res}. */
1618  virtual void operator()( char* res, const char* op1,
1619  const char* op2 );
1620 };
1621 
1622 //@ManMemo: Module: {\bf catalogif}.
1623 //@Doc: OP_NOTEQUAL on C type #double# and #double#, result #char#.
1628 {
1629 public:
1631  OpNOTEQUALCCharCDouble(const BaseType* newResType,const BaseType* newOp1Type,
1632  const BaseType* newOp2Type, unsigned int newResOff = 0,
1633  unsigned int newOp1Off = 0,
1634  unsigned int newOp2Off = 0 );
1635  /*@ManMemo: operator to carry out operation on {\tt op1} and
1636  {\tt op2} with result {\tt res}. */
1637  virtual void operator()( char* res, const char* op1,
1638  const char* op2 );
1639 };
1640 
1641 //@ManMemo: Module: {\bf catalogif}.
1642 //@Doc: OP_GREATER on C type #double# and #double#, result #char#.
1647 {
1648 public:
1650  OpGREATERCCharCDouble(const BaseType* newResType,const BaseType* newOp1Type,
1651  const BaseType* newOp2Type, unsigned int newResOff = 0,
1652  unsigned int newOp1Off = 0,
1653  unsigned int newOp2Off = 0 );
1654  /*@ManMemo: operator to carry out operation on {\tt op1} and
1655  {\tt op2} with result {\tt res}. */
1656  virtual void operator()( char* res, const char* op1,
1657  const char* op2 );
1658 };
1659 
1660 //@ManMemo: Module: {\bf catalogif}.
1661 //@Doc: OP_GREATEREQUAL on C type #double# and #double#, result #char#.
1666 {
1667 public:
1669  OpGREATEREQUALCCharCDouble(const BaseType* newResType,const BaseType* newOp1Type,
1670  const BaseType* newOp2Type, unsigned int newResOff = 0,
1671  unsigned int newOp1Off = 0,
1672  unsigned int newOp2Off = 0 );
1673  /*@ManMemo: operator to carry out operation on {\tt op1} and
1674  {\tt op2} with result {\tt res}. */
1675  virtual void operator()( char* res, const char* op1,
1676  const char* op2 );
1677 };
1678 
1679 //@ManMemo: Module: {\bf catalogif}.
1680 //@Doc: OP_PLUS specialized for RasDaMan type Char.
1684 class OpPLUSChar : public BinaryOp
1685 {
1686 public:
1688  OpPLUSChar(const BaseType* newResType,const BaseType* newOp1Type,
1689  const BaseType* newOp2Type, unsigned int newResOff = 0,
1690  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1691  /*@ManMemo: operator to carry out operation on {\tt op1} and
1692  {\tt op2} with result {\tt res}. */
1693  virtual void operator()( char* res, const char* op1,
1694  const char* op2 );
1695  virtual void getCondenseInit(char* init);
1696 };
1697 
1698 //@ManMemo: Module: {\bf catalogif}.
1699 //@Doc: OP_MINUS specialized for RasDaMan type Char.
1703 class OpMINUSChar : public BinaryOp
1704 {
1705 public:
1707  OpMINUSChar(const BaseType* newResType,const BaseType* newOp1Type,
1708  const BaseType* newOp2Type, unsigned int newResOff = 0,
1709  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1710  /*@ManMemo: operator to carry out operation on {\tt op1} and
1711  {\tt op2} with result {\tt res}. */
1712  virtual void operator()( char* res, const char* op1,
1713  const char* op2 );
1714 };
1715 
1716 //@ManMemo: Module: {\bf catalogif}.
1717 //@Doc: OP_MULT specialized for RasDaMan type Char.
1721 class OpMULTChar : public BinaryOp
1722 {
1723 public:
1725  OpMULTChar(const BaseType* newResType,const BaseType* newOp1Type,
1726  const BaseType* newOp2Type, unsigned int newResOff = 0,
1727  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1728  /*@ManMemo: operator to carry out operation on {\tt op1} and
1729  {\tt op2} with result {\tt res}. */
1730  virtual void operator()( char* res, const char* op1,
1731  const char* op2 );
1732  virtual void getCondenseInit(char* init);
1733 };
1734 
1735 //@ManMemo: Module: {\bf catalogif}.
1736 //@Doc: OP_DIV specialized for RasDaMan type Char.
1740 class OpDIVChar : public BinaryOp
1741 {
1742 public:
1744  OpDIVChar(const BaseType* newResType,const BaseType* newOp1Type,
1745  const BaseType* newOp2Type, unsigned int newResOff = 0,
1746  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1747  /*@ManMemo: operator to carry out operation on {\tt op1} and
1748  {\tt op2} with result {\tt res}. */
1749  virtual void operator()( char* res, const char* op1,
1750  const char* op2 );
1751 };
1752 
1753 //@ManMemo: Module: {\bf catalogif}.
1754 //@Doc: OP_EQUAL specialized for RasDaMan type Char.
1758 class OpEQUALChar : public BinaryOp
1759 {
1760 public:
1762  OpEQUALChar(const BaseType* newResType,const BaseType* newOp1Type,
1763  const BaseType* newOp2Type, unsigned int newResOff = 0,
1764  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1765  /*@ManMemo: operator to carry out operation on {\tt op1} and
1766  {\tt op2} with result {\tt res}. */
1767  virtual void operator()( char* res, const char* op1,
1768  const char* op2 );
1769 };
1770 
1771 //@ManMemo: Module: {\bf catalogif}.
1772 //@Doc: OP_LESS specialized for RasDaMan type Char.
1776 class OpLESSChar : public BinaryOp
1777 {
1778 public:
1780  OpLESSChar(const BaseType* newResType,const BaseType* newOp1Type,
1781  const BaseType* newOp2Type, unsigned int newResOff = 0,
1782  unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
1783  /*@ManMemo: operator to carry out operation on {\tt op1} and
1784  {\tt op2} with result {\tt res}. */
1785  virtual void operator()( char* res, const char* op1,
1786  const char* op2 );
1787 };
1788 
1789 //@ManMemo: Module: {\bf catalogif}.
1790 //@Doc: OP_LESSEQUAL specialized for RasDaMan type Char.
1795 {
1796 public:
1798  OpLESSEQUALChar(const BaseType* newResType,const BaseType* newOp1Type,
1799  const BaseType* newOp2Type, unsigned int newResOff = 0,
1800  unsigned int newOp1Off = 0,
1801  unsigned int newOp2Off = 0 );
1802  /*@ManMemo: operator to carry out operation on {\tt op1} and
1803  {\tt op2} with result {\tt res}. */
1804  virtual void operator()( char* res, const char* op1,
1805  const char* op2 );
1806 };
1807 
1808 //@ManMemo: Module: {\bf catalogif}.
1809 //@Doc: OP_NOTEQUAL specialized for RasDaMan type Char.
1813 class OpNOTEQUALChar : public BinaryOp
1814 {
1815 public:
1817  OpNOTEQUALChar(const BaseType* newResType,const BaseType* newOp1Type,
1818  const BaseType* newOp2Type, unsigned int newResOff = 0,
1819  unsigned int newOp1Off = 0,
1820  unsigned int newOp2Off = 0 );
1821  /*@ManMemo: operator to carry out operation on {\tt op1} and
1822  {\tt op2} with result {\tt res}. */
1823  virtual void operator()( char* res, const char* op1,
1824  const char* op2 );
1825 };
1826 
1827 //@ManMemo: Module: {\bf catalogif}.
1828 //@Doc: OP_GREATER specialized for RasDaMan type Char.
1832 class OpGREATERChar : public BinaryOp
1833 {
1834 public:
1836  OpGREATERChar(const BaseType* newResType,const BaseType* newOp1Type,
1837  const BaseType* newOp2Type, unsigned int newResOff = 0,
1838  unsigned int newOp1Off = 0,
1839  unsigned int newOp2Off = 0 );
1840  /*@ManMemo: operator to carry out operation on {\tt op1} and
1841  {\tt op2} with result {\tt res}. */
1842  virtual void operator()( char* res, const char* op1,
1843  const char* op2 );
1844 };
1845 
1846 //@ManMemo: Module: {\bf catalogif}.
1847 //@Doc: OP_GREATEREQUAL specialized for RasDaMan type Char.
1848 
1853 {
1854 public:
1856  OpGREATEREQUALChar(const BaseType* newResType,const BaseType* newOp1Type,
1857  const BaseType* newOp2Type, unsigned int newResOff = 0,
1858  unsigned int newOp1Off = 0,
1859  unsigned int newOp2Off = 0 );
1860  /*@ManMemo: operator to carry out operation on {\tt op1} and
1861  {\tt op2} with result {\tt res}. */
1862  virtual void operator()( char* res, const char* op1,
1863  const char* op2 );
1864 };
1865 
1866 //@ManMemo: Module: {\bf catalogif}.
1867 //@Doc: OP_IDENTITY specialized for RasDaMan type Char.
1868 
1872 class OpIDENTITYChar : public UnaryOp
1873 {
1874 public:
1876  OpIDENTITYChar(const BaseType* newResType,const BaseType* newOpType,
1877  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
1879  virtual void operator()( char* result, const char* op );
1880 };
1881 
1882 //@ManMemo: Module: {\bf catalogif}.
1883 //@Doc: OP_IDENTITY specialized for RasDaMan type Short.
1884 
1888 class OpIDENTITYShort : public UnaryOp
1889 {
1890 public:
1892  OpIDENTITYShort(const BaseType* newResType,const BaseType* newOpType,
1893  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
1895  virtual void operator()( char* result, const char* op );
1896 };
1897 
1898 //@ManMemo: Module: {\bf catalogif}.
1899 //@Doc: OP_IDENTITY specialized for RasDaMan type Long.
1900 
1904 class OpIDENTITYLong : public UnaryOp
1905 {
1906 public:
1908  OpIDENTITYLong(const BaseType* newResType,const BaseType* newOpType,
1909  unsigned int newResOff = 0, unsigned int newOpOff = 0 );
1911  virtual void operator()( char* result, const char* op );
1912 };
1913 
1914 //@ManMemo: Module: {\bf catalogif}.
1915 
1916 /*@Doc:
1917  MarrayOp is the superclass for all marray constructors. The class
1918  defined here is just a dummy and will be specialized in another
1919  module. operator() gets an r_Point as a parameter. For a useful
1920  marray constructor operation() will also need to calculate an
1921  expression.
1922 */
1923 
1928 {
1929 public:
1930  /*@ManMemo: constructor gets RasDaMan base type of result and its
1931  offset (for structs). Subclasses will have additional parameters. */
1932  MarrayOp(const BaseType* newResType, unsigned int newResOff = 0 );
1934  virtual void operator() ( char* result, const r_Point& p );
1935  /*@ManMemo: virtual destructor because subclasses may have
1936  non-trivial destructor. */
1937  virtual ~MarrayOp() { };
1938 
1939 protected:
1940  const BaseType* resType;
1941  unsigned int resOff;
1942 };
1943 
1944 //@ManMemo: Module: {\bf catalogif}.
1945 
1946 /*@Doc:
1947  GenCondenseOp is the superclass for all general condense operations.
1948  The class defined here is just a dummy and will be specialized in
1949  another module. operator() gets an r_Point as a parameter. For a useful
1950  marray constructor operation() will also need to calculate an
1951  expression. Every GenCondenseOp has a binary operation which is
1952  used to accumulate the values. If an initVal (of type resType)
1953  is given, it is used as a basis for accumulation. Otherwist a
1954  default initVal is retrieved from {\tt accuOp}.
1955 */
1956 
1961 {
1962 public:
1963  /*@ManMemo: constructor gets RasDaMan base type of result and its
1964  offset (for structs, 0 if no struct). A binary operation for
1965  accumulation is given and an optional init value. Subclasses
1966  will have additional parameters. Note that newInitVal has to be
1967  deleted by the caller! */
1968  GenCondenseOp(const BaseType* newResType, unsigned int newResOff,
1969  BinaryOp* newAccuOp, char* newInitVal = 0 );
1971  virtual void operator()( const r_Point& p );
1973  BinaryOp* getAccuOp();
1975  const BaseType* getResultType();
1977  unsigned int getResultOff();
1979  char* getAccuVal();
1980  /*@ManMemo: virtual destructor because subclasses may have
1981  non-trivial destructor. */
1982  virtual ~GenCondenseOp();
1983 
1984 protected:
1986  unsigned int resOff;
1988  // initVal is always of RasDaMan-Type restype!
1989  char* initVal;
1990  // used to flag if destructor should delete initVal
1992 };
1993 
1994 
1995 //--------------------------------------------
1996 // Complex operations
1997 //--------------------------------------------
1998 
2002 class OpPLUSComplex : public BinaryOp
2003 {
2004 public:
2005  // Question: which operand is scalar?
2006  // Answere: NONE, FIRST, SECOND
2008 
2009  OpPLUSComplex(
2010  const BaseType* newResType,
2011  const BaseType* newOp1Type,
2012  const BaseType* newOp2Type,
2013  unsigned int newResOff = 0,
2014  unsigned int newOp1Off = 0,
2015  unsigned int newOp2Off = 0,
2016  ScalarFlag flag = NONE
2017  );
2018  virtual void operator()(char* res, const char* op1, const char* op2);
2019  virtual void getCondenseInit(char* init);
2020 
2021 protected:
2022  unsigned int op1ReOff;
2023  unsigned int op1ImOff;
2024  unsigned int op2ReOff;
2025  unsigned int op2ImOff;
2026  unsigned int resReOff;
2027  unsigned int resImOff;
2029 };
2030 
2034 class OpMINUSComplex : public BinaryOp
2035 {
2036 public:
2037  // Question: which operand is scalar?
2038  // Answere: NONE, FIRST, SECOND
2040 
2042  const BaseType* newResType,
2043  const BaseType* newOp1Type,
2044  const BaseType* newOp2Type,
2045  unsigned int newResOff = 0,
2046  unsigned int newOp1Off = 0,
2047  unsigned int newOp2Off = 0,
2048  ScalarFlag flag = NONE
2049  );
2050  virtual void operator()(char* res, const char* op1, const char* op2);
2051 
2052 protected:
2053  unsigned int op1ReOff;
2054  unsigned int op1ImOff;
2055  unsigned int op2ReOff;
2056  unsigned int op2ImOff;
2057  unsigned int resReOff;
2058  unsigned int resImOff;
2060 };
2061 
2065 class OpDIVComplex : public BinaryOp
2066 {
2067 public:
2068  // Question: which operand is scalar?
2069  // Answere: NONE, FIRST, SECOND
2071 
2072  OpDIVComplex(
2073  const BaseType* newResType,
2074  const BaseType* newOp1Type,
2075  const BaseType* newOp2Type,
2076  unsigned int newResOff = 0,
2077  unsigned int newOp1Off = 0,
2078  unsigned int newOp2Off = 0,
2079  ScalarFlag flag = NONE
2080  );
2081  virtual void operator()( char* res, const char* op1, const char* op2 );
2082 
2083 protected:
2084  unsigned int op1ReOff;
2085  unsigned int op1ImOff;
2086  unsigned int op2ReOff;
2087  unsigned int op2ImOff;
2088  unsigned int resReOff;
2089  unsigned int resImOff;
2091 };
2092 
2096 class OpMULTComplex : public BinaryOp
2097 {
2098 public:
2099  // Question: which operand is scalar?
2100  // Answere: NONE, FIRST, SECOND
2102 
2103  OpMULTComplex(
2104  const BaseType* newResType,
2105  const BaseType* newOp1Type,
2106  const BaseType* newOp2Type,
2107  unsigned int newResOff = 0,
2108  unsigned int newOp1Off = 0,
2109  unsigned int newOp2Off = 0,
2110  ScalarFlag flag = NONE
2111  );
2112  virtual void operator()( char* res, const char* op1, const char* op2 );
2113  virtual void getCondenseInit(char* init);
2114 
2115 protected:
2116  unsigned int op1ReOff;
2117  unsigned int op1ImOff;
2118  unsigned int op2ReOff;
2119  unsigned int op2ImOff;
2120  unsigned int resReOff;
2121  unsigned int resImOff;
2123 };
2124 
2129 {
2130 public:
2131  OpIDENTITYComplex(const BaseType* , const BaseType* , unsigned int = 0, unsigned int = 0);
2132  virtual void operator()(char* result, const char* op);
2133 };
2134 
2138 class OpRealPart : public UnaryOp
2139 {
2140 public:
2141  OpRealPart(
2142  const BaseType* newResType,
2143  const BaseType* newOpType,
2144  unsigned int newResOff = 0,
2145  unsigned int newOpOff = 0
2146  );
2147  virtual void operator() (char* result, const char* op);
2148 
2149 private:
2150  unsigned int opReOff;
2151 };
2152 
2153 
2157 class OpImaginarPart : public UnaryOp
2158 {
2159 public:
2161  const BaseType* newResType,
2162  const BaseType* newOpType,
2163  unsigned int newResOff = 0,
2164  unsigned int newOpOff = 0
2165  );
2166  virtual void operator() (char* result, const char* op);
2167 
2168 private:
2169  unsigned int opImOff;
2170 };
2171 
2172 //--------------------------------------------
2173 // OpCAST
2174 //--------------------------------------------
2175 /*@Doc:
2176 OpCAST provide cast operation.
2177 */
2178 
2182 class OpCAST : public UnaryOp
2183 {
2184 public:
2185  OpCAST(
2186  const BaseType* newResType,
2187  const BaseType* newOpType,
2188  unsigned int newResOff = 0,
2189  unsigned int newOpOff = 0
2190  );
2192  virtual void operator() (char* result, const char* op);
2193 };
2194 
2195 //--------------------------------------------
2196 // OpOVERLAY
2197 //--------------------------------------------
2198 //@ManMemo: Module: {\bf catalogif}.
2199 //@Doc: OP_OVERLAY
2200 
2204 class OpOVERLAY : public BinaryOp
2205 {
2206 public:
2208  static const char* nullPattern;
2210  OpOVERLAY(const BaseType* newResType,
2211  const BaseType* newOp1Type,
2212  const BaseType* newOp2Type,
2213  size_t typeSize,
2214  const char* transparentPattern = OpOVERLAY::nullPattern,
2215  unsigned int newResOff = 0,
2216  unsigned int newOp1Off = 0,
2217  unsigned int newOp2Off = 0);
2218 
2219  /*@ManMemo: operator to carry out operation on {\tt op1} and
2220  {\tt op2} with result {\tt res}. */
2221  virtual void operator()( char* res, const char* op1, const char* op2 );
2222 private:
2223  size_t length;
2224 
2225  const char* pattern;
2226 };
2227 
2228 
2229 //--------------------------------------------
2230 // OpBIT
2231 //--------------------------------------------
2232 /*@Doc:
2233 */
2234 
2238 class OpBIT : public BinaryOp
2239 {
2240 public:
2241  OpBIT(
2242  const BaseType* newResType,
2243  const BaseType* newOp1Type,
2244  const BaseType* newOp2Type,
2245  unsigned int newResOff = 0,
2246  unsigned int newOp1Off = 0,
2247  unsigned int newOp2Off = 0
2248  );
2249 
2251  virtual void operator()(char* res, const char* op1, const char* op2);
2252 };
2253 
2254 
2255 
2256 #include "autogen_ops.hh"
2257 
2258 
2259 #endif
2260 // LocalWords: op
unsigned int op1ReOff
Definition: ops.hh:2116
Definition: ops.hh:151
Definition: ops.hh:2070
virtual char * operator()(const char *op, char *myAccu)
operator to carry out operation on { op}.
Definition: ops.hh:58
Definition: ops.hh:2157
Definition: ops.hh:118
virtual void operator()(char *res, const char *op1, const char *op2)
Definition: ops.hh:1721
GenCondenseOp(const BaseType *newResType, unsigned int newResOff, BinaryOp *newAccuOp, char *newInitVal=0)
StructType * myOpType
Definition: ops.hh:660
Definition: ops.hh:160
Definition: ops.hh:270
OpMINUSCDouble(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
Definition: ops.hh:1960
Definition: ops.hh:1534
Definition: ops.hh:370
virtual void operator()(char *res, const char *op1, const char *op2)
Definition: ops.hh:2065
OpGREATERCCharCULong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
unsigned int resImOff
Definition: ops.hh:2058
virtual void getCondenseInit(char *init)
returns initialization value for {GenCondenseOp}.
Definition: ops.hh:1441
virtual void operator()(char *res, const char *op1, const char *op2)
virtual void getCondenseInit(char *init)
returns initialization value for {GenCondenseOp}.
OpMINUSChar(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
virtual char * operator()(const char *op, char *myAccu)
operator to carry out operation on { op}.
virtual void operator()(char *res, const char *op1, const char *op2)
virtual void operator()(char *res, const char *op1, const char *op2)
unsigned int numElems
Definition: ops.hh:910
Definition: ops.hh:135
Definition: ops.hh:160
Definition: ops.hh:686
virtual void getCondenseInit(char *init)
returns initialization value for {GenCondenseOp}.
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op}.
Definition: ops.hh:124
virtual void operator()(char *res, const char *op1, const char *op2)
virtual void operator()(char *res, const char *op1, const char *op2)
Definition: ops.hh:896
virtual void operator()(char *res, const char *op1, const char *op2)
Definition: ops.hh:156
virtual void getCondenseInit(char *init)
returns initialization value for {GenCondenseOp}.
UnaryOp(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
BinaryOp ** elemOps
Definition: ops.hh:912
Definition: ops.hh:942
OpGREATERChar(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
Definition: ops.hh:546
Definition: ops.hh:1013
Definition: ops.hh:1108
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op}.
ScalarFlag scalarFlag
Definition: ops.hh:2059
Definition: ops.hh:2138
Definition: ops.hh:326
virtual void operator()(char *res, const char *op1, const char *op2)
operator to carry out operation on struct { op}.
unsigned int op2ReOff
Definition: ops.hh:2024
unsigned int op2ReOff
Definition: ops.hh:2118
const BaseType * resType
Definition: ops.hh:294
virtual void getCondenseInit(char *init)
returns initialization value for {GenCondenseOp}.
unsigned int op1ImOff
Definition: ops.hh:2117
Definition: ops.hh:157
virtual ~OpCondenseStruct()
destructor.
unsigned int op2ImOff
Definition: ops.hh:2119
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op} with result { result}.
virtual void operator()(char *res, const char *op1, const char *op2)
Definition: ops.hh:2101
OpLESSCCharCULong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
StructType * resStructType
Definition: ops.hh:887
Definition: ops.hh:414
Definition: ops.hh:2007
OpDIVCULong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
StructType * myResType
Definition: ops.hh:659
Definition: ops.hh:2204
virtual void operator()(char *res, const char *op1, const char *op2)
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op} with result { result}.
Definition: ops.hh:1776
Definition: point.hh:59
virtual void getCondenseInit(char *init)
returns initialization value for {GenCondenseOp}.
Definition: ops.hh:145
Definition: ops.hh:1553
OpMAXCULong(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
static UnaryOp * getUnaryOp(Ops::OpType op, const BaseType *restype, const BaseType *optype, unsigned int resOff=0, unsigned int opOff=0)
get function object for unary operation.
StructType * myOpType
Definition: ops.hh:598
OpNOTCLong(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
constructor gets RasDaMan base type of result and operand.
Definition: ops.hh:144
OpLESSCCharCLong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
virtual char * operator()(const char *op, char *myAccu)
operator to carry out operation on { op}.
virtual void operator()(char *res, const char *op1, const char *op2)
unsigned int op1ReOff
Definition: ops.hh:2053
const BaseType * resType
Definition: ops.hh:1937
Definition: ops.hh:124
Definition: ops.hh:1237
Definition: ops.hh:157
OpType
Definition: ops.hh:121
virtual void operator()(char *res, const char *op1, const char *op2)
virtual char * operator()(const char *op, char *myAccu)
operator to carry out operation on struct { op}.
OpIDENTITYLong(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
constructor gets RasDaMan base type of result and operand.
unsigned int numElems
Definition: ops.hh:932
Definition: ops.hh:146
const BaseType * opType
Definition: ops.hh:625
virtual void operator()(char *res, const char *op1, const char *op2)
Definition: ops.hh:1590
unsigned int numElems
Definition: ops.hh:829
Definition: ops.hh:54
unsigned int numElems
Definition: ops.hh:661
unsigned int numElems
Definition: ops.hh:859
OpGREATEREQUALCCharCULong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
Definition: ops.hh:157
virtual void operator()(char *res, const char *op1, const char *op2)
virtual void operator()(char *res, const char *op1, const char *op2)
virtual void getCondenseInit(char *init)
returns initialization value for {GenCondenseOp}.
OpIDENTITYCDouble(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
constructor gets RasDaMan base type of result and operand.
Definition: ops.hh:1904
virtual void getCondenseInit(char *init)
returns initialization value for {GenCondenseOp}.
Definition: ops.hh:304
CondenseOp(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
virtual void getCondenseInit(char *init)
returns initialization value for {GenCondenseOp}.
virtual char * getAccuVal()
operator to access value of internal accumulator.
Definition: ops.hh:995
BinaryOp ** elemOps
Definition: ops.hh:891
Definition: ops.hh:147
virtual void operator()(char *result, const char *op)
operator to carry out cast operation.
Definition: ops.hh:1478
Definition: ops.hh:136
virtual ~OpBinaryConstStruct()
destructor.
Definition: ops.hh:716
Definition: ops.hh:139
unsigned int resImOff
Definition: ops.hh:2027
virtual void operator()(char *res, const char *op1, const char *op2)
Definition: ops.hh:958
OpPLUSChar(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
Definition: ops.hh:134
static CondenseOp * getCondenseOp(Ops::OpType op, const BaseType *resType, const BaseType *opType=0, unsigned int resOff=0, unsigned int opOff=0)
Definition: ops.hh:2182
Definition: ops.hh:134
Definition: ops.hh:1366
OpCOUNTCChar(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
const BaseType * getResultType()
returns result type (needed in class {Tile}.
StructType * myStructType
Definition: ops.hh:828
Definition: ops.hh:54
Definition: ops.hh:124
virtual char * operator()(const char *op, char *myAccu)
operator to carry out operation on { op}.
virtual void operator()(char *res, const char *op1, const char *op2)
virtual ~OpNOTEQUALStruct()
destructor.
unsigned int resImOff
Definition: ops.hh:2121
Definition: ops.hh:1126
Definition: ops.hh:141
Definition: ops.hh:2039
unsigned int op2ImOff
Definition: ops.hh:2087
ScalarFlag
Definition: ops.hh:2070
virtual void operator()(char *res, const char *op1, const char *op2)
Definition: ops.hh:1051
Definition: ops.hh:130
virtual void operator()(char *res, const char *op1, const char *op2)
virtual void operator()(char *res, const char *op1, const char *op2)
virtual void operator()(char *res, const char *op1, const char *op2)
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op} with result { result}.
Definition: ops.hh:2101
OpSUMCDouble(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
Definition: ops.hh:1199
virtual ~UnaryOp()
Definition: ops.hh:625
virtual char * operator()(const char *op, char *myAccu)=0
operator to carry out operation on { op}.
virtual void getCondenseInit(char *init)
returns initialization value for {GenCondenseOp}.
Definition: ops.hh:2007
Definition: ops.hh:124
Definition: ops.hh:131
OpMULTCULong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
static const BaseType * getResultType(Ops::OpType op, const BaseType *op1, const BaseType *op2=0)
gives back suggested return type for #op# carried out on the given types.
virtual void operator()(char *res, const char *op1, const char *op2)
OpNOTEQUALCCharCDouble(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
OpXORCLong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op} with result { result}.
BinaryOp ** elemOps
Definition: ops.hh:831
Definition: ops.hh:132
Definition: ops.hh:2039
unsigned int opOff
Definition: ops.hh:296
Definition: ops.hh:1572
Definition: ops.hh:671
Definition: ops.hh:2101
Definition: ops.hh:156
OpImaginarPart(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
virtual char * operator()(const char *op, char *myAccu)
operator to carry out operation on { op}.
static BinaryOp * getBinaryOp(Ops::OpType op, const BaseType *resType, const BaseType *op1Type, const BaseType *op2Type, unsigned int resOff=0, unsigned int op1Off=0, unsigned int op2Off=0)
get function object for binary operation.
virtual ~CondenseOp()
virtual void getCondenseInit(char *init)
returns initialization value for {GenCondenseOp}.
virtual void operator()(char *res, const char *op1, const char *op2)
ScalarFlag
Definition: ops.hh:2101
OpIDENTITYCLong(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
constructor gets RasDaMan base type of result and operand.
OpLESSEQUALCCharCDouble(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
Definition: ops.hh:157
const BaseType * resType
Definition: ops.hh:801
OpMINUSComplex(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0, ScalarFlag flag=NONE)
virtual ~OpBinaryStruct()
destructor.
unsigned int op2Off
Definition: ops.hh:804
Definition: ops.hh:1740
Definition: ops.hh:1089
virtual ~BinaryOp()
Definition: ops.hh:796
Definition: ops.hh:761
Definition: ops.hh:731
Definition: ops.hh:2002
virtual void operator()(char *res, const char *op1, const char *op2)
static const char * nullPattern
this pattern is only 16 bytes long and empty, if your struct is longer you need to supply your own pa...
Definition: ops.hh:2208
unsigned int resReOff
Definition: ops.hh:2057
char * initVal
Definition: ops.hh:1989
Definition: ops.hh:1348
Definition: ops.hh:138
virtual void operator()(char *res, const char *op1, const char *op2)
Definition: ops.hh:58
OpEQUALCCharCULong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
OpPLUSULong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
OpPLUSCULong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
OpEQUALCCharCLong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
Definition: ops.hh:480
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op} with result { result}.
virtual ~OpBinaryStructConst()
destructor.
OpRealPart(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
virtual void operator()(char *res, const char *op1, const char *op2)
OpOVERLAY(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, size_t typeSize, const char *transparentPattern=OpOVERLAY::nullPattern, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
ScalarFlag
Definition: ops.hh:2007
OpEQUALChar(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
Definition: ops.hh:135
Definition: ops.hh:1403
OpMULTChar(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
OpALLCChar(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} with result { result}.
Definition: ops.hh:127
Definition: ops.hh:1032
Definition: ops.hh:124
OpANDBool(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
Definition: ops.hh:642
Definition: ops.hh:458
Definition: ops.hh:2039
Definition: ops.hh:2096
virtual void operator()(char *res, const char *op1, const char *op2)
OpLESSCCharCDouble(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
Definition: ops.hh:131
Definition: ops.hh:132
unsigned int getResultOff()
returns result offset (needed in class {Tile}.
unsigned int resOff
Definition: ops.hh:630
Definition: ops.hh:614
OpGREATERCCharCDouble(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
ScalarFlag scalarFlag
Definition: ops.hh:2028
virtual void operator()(char *res, const char *op1, const char *op2)
virtual ~OpUnaryStruct()
destructor.
OpDIVComplex(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0, ScalarFlag flag=NONE)
virtual char * operator()(const char *op, char *myAccu)
operator to carry out operation on { op}.
OpANDCULong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
Definition: ops.hh:502
virtual void operator()(char *res, const char *op1, const char *op2)
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op} with result { result}.
Definition: ops.hh:815
virtual char * operator()(const char *op, char *myAccu)
operator to carry out operation on { op}.
Definition: ops.hh:348
Definition: ops.hh:1329
OpEQUALStruct(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
Definition: structtype.hh:68
virtual ~OpEQUALStruct()
destructor.
virtual void operator()(char *res, const char *op1, const char *op2)
OpSUMCULong(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
Definition: ops.hh:134
Definition: ops.hh:156
OpBIT(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
OpBinaryStructConst(const BaseType *resType, const BaseType *op1Type, const BaseType *op2Type, Ops::OpType op, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets struct type.
Definition: ops.hh:159
BinaryOp * accuOp
Definition: ops.hh:1987
Definition: ops.hh:1422
Definition: ops.hh:1813
Definition: ops.hh:1794
Definition: ops.hh:1515
virtual char * operator()(const char *op, char *myAccu)
operator to carry out operation on { op}.
Definition: ops.hh:1646
Definition: ops.hh:54
virtual void operator()(char *res, const char *op1, const char *op2)
OpMINCDouble(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
OpCondenseStruct(const BaseType *newResType, const BaseType *newOpType, Ops::OpType op, unsigned int newResOff=0, unsigned int newOpOff=0)
constructor gets struct type.
Definition: ops.hh:150
Definition: ops.hh:55
Definition: ops.hh:159
static int isApplicable(Ops::OpType op, const BaseType *op1Type, const BaseType *op2Type=0)
checks, if #op# is applicable on the given types.
virtual void operator()(char *res, const char *op1, const char *op2)
operator to carry out operation on struct { op}.
virtual char * operator()(const char *op, char *myAccu)
operator to carry out operation on { op}.
Definition: ops.hh:780
Definition: ops.hh:701
char * accu
Definition: ops.hh:292
Definition: ops.hh:159
virtual void operator()(char *res, const char *op1, const char *op2)
OpNOTEQUALCCharCULong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
OpNOTEQUALChar(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
OpUnaryStruct(const BaseType *newResType, const BaseType *newOpType, Ops::OpType op, unsigned int newResOff=0, unsigned int newOpOff=0)
constructor gets struct type.
virtual void operator()(char *result, const char *op)
operator to carry out operation on struct { op}.
virtual void operator()(char *res, const char *op1, const char *op2)
virtual void getCondenseInit(char *init)
returns initialization value for {GenCondenseOp}.
OpSUMCLong(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
virtual void operator()(char *res, const char *op1, const char *op2)
unsigned int op1Off
Definition: ops.hh:803
OpMINUSCLong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op} with result { result}.
Definition: ops.hh:2070
const BaseType * op1Type
Definition: ops.hh:796
ScalarFlag scalarFlag
Definition: ops.hh:2122
Definition: ops.hh:1256
Definition: ops.hh:571
unsigned int resOff
Definition: ops.hh:802
int myInitVal
Definition: ops.hh:1991
virtual void operator()(char *res, const char *op1, const char *op2)
Definition: ops.hh:1832
virtual void operator()(char *result, const char *op)=0
operator to carry out operation on { op}.
virtual void operator()(char *res, const char *op1, const char *op2)
StructType * opStructType
Definition: ops.hh:888
virtual void getCondenseInit(char *init)
returns initialization value for {GenCondenseOp}.
virtual void operator()(char *res, const char *op1, const char *op2)
Definition: tile.hh:80
OpLESSEQUALChar(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
OpORCULong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
OpPLUSCDouble(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
OpNOTEQUALCCharCLong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
Definition: ops.hh:133
OpDIVCLong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
virtual void operator()(char *res, const char *op1, const char *op2)
Definition: ops.hh:1460
OpANDCLong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
Definition: ops.hh:2007
BinaryOp(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
unsigned int op1ImOff
Definition: ops.hh:2054
BinaryOp ** elemOps
Definition: ops.hh:861
OpPLUSCLong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
virtual void operator()(char *res, const char *op1, const char *op2)
unsigned int resOff
Definition: ops.hh:1941
unsigned int op1ReOff
Definition: ops.hh:2084
OpGREATEREQUALCCharCLong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
Definition: ops.hh:57
virtual void operator()(char *res, const char *op1, const char *op2)
Definition: ops.hh:1311
Definition: ops.hh:1163
unsigned int resImOff
Definition: ops.hh:2089
Definition: relcatalogif/basetype.hh:66
CondenseOp ** elemOps
Definition: ops.hh:601
Definition: ops.hh:1888
Definition: ops.hh:2070
Definition: ops.hh:392
TypeEnum
Definition: ops.hh:52
Definition: ops.hh:149
OpMAXCLong(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
Definition: ops.hh:156
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op} with result { result}.
Definition: ops.hh:1293
OpIDENTITYComplex(const BaseType *, const BaseType *, unsigned int=0, unsigned int=0)
Definition: ops.hh:1608
Definition: ops.hh:54
Definition: ops.hh:840
virtual void getCondenseInit(char *init)
returns initialization value for {GenCondenseOp}.
Definition: ops.hh:1274
virtual void operator()(char *res, const char *op1, const char *op2)
operator to carry out bit operation
virtual void operator()(char *res, const char *op1, const char *op2)
Definition: ops.hh:133
Definition: ops.hh:135
Definition: ops.hh:54
OpXORCULong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
OpMINUSCULong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
Definition: ops.hh:1758
virtual char * operator()(const char *op, char *myAccu)
operator to carry out operation on { op}.
const BaseType * resType
Definition: ops.hh:1985
Definition: ops.hh:746
virtual void operator()(char *res, const char *op1, const char *op2)
unsigned int op2ImOff
Definition: ops.hh:2025
virtual ~MarrayOp()
Definition: ops.hh:1937
Definition: ops.hh:1852
Definition: ops.hh:2128
unsigned int numElems
Definition: ops.hh:889
OpGREATEREQUALChar(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
virtual void getCondenseInit(char *init)
returns initialization value for {GenCondenseOp}.
Definition: ops.hh:133
virtual void operator()(char *res, const char *op1, const char *op2)
OpNOTBool(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
constructor gets RasDaMan base type of result and operand.
Definition: ops.hh:1218
StructType * resStructType
Definition: ops.hh:857
Definition: ops.hh:524
unsigned int numElems
Definition: ops.hh:599
Definition: ops.hh:143
virtual char * operator()(const char *op, char *myAccu)
operator to carry out operation on { op}.
Definition: ops.hh:870
virtual ~GenCondenseOp()
OpMULTCLong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
Definition: ops.hh:1144
Definition: ops.hh:54
Definition: ops.hh:154
OpMINCULong(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
OpGREATERCCharCLong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
OpEQUALCCharCDouble(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
OpPLUSComplex(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0, ScalarFlag flag=NONE)
virtual void operator()(char *res, const char *op1, const char *op2)
virtual char * operator()(const char *op, char *myAccu)
operator to carry out operation on { op}.
virtual void operator()(char *res, const char *op1, const char *op2)
Definition: ops.hh:125
virtual void operator()(char *res, const char *op1, const char *op2)
OpIDENTITYCULong(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
constructor gets RasDaMan base type of result and operand.
OpLESSChar(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
OpIDENTITYShort(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
constructor gets RasDaMan base type of result and operand.
virtual void getCondenseInit(char *init)
returns initialization value for {GenCondenseOp}.
OpIDENTITYChar(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
constructor gets RasDaMan base type of result and operand.
StructType * myResType
Definition: ops.hh:597
OpMULTCDouble(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
Definition: ops.hh:1684
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op} with result { result}.
Definition: ops.hh:2238
static void execUnaryConstOp(Ops::OpType op, const BaseType *resType, const BaseType *opType, char *res, const char *op1, unsigned int resOff=0, unsigned int opOff=0)
executes operation on a constant.
Definition: ops.hh:58
const BaseType * resType
Definition: ops.hh:629
virtual void operator()(char *res, const char *op1, const char *op2)
unsigned int resReOff
Definition: ops.hh:2120
Definition: ops.hh:56
OpXORBool(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
ScalarFlag scalarFlag
Definition: ops.hh:2090
virtual void operator()(char *res, const char *op1, const char *op2)
unsigned int op1ReOff
Definition: ops.hh:2022
Definition: ops.hh:157
ScalarFlag
Definition: ops.hh:2039
OpBinaryStruct(const BaseType *newStructType, Ops::OpType op, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets struct type.
Definition: ops.hh:1627
virtual void operator()(char *res, const char *op1, const char *op2)
virtual void operator()(char *res, const char *op1, const char *op2)
Definition: ops.hh:977
OpDIVChar(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
OpORBool(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
StructType * opStructType
Definition: ops.hh:858
unsigned int op2ReOff
Definition: ops.hh:2086
virtual void operator()(char *res, const char *op1, const char *op2)=0
static void execBinaryConstOp(Ops::OpType op, const BaseType *resType, const BaseType *op1Type, const BaseType *op2Type, char *res, const char *op1, const char *op2, unsigned int resOff=0, unsigned int op1Off=0, unsigned int op2Off=0)
executes operation on two constants.
Definition: ops.hh:1070
Definition: ops.hh:157
virtual void operator()(char *res, const char *op1, const char *op2)
Definition: ops.hh:142
UnaryOp ** elemOps
Definition: ops.hh:663
unsigned int op1ImOff
Definition: ops.hh:2023
unsigned int op2ImOff
Definition: ops.hh:2056
Definition: ops.hh:1665
OpLESSEQUALCCharCLong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
OpORCLong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
Definition: ops.hh:1703
Definition: ops.hh:917
BinaryOp * getAccuOp()
returns binary accumulation op (needed in class {Tile}.
Definition: ops.hh:1181
Definition: ops.hh:132
unsigned int resOff
Definition: ops.hh:1986
OpIDENTITYStruct(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
constructor gets RasDaMan base type of result and operand.
OpMAXCDouble(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
OpBinaryConstStruct(const BaseType *resType, const BaseType *op1Type, const BaseType *op2Type, Ops::OpType op, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets struct type.
virtual void operator()(char *res, const char *op1, const char *op2)
const BaseType * opType
Definition: ops.hh:293
OpDIVCDouble(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
virtual void operator()(char *res, const char *op1, const char *op2)
MarrayOp(const BaseType *newResType, unsigned int newResOff=0)
OpMINCLong(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
Definition: ops.hh:160
virtual void operator()(char *result, const char *op)
operator to carry out operation on { op}.
unsigned int resReOff
Definition: ops.hh:2088
OpLESSEQUALCCharCULong(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
const BaseType * op2Type
Definition: ops.hh:800
unsigned int resOff
Definition: ops.hh:295
Definition: ops.hh:436
Definition: ops.hh:2034
virtual void operator()(char *res, const char *op1, const char *op2)
char * getAccuVal()
returns accumulated result.
Definition: ops.hh:1872
OpSOMECChar(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
unsigned int op1ImOff
Definition: ops.hh:2085
Definition: ops.hh:54
virtual void getCondenseInit(char *init)
returns initialization value for {GenCondenseOp}.
unsigned int op2ReOff
Definition: ops.hh:2055
unsigned int opOff
Definition: ops.hh:631
virtual void operator()(char *res, const char *op1, const char *op2)
unsigned int resReOff
Definition: ops.hh:2026
OpNOTEQUALStruct(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
Definition: ops.hh:148
virtual void getCondenseInit(char *init)
returns initialization value for {GenCondenseOp}.
BinaryOp ** elemOps
Definition: ops.hh:934
OpMULTComplex(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0, ScalarFlag flag=NONE)
Definition: ops.hh:1496
OpNOTCULong(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
constructor gets RasDaMan base type of result and operand.
Definition: ops.hh:1384
virtual void operator()(char *res, const char *op1, const char *op2)
operator to carry out operation on struct { op}.
OpGREATEREQUALCCharCDouble(const BaseType *newResType, const BaseType *newOp1Type, const BaseType *newOp2Type, unsigned int newResOff=0, unsigned int newOp1Off=0, unsigned int newOp2Off=0)
constructor gets RasDaMan base type of result and operands.
virtual void operator()(const r_Point &p)
operator to carry out operation on { p}. Has a dummy implementation.
Definition: ops.hh:54
Definition: ops.hh:1927
Definition: ops.hh:54
virtual void operator()(char *res, const char *op1, const char *op2)
OpCAST(const BaseType *newResType, const BaseType *newOpType, unsigned int newResOff=0, unsigned int newOpOff=0)
virtual void operator()(char *res, const char *op1, const char *op2)
virtual void operator()(char *result, const r_Point &p)
operator to carry out operation on { p}. Has a dummy implementation.