/*
* This file is part of rasdaman community.
*
* Rasdaman community is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Rasdaman community is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with rasdaman community. If not, see .
*
* Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009 Peter Baumann /
rasdaman GmbH.
*
* For more information please see
* or contact Peter Baumann via .
/
/*************************************************************
*
*
* PURPOSE:
* Ops contains an enum for identifying all possible
* operations.
*
*
* COMMENTS:
*
************************************************************/
#ifndef _OPS_HH_
#define _OPS_HH_
#include
class CondenseOp;
class UnaryOp;
class BinaryOp;
class BaseType;
class StructType;
class Tile;
class r_Point;
//@Man: TypeEnum
//@Type: typedef
//@Memo: Module: {\bf catalogif}.
enum TypeEnum
{
ULONG, USHORT, CHAR, BOOLTYPE, LONG, SHORT, OCTET, DOUBLE, FLOAT,
COMPLEXTYPE1, // COMPLEX already defined as token !!!
COMPLEXTYPE2,
STRUCT,
CLASSTYPE, SETTYPE, MDDTYPE
};
/*@Doc: This is an enum used for handling types instead of using the
string representation of the name. For some strange reason
I did not manage to define it in Ops scope. I had to use BOOLTYPE
instead of BOOL because of name conflicts.
Attention: DO NOT change the sequence because some code relies on it.
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.
*/
//@ManMemo: Module: {\bf catalogif}.
/*@Doc:
The class Ops is contains an enumeration type giving symbolic names
to all implemented operations. These names are given as parameters
to functions concerning operations in \Ref{Tile} and
\Ref{BaseType}. The selection of operations is actually done in
functions of this class, called by the classes mentioned above. The
operations are implemented in subclasses of \Ref{CondenseOp},
\Ref{UnaryOp} and \Ref{BinaryOp}.
The operations in the following table are defined at the moment.
They can be used in expressions like {\tt Ops::OP_EQUAL}.
\begin{tabular}{cl}
symbolic name && operation \\
&& {\bf condense operations} \\
OP_SOME && condense boolean tile with OR \\
OP_ALL && condense boolean tile with AND \\
&& {\bf unary operations} \\
OP_NOT && negation (bitwise for ints, logical for bools) \\
OP_SQRT && square root (for doubles) \\
OP_IDENTITY && used for copying cells \\
&& {\bf binary operations} \\
OP_MINUS && subtraction \\
OP_PLUS && addition \\
OP_MULT && multiplication \\
OP_DIV && division \\
OP_IS && not implemented yet \\
OP_AND && bitwise resp. logical AND \\
OP_OR && bitwise resp. logical OR \\
OP_XOR && bitwise resp. logical XOR \\
OP_EQUAL && equality (result Bool) \\
OP_LESS && less than (result Bool) \\
OP_LESSEQUAL && less than or equal (result Bool) \\
OP_NOTEQUAL && inequality (result Bool) \\
OP_GREATER && greater than (result Bool) \\
OP_GREATEREQUAL && greater than or equal (result Bool) \\
\end{tabular}
*/
class Ops
{
public:
enum OpType
{
// condense operations.
OP_COUNT, OP_MAX, OP_MIN, OP_SUM, OP_SOME,
/* insert new condense ops before this line */ OP_ALL,
// unary operations.
OP_NOT,
//*******************
OP_UFUNC_BEGIN,
OP_ABS, OP_SQRT,
OP_EXP, OP_LOG, OP_LN,
OP_SIN, OP_COS, OP_TAN,
OP_SINH, OP_COSH, OP_TANH,
OP_ARCSIN, OP_ARCCOS, OP_ARCTAN,
OP_UFUNC_END,
OP_REALPART,
OP_IMAGINARPART,
OP_CAST_BEGIN,
OP_CAST_BOOL,
OP_CAST_CHAR,
OP_CAST_OCTET,
OP_CAST_SHORT,
OP_CAST_USHORT,
OP_CAST_LONG,
OP_CAST_ULONG,
OP_CAST_FLOAT,
OP_CAST_DOUBLE,
OP_CAST_END,
//*******************
/* insert new unary ops before this line */ OP_IDENTITY,
// binary operations.
OP_MINUS, OP_PLUS, OP_DIV, OP_MULT,
OP_IS, OP_AND, OP_OR, OP_OVERLAY, OP_BIT, OP_XOR,
/* insert new binary ops before this line */
OP_EQUAL, OP_LESS, OP_LESSEQUAL,
OP_NOTEQUAL, OP_GREATER, OP_GREATEREQUAL
};
//@Man: methods for getting functions
//@{
/// get function object for unary operation.
static UnaryOp* getUnaryOp( Ops::OpType op, const BaseType* restype,
const BaseType* optype, unsigned int resOff = 0,
unsigned int opOff = 0 );
/*@Doc:
An \Ref{UnaryOp} carrying out #op# on the given types is
returned. If #op# is not applicable to the given types,
0 is returned.
*/
/// get function object for binary operation.
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 );
/*@Doc:
An \Ref{BinaryOp} carrying out #op# on the given types is
returned. If #op# is not applicable to the given types,
0 is returned.
*/
static CondenseOp* getCondenseOp( Ops::OpType op, const BaseType* resType,
const BaseType* opType = 0,
unsigned int resOff = 0,
unsigned int opOff = 0);
/// get function object for condense operation.
static CondenseOp* getCondenseOp( Ops::OpType op, const BaseType* resType,
char* newAccu, const BaseType* opType = 0,
unsigned int resOff = 0,
unsigned int opOff = 0 );
/*@Doc:
An \Ref{CondenseOp} carrying out #op# on the given types is
returned. If #op# is not applicable to the given types,
0 is returned.
*/
//@}
//@Man: methods for checking applicability of functions.
//@{
/// checks, if #op# is applicable on the given types.
static int isApplicable( Ops::OpType op, const BaseType* op1Type,
const BaseType* op2Type = 0 );
/*@Doc:
For unary or condense operations, just leave out #op2Type# (or
set it to 0).
*/
/// gives back suggested return type for #op# carried out on the given types.
static const BaseType* getResultType( Ops::OpType op, const BaseType* op1,
const BaseType* op2 = 0 );
/*@Doc:
This usually gives back the "stronger" type of #op1Type# or #op2Type#
(e.g. for a function like OP_PLUS). Usually the operation can also
be applied to another type, loosing information if the type is
"weaker". At the moment, only comparison operations (e.g. OP_EQUAL)
have a well defined return type, which is Bool. No other return type
can be used for these operations. If the operation is not applicable
to the given type, 0 is returned.
*/
/// executes operation on a constant.
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 two constants.
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 );
//@}
private:
/// checks, if #op# is applicable on two struct of type opType.
static int isApplicableOnStruct( Ops::OpType op, const BaseType* opType );
/*@ManMemo: checks, if #op# is applicable on struct of type op1Type
and value of type op2Type.*/
static int isApplicableOnStructConst( Ops::OpType op,
const BaseType* op1Type,
const BaseType* op2Type );
/// returns 1 for signed types, 0 for unsigned.
static int isSignedType( const BaseType* type );
// these functions aren't even used for the time being, but may
// be important for better implementations of isApplicable and
// getResultType.
static int isCondenseOp( Ops::OpType op );
static int isUnaryOp( Ops::OpType op );
static int isBinaryOp( Ops::OpType op );
};
//@ManMemo: Module: {\bf catalogif}.
/*@Doc:
CondenseOp is the superclass for all condense operations. The
operator() carries out a condense operation on one cell {\tt op},
which is accumulated into {\tt accu}. {\tt accu} is returned as a
result. Remember to always initialize {\tt accu} correctly according
to the condense operation used (e.g. 0 for \Ref{OpSOMEBool} or 1 for
\Ref{OpALLBool}).
*/
class CondenseOp
{
public:
/*@ManMemo: constructor gets RasDaMan base type of result and operand
and offsets to result and operand (for structs). */
CondenseOp( const BaseType* newResType, const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/*@ManMemo: constructor gets RasDaMan base type of result and operand,
initial value, and offsets to result and operand (for structs) . */
CondenseOp( const BaseType* newResType, char* newAccu, const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// operator to carry out operation on {\tt op}.
virtual char* operator()( const char* op, char* myAccu ) = 0;
/// operator to carry out operation on {\tt op} using internal accu.
virtual char* operator()( const char* op ) = 0;
/// operator to access value of internal accumulator.
virtual char* getAccuVal();
/*@ManMemo: virtual destructor because subclasse OpCondenseStruct has
non-trivial destructor. */
virtual ~CondenseOp();
protected:
char* accu;
const BaseType* opType;
const BaseType* resType;
unsigned int resOff;
unsigned int opOff;
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_SOME on C type #char#.
class OpSOMECChar : public CondenseOp
{
public:
/*@ManMemo: constructor gets RasDaMan base type of result and operand
and offsets to result and operand (for structs). */
OpSOMECChar( const BaseType* newResType, const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// constructor initializing internal accu.
OpSOMECChar( const BaseType* newResType, char* newAccu,
const BaseType* newOpType, unsigned int newResOff,
unsigned int newOpOff );
/// operator to carry out operation on {\tt op}.
virtual char* operator()( const char* op, char* myAccu );
/// operator to carry out operation on {\tt op} using internal accu.
virtual char* operator()( const char* op );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_ALL on C type #char#.
class OpALLCChar : public CondenseOp
{
public:
/*@ManMemo: constructor gets RasDaMan base type of result and operand
and offsets to result and operand (for structs). */
OpALLCChar( const BaseType* newResType, const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// constructor initializing internal accu.
OpALLCChar( const BaseType* newResType, char* newAccu,
const BaseType* newOpType, unsigned int newResOff,
unsigned int newOpOff );
/// operator to carry out operation on {\tt op}.
virtual char* operator()( const char* op, char* myAccu );
/// operator to carry out operation on {\tt op} using internal accu.
virtual char* operator()( const char* op );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_COUNT on C type #char#.
class OpCOUNTCChar : public CondenseOp
{
public:
/*@ManMemo: constructor gets RasDaMan base type of result and operand
and offsets to result and operand (for structs). */
OpCOUNTCChar( const BaseType* newResType, const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// constructor initializing internal accu.
OpCOUNTCChar( const BaseType* newResType, char* newAccu,
const BaseType* newOpType, unsigned int newResOff,
unsigned int newOpOff );
/// operator to carry out operation on {\tt op}.
virtual char* operator()( const char* op, char* myAccu );
/// operator to carry out operation on {\tt op} using internal accu.
virtual char* operator()( const char* op );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_MAX on C type #char#.
class OpMAXCULong : public CondenseOp
{
public:
/*@ManMemo: constructor gets RasDaMan base type of result and operand
and offsets to result and operand (for structs). */
OpMAXCULong( const BaseType* newResType, const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// constructor initializing internal accu.
OpMAXCULong( const BaseType* newResType, char* newAccu,
const BaseType* newOpType, unsigned int newResOff,
unsigned int newOpOff );
/// operator to carry out operation on {\tt op}.
virtual char* operator()( const char* op, char* myAccu );
/// operator to carry out operation on {\tt op} using internal accu.
virtual char* operator()( const char* op );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_MAX on C type #char#.
class OpMAXCLong : public CondenseOp
{
public:
/*@ManMemo: constructor gets RasDaMan base type of result and operand
and offsets to result and operand (for structs). */
OpMAXCLong( const BaseType* newResType, const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// constructor initializing internal accu.
OpMAXCLong( const BaseType* newResType, char* newAccu,
const BaseType* newOpType, unsigned int newResOff,
unsigned int newOpOff );
/// operator to carry out operation on {\tt op}.
virtual char* operator()( const char* op, char* myAccu );
/// operator to carry out operation on {\tt op} using internal accu.
virtual char* operator()( const char* op );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_MAX on C type #char#.
class OpMAXCDouble : public CondenseOp
{
public:
/*@ManMemo: constructor gets RasDaMan base type of result and operand
and offsets to result and operand (for structs). */
OpMAXCDouble( const BaseType* newResType, const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// constructor initializing internal accu.
OpMAXCDouble( const BaseType* newResType, char* newAccu,
const BaseType* newOpType, unsigned int newResOff,
unsigned int newOpOff );
/// operator to carry out operation on {\tt op}.
virtual char* operator()( const char* op, char* myAccu );
/// operator to carry out operation on {\tt op} using internal accu.
virtual char* operator()( const char* op );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_MIN on C type #char#.
class OpMINCULong : public CondenseOp
{
public:
/*@ManMemo: constructor gets RasDaMan base type of result and operand
and offsets to result and operand (for structs). */
OpMINCULong( const BaseType* newResType, const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// constructor initializing internal accu.
OpMINCULong( const BaseType* newResType, char* newAccu,
const BaseType* newOpType, unsigned int newResOff,
unsigned int newOpOff );
/// operator to carry out operation on {\tt op}.
virtual char* operator()( const char* op, char* myAccu );
/// operator to carry out operation on {\tt op} using internal accu.
virtual char* operator()( const char* op );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_MIN on C type #char#.
class OpMINCLong : public CondenseOp
{
public:
/*@ManMemo: constructor gets RasDaMan base type of result and operand
and offsets to result and operand (for structs). */
OpMINCLong( const BaseType* newResType, const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// constructor initializing internal accu.
OpMINCLong( const BaseType* newResType, char* newAccu,
const BaseType* newOpType, unsigned int newResOff,
unsigned int newOpOff );
/// operator to carry out operation on {\tt op}.
virtual char* operator()( const char* op, char* myAccu );
/// operator to carry out operation on {\tt op} using internal accu.
virtual char* operator()( const char* op );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_MIN on C type #char#.
class OpMINCDouble : public CondenseOp
{
public:
/*@ManMemo: constructor gets RasDaMan base type of result and operand
and offsets to result and operand (for structs). */
OpMINCDouble( const BaseType* newResType, const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// constructor initializing internal accu.
OpMINCDouble( const BaseType* newResType, char* newAccu,
const BaseType* newOpType, unsigned int newResOff,
unsigned int newOpOff );
/// operator to carry out operation on {\tt op}.
virtual char* operator()( const char* op, char* myAccu );
/// operator to carry out operation on {\tt op} using internal accu.
virtual char* operator()( const char* op );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_SUM on C type #char#.
class OpSUMCULong : public CondenseOp
{
public:
/*@ManMemo: constructor gets RasDaMan base type of result and operand
and offsets to result and operand (for structs). */
OpSUMCULong(const BaseType* newResType,const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// constructor initializing internal accu.
OpSUMCULong(const BaseType* newResType, char* newAccu,
const BaseType* newOpType, unsigned int newResOff,
unsigned int newOpOff );
/// operator to carry out operation on {\tt op}.
virtual char* operator()( const char* op, char* myAccu );
/// operator to carry out operation on {\tt op} using internal accu.
virtual char* operator()( const char* op );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_SUM on C type #char#.
class OpSUMCLong : public CondenseOp
{
public:
/*@ManMemo: constructor gets RasDaMan base type of result and operand
and offsets to result and operand (for structs). */
OpSUMCLong(const BaseType* newResType,const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// constructor initializing internal accu.
OpSUMCLong(const BaseType* newResType, char* newAccu,
const BaseType* newOpType, unsigned int newResOff,
unsigned int newOpOff );
/// operator to carry out operation on {\tt op}.
virtual char* operator()( const char* op, char* myAccu );
/// operator to carry out operation on {\tt op} using internal accu.
virtual char* operator()( const char* op );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_SUM on C type #char#.
class OpSUMCDouble : public CondenseOp
{
public:
/*@ManMemo: constructor gets RasDaMan base type of result and operand
and offsets to result and operand (for structs). */
OpSUMCDouble(const BaseType* newResType,const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// constructor initializing internal accu.
OpSUMCDouble(const BaseType* newResType, char* newAccu,
const BaseType* newOpType, unsigned int newResOff,
unsigned int newOpOff );
/// operator to carry out operation on {\tt op}.
virtual char* operator()( const char* op, char* myAccu );
/// operator to carry out operation on {\tt op} using internal accu.
virtual char* operator()( const char* op );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: Class for carrying out condense operations on structs.
// Inherits some useless members from CondenseOp, don't want to
// change this now.
class OpCondenseStruct : public CondenseOp
{
public:
/// constructor gets struct type.
OpCondenseStruct(
const BaseType* newResType,
const BaseType* newOpType,
Ops::OpType op,
unsigned int newResOff = 0, unsigned int newOpOff = 0
);
/// constructor gets struct type and initial value for internal accu.
OpCondenseStruct(
const BaseType* newResType,
char* newAccu,
const BaseType* newOpType,
Ops::OpType op,
unsigned int newResOff,
unsigned int newOpOff
);
/// destructor.
virtual ~OpCondenseStruct();
/// operator to carry out operation on struct {\tt op}.
virtual char* operator()( const char* op, char* myAccu );
/// operator to carry out operation on struct {\tt op} using internal accu.
virtual char* operator()( const char* op );
protected:
StructType* myResType;
StructType* myOpType;
unsigned int numElems;
// array of operations on the elements.
CondenseOp** elemOps;
};
//@ManMemo: Module: {\bf catalogif}.
/*@Doc:
UnaryOp is the superclass for all unary operations. The
operator() carries out a unary operation on one cell {\tt op} and
stores the result in the cell {\tt result}.
*/
class UnaryOp
{
public:
/*@ManMemo: constructor gets RasDaMan base type of result and operand
and offsets to result and operand (for structs). */
UnaryOp(const BaseType* newResType,const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// operator to carry out operation on {\tt op}.
virtual void operator()( char* result, const char* op ) = 0;
/*@ManMemo: virtual destructor because subclasse OpUnaryStruct has
non-trivial destructor. */
virtual ~UnaryOp() { };
protected:
const BaseType* opType;
const BaseType* resType;
unsigned int resOff;
unsigned int opOff;
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: Class for carrying out binary operations on structs.
// Inherits some useless members from UnaryOp, don't want to
// change this now.
class OpUnaryStruct : public UnaryOp
{
public:
/// constructor gets struct type.
OpUnaryStruct(
const BaseType* newResType,
const BaseType* newOpType,
Ops::OpType op,
unsigned int newResOff = 0,
unsigned int newOpOff = 0
);
/// destructor.
virtual ~OpUnaryStruct();
/// operator to carry out operation on struct {\tt op}.
virtual void operator()( char* result, const char* op );
protected:
StructType* myResType;
StructType* myOpType;
unsigned int numElems;
// array of operations on the elements.
UnaryOp** elemOps;
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_IDENTITY on structs. Works, if struct types are identical.
class OpIDENTITYStruct : public UnaryOp
{
public:
/// constructor gets RasDaMan base type of result and operand.
OpIDENTITYStruct(const BaseType* newResType,const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// operator to carry out operation on {\tt op} with result {\tt result}.
virtual void operator()( char* result, const char* op );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_NOT on C type #unsigned long#, result #unsigned long#.
class OpNOTCULong : public UnaryOp
{
public:
/// constructor gets RasDaMan base type of result and operand.
OpNOTCULong(const BaseType* newResType,const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// operator to carry out operation on {\tt op} with result {\tt result}.
virtual void operator()( char* result, const char* op );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_IDENTITY on C type #unsigned long#, result #unsigned long#.
class OpIDENTITYCULong : public UnaryOp
{
public:
/// constructor gets RasDaMan base type of result and operand.
OpIDENTITYCULong(const BaseType* newResType,const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// operator to carry out operation on {\tt op} with result {\tt result}.
virtual void operator()( char* result, const char* op );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_NOT on C type #unsigned long#, result #unsigned long#.
class OpNOTCLong : public UnaryOp
{
public:
/// constructor gets RasDaMan base type of result and operand.
OpNOTCLong(const BaseType* newResType,const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// operator to carry out operation on {\tt op} with result {\tt result}.
virtual void operator()( char* result, const char* op );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_NOT on Bools (logical NOT as opposed to bitwise NOT).
class OpNOTBool : public UnaryOp
{
public:
/// constructor gets RasDaMan base type of result and operand.
OpNOTBool(const BaseType* newResType,const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// operator to carry out operation on {\tt op} with result {\tt result}.
virtual void operator()( char* result, const char* op );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_IDENTITY on C type #unsigned long#, result #unsigned long#.
class OpIDENTITYCLong : public UnaryOp
{
public:
/// constructor gets RasDaMan base type of result and operand.
OpIDENTITYCLong(const BaseType* newResType,const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// operator to carry out operation on {\tt op} with result {\tt result}.
virtual void operator()( char* result, const char* op );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_IDENTITY on C type #unsigned long#, result #unsigned long#.
class OpIDENTITYCDouble : public UnaryOp
{
public:
/// constructor gets RasDaMan base type of result and operand.
OpIDENTITYCDouble(const BaseType* newResType,const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// operator to carry out operation on {\tt op} with result {\tt result}.
virtual void operator()( char* result, const char* op );
};
//@ManMemo: Module: {\bf catalogif}.
/*@Doc:
BinaryOp is the superclass for all binary operations. The operator()
carries out a binary operation on cells {\tt op1} and {\tt op2}. The
result is stored in the cell {\tt res}.
*/
class BinaryOp
{
public:
/*@ManMemo: constructor gets RasDaMan base type of result and operands
and offsets to result and operands (for structs). */
BinaryOp(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 ) = 0;
/// returns initialization value for {\ref GenCondenseOp}.
virtual void getCondenseInit(char* init);
/*@ManMemo: virtual destructor because subclasse OpBinaryStruct has
non-trivial destructor. */
virtual ~BinaryOp() { };
protected:
const BaseType* op1Type;
const BaseType* op2Type;
const BaseType* resType;
unsigned int resOff;
unsigned int op1Off;
unsigned int op2Off;
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: Class for carrying out binary operations on structs.
// Inherits some useless members from BinaryOp, don't want to
// change this now.
class OpBinaryStruct : public BinaryOp
{
public:
/// constructor gets struct type.
OpBinaryStruct(const BaseType* newStructType, Ops::OpType op,
unsigned int newResOff = 0, unsigned int newOp1Off = 0,
unsigned int newOp2Off = 0 );
/// destructor.
virtual ~OpBinaryStruct();
/// operator to carry out operation on struct {\tt op}.
virtual void operator()( char* res, const char* op1,
const char* op2 );
protected:
StructType* myStructType;
unsigned int numElems;
// array of operations on the elements.
BinaryOp** elemOps;
};
//@ManMemo: Module: {\bf catalogif}.
/*@Doc: Class for carrying out binary operations on structs where the
second operand is a value. */
class OpBinaryStructConst : public BinaryOp
{
public:
/// constructor gets struct type.
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 );
/// destructor.
virtual ~OpBinaryStructConst();
/// operator to carry out operation on struct {\tt op}.
virtual void operator()( char* res, const char* op1,
const char* op2 );
protected:
StructType* resStructType;
StructType* opStructType;
unsigned int numElems;
// array of operations on the elements.
BinaryOp** elemOps;
};
//@ManMemo: Module: {\bf catalogif}.
/*@Doc: Class for carrying out binary operations on structs where the
first operand is a value. */
class OpBinaryConstStruct : public BinaryOp
{
public:
/// constructor gets struct type.
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 );
/// destructor.
virtual ~OpBinaryConstStruct();
/// operator to carry out operation on struct {\tt op}.
virtual void operator()( char* res, const char* op1,
const char* op2 );
protected:
StructType* resStructType;
StructType* opStructType;
unsigned int numElems;
// array of operations on the elements.
BinaryOp** elemOps;
};
class OpEQUALStruct : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpEQUALStruct(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/// destructor.
virtual ~OpEQUALStruct();
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
protected:
unsigned int numElems;
// array of operations on the elements.
BinaryOp** elemOps;
};
class OpNOTEQUALStruct : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpNOTEQUALStruct(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0,
unsigned int newOp2Off = 0 );
/// destructor.
virtual ~OpNOTEQUALStruct();
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
protected:
unsigned int numElems;
// array of operations on the elements.
BinaryOp** elemOps;
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_PLUS on C type #unsigned long# and #unsigned long#, result #unsigned long#.
class OpPLUSCULong : public BinaryOp
{
public:
/// 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 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
virtual void getCondenseInit(char* init);
};
class OpPLUSULong : public BinaryOp
{
public:
/// 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 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
virtual void getCondenseInit(char* init);
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_MINUS on C type #unsigned long# and #unsigned long#, result #unsigned long#.
class OpMINUSCULong : public BinaryOp
{
public:
/// 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 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_DIV on C type #unsigned long# and #unsigned long#, result #unsigned long#.
class OpDIVCULong : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpDIVCULong(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_MULT on C type #unsigned long# and #unsigned long#, result #unsigned long#.
class OpMULTCULong : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpMULTCULong(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
virtual void getCondenseInit(char* init);
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_AND on C type #unsigned long# and #unsigned long#, result #unsigned long#.
class OpANDCULong : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpANDCULong(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
virtual void getCondenseInit(char* init);
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_AND on Bools (logical as opposed to bitwise)
class OpANDBool : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpANDBool(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
virtual void getCondenseInit(char* init);
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_OR on C type #unsigned long# and #unsigned long#, result #unsigned long#.
class OpORCULong : public BinaryOp
{
public:
/// 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 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
virtual void getCondenseInit(char* init);
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_OR on Bools (logical as opposed to bitwise)
class OpORBool : public BinaryOp
{
public:
/// 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 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
virtual void getCondenseInit(char* init);
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_XOR on C type #unsigned long# and #unsigned long#, result #unsigned long#.
class OpXORCULong : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpXORCULong(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_XOR on Bools (logical as opposed to bitwise)
class OpXORBool : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpXORBool(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_PLUS on C type #long# and #long#, result #long#.
class OpPLUSCLong : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpPLUSCLong(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
virtual void getCondenseInit(char* init);
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_MINUS on C type #long# and #long#, result #long#.
class OpMINUSCLong : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpMINUSCLong(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_DIV on C type #long# and #long#, result #long#.
class OpDIVCLong : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpDIVCLong(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_MULT on C type #long# and #long#, result #long#.
class OpMULTCLong : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpMULTCLong(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
virtual void getCondenseInit(char* init);
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_AND on C type #long# and #long#, result #long#.
class OpANDCLong : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpANDCLong(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
virtual void getCondenseInit(char* init);
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_OR on C type #long# and #long#, result #long#.
class OpORCLong : public BinaryOp
{
public:
/// 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 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
virtual void getCondenseInit(char* init);
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_XOR on C type #long# and #long#, result #long#.
class OpXORCLong : public BinaryOp
{
public:
/// 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 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_PLUS on C type #double# and #double#, result #double#.
class OpPLUSCDouble : public BinaryOp
{
public:
/// 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 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
virtual void getCondenseInit(char* init);
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_MINUS on C type #double# and #double#, result #double#.
class OpMINUSCDouble : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpMINUSCDouble(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_DIV on C type #double# and #double#, result #double#.
class OpDIVCDouble : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpDIVCDouble(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_MULT on C type #double# and #double#, result #double#.
class OpMULTCDouble : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpMULTCDouble(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
virtual void getCondenseInit(char* init);
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_EQUAL on C type #unsigned long# and #unsigned long#, result #char#.
class OpEQUALCCharCULong : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpEQUALCCharCULong(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_LESS on C type #unsigned long# and #unsigned long#, result #char#.
class OpLESSCCharCULong : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpLESSCCharCULong(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_LESSEQUAL on C type #unsigned long# and #unsigned long#, result #char#.
class OpLESSEQUALCCharCULong : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpLESSEQUALCCharCULong(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0,
unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_NOTEQUAL on C type #unsigned long# and #unsigned long#, result #char#.
class OpNOTEQUALCCharCULong : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpNOTEQUALCCharCULong(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0,
unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_GREATER on C type #unsigned long# and #unsigned long#, result #char#.
class OpGREATERCCharCULong : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpGREATERCCharCULong(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0,
unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_GREATEREQUAL on \Ref{ULong} and \Ref{ULong}, result \Ref{Bool}.
class OpGREATEREQUALCCharCULong : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpGREATEREQUALCCharCULong(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0,
unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_EQUAL on C type #unsigned long# and #unsigned long#, result #char#.
class OpEQUALCCharCLong : public BinaryOp
{
public:
/// 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 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_LESS on C type #long# and #long#, result #char#.
class OpLESSCCharCLong : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpLESSCCharCLong(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_LESSEQUAL on C type #long# and #long#, result #char#.
class OpLESSEQUALCCharCLong : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpLESSEQUALCCharCLong(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0,
unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_NOTEQUAL on C type #long# and #long#, result #char#.
class OpNOTEQUALCCharCLong : public BinaryOp
{
public:
/// 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 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_GREATER on C type #long# and #long#, result #char#.
class OpGREATERCCharCLong : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpGREATERCCharCLong(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0,
unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_GREATEREQUAL on C type #long# and #long#, result #char#.
class OpGREATEREQUALCCharCLong : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpGREATEREQUALCCharCLong(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0,
unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_EQUAL on C type #double# and #double#, result #char#.
class OpEQUALCCharCDouble : public BinaryOp
{
public:
/// 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 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_LESS on C type #double# and #double#, result #char#.
class OpLESSCCharCDouble : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpLESSCCharCDouble(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_LESSEQUAL on C type #double# and #double#, result #char#.
class OpLESSEQUALCCharCDouble : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpLESSEQUALCCharCDouble(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0,
unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_NOTEQUAL on C type #double# and #double#, result #char#.
class OpNOTEQUALCCharCDouble : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpNOTEQUALCCharCDouble(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0,
unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_GREATER on C type #double# and #double#, result #char#.
class OpGREATERCCharCDouble : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpGREATERCCharCDouble(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0,
unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_GREATEREQUAL on C type #double# and #double#, result #char#.
class OpGREATEREQUALCCharCDouble : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpGREATEREQUALCCharCDouble(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0,
unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_PLUS specialized for RasDaMan type Char.
class OpPLUSChar : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpPLUSChar(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
virtual void getCondenseInit(char* init);
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_MINUS specialized for RasDaMan type Char.
class OpMINUSChar : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpMINUSChar(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_MULT specialized for RasDaMan type Char.
class OpMULTChar : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpMULTChar(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
virtual void getCondenseInit(char* init);
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_DIV specialized for RasDaMan type Char.
class OpDIVChar : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpDIVChar(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_EQUAL specialized for RasDaMan type Char.
class OpEQUALChar : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpEQUALChar(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_LESS specialized for RasDaMan type Char.
class OpLESSChar : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpLESSChar(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0, unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_LESSEQUAL specialized for RasDaMan type Char.
class OpLESSEQUALChar : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpLESSEQUALChar(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0,
unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_NOTEQUAL specialized for RasDaMan type Char.
class OpNOTEQUALChar : public BinaryOp
{
public:
/// 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 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_GREATER specialized for RasDaMan type Char.
class OpGREATERChar : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpGREATERChar(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0,
unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_GREATEREQUAL specialized for RasDaMan type Char.
class OpGREATEREQUALChar : public BinaryOp
{
public:
/// constructor gets RasDaMan base type of result and operands.
OpGREATEREQUALChar(const BaseType* newResType,const BaseType* newOp1Type,
const BaseType* newOp2Type, unsigned int newResOff = 0,
unsigned int newOp1Off = 0,
unsigned int newOp2Off = 0 );
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1,
const char* op2 );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_IDENTITY specialized for RasDaMan type Char.
class OpIDENTITYChar : public UnaryOp
{
public:
/// constructor gets RasDaMan base type of result and operand.
OpIDENTITYChar(const BaseType* newResType,const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// operator to carry out operation on {\tt op} with result {\tt result}.
virtual void operator()( char* result, const char* op );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_IDENTITY specialized for RasDaMan type Short.
class OpIDENTITYShort : public UnaryOp
{
public:
/// constructor gets RasDaMan base type of result and operand.
OpIDENTITYShort(const BaseType* newResType,const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// operator to carry out operation on {\tt op} with result {\tt result}.
virtual void operator()( char* result, const char* op );
};
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_IDENTITY specialized for RasDaMan type Long.
class OpIDENTITYLong : public UnaryOp
{
public:
/// constructor gets RasDaMan base type of result and operand.
OpIDENTITYLong(const BaseType* newResType,const BaseType* newOpType,
unsigned int newResOff = 0, unsigned int newOpOff = 0 );
/// operator to carry out operation on {\tt op} with result {\tt result}.
virtual void operator()( char* result, const char* op );
};
//@ManMemo: Module: {\bf catalogif}.
/*@Doc:
MarrayOp is the superclass for all marray constructors. The class
defined here is just a dummy and will be specialized in another
module. operator() gets an r_Point as a parameter. For a useful
marray constructor operation() will also need to calculate an
expression.
*/
class MarrayOp
{
public:
/*@ManMemo: constructor gets RasDaMan base type of result and its
offset (for structs). Subclasses will have additional parameters. */
MarrayOp(const BaseType* newResType, unsigned int newResOff = 0 );
/// operator to carry out operation on {\tt p}. Has a dummy implementation.
virtual void operator() ( char* result, const r_Point& p );
/*@ManMemo: virtual destructor because subclasses may have
non-trivial destructor. */
virtual ~MarrayOp() { };
protected:
const BaseType* resType;
unsigned int resOff;
};
//@ManMemo: Module: {\bf catalogif}.
/*@Doc:
GenCondenseOp is the superclass for all general condense operations.
The class defined here is just a dummy and will be specialized in
another module. operator() gets an r_Point as a parameter. For a useful
marray constructor operation() will also need to calculate an
expression. Every GenCondenseOp has a binary operation which is
used to accumulate the values. If an initVal (of type resType)
is given, it is used as a basis for accumulation. Otherwist a
default initVal is retrieved from {\tt accuOp}.
*/
class GenCondenseOp
{
public:
/*@ManMemo: constructor gets RasDaMan base type of result and its
offset (for structs, 0 if no struct). A binary operation for
accumulation is given and an optional init value. Subclasses
will have additional parameters. Note that newInitVal has to be
deleted by the caller! */
GenCondenseOp(const BaseType* newResType, unsigned int newResOff,
BinaryOp* newAccuOp, char* newInitVal = 0 );
/// operator to carry out operation on {\tt p}. Has a dummy implementation.
virtual void operator()( const r_Point& p );
/// returns binary accumulation op (needed in class {\ref Tile}.
BinaryOp* getAccuOp();
/// returns result type (needed in class {\ref Tile}.
const BaseType* getResultType();
/// returns result offset (needed in class {\ref Tile}.
unsigned int getResultOff();
/// returns accumulated result.
char* getAccuVal();
/*@ManMemo: virtual destructor because subclasses may have
non-trivial destructor. */
virtual ~GenCondenseOp();
protected:
const BaseType* resType;
unsigned int resOff;
BinaryOp* accuOp;
// initVal is always of RasDaMan-Type restype!
char* initVal;
// used to flag if destructor should delete initVal
int myInitVal;
};
//--------------------------------------------
// Complex operations
//--------------------------------------------
class OpPLUSComplex : public BinaryOp {
public:
// Question: which operand is scalar?
// Answere: NONE, FIRST, SECOND
enum ScalarFlag { NONE, FIRST, SECOND};
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 void getCondenseInit(char* init);
protected:
unsigned int op1ReOff;
unsigned int op1ImOff;
unsigned int op2ReOff;
unsigned int op2ImOff;
unsigned int resReOff;
unsigned int resImOff;
ScalarFlag scalarFlag;
};
class OpMINUSComplex : public BinaryOp {
public:
// Question: which operand is scalar?
// Answere: NONE, FIRST, SECOND
enum ScalarFlag { NONE, FIRST, SECOND};
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 void operator()(char* res, const char* op1, const char* op2);
protected:
unsigned int op1ReOff;
unsigned int op1ImOff;
unsigned int op2ReOff;
unsigned int op2ImOff;
unsigned int resReOff;
unsigned int resImOff;
ScalarFlag scalarFlag;
};
class OpDIVComplex : public BinaryOp {
public:
// Question: which operand is scalar?
// Answere: NONE, FIRST, SECOND
enum ScalarFlag { NONE, FIRST, SECOND};
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 void operator()( char* res, const char* op1, const char* op2 );
protected:
unsigned int op1ReOff;
unsigned int op1ImOff;
unsigned int op2ReOff;
unsigned int op2ImOff;
unsigned int resReOff;
unsigned int resImOff;
ScalarFlag scalarFlag;
};
class OpMULTComplex : public BinaryOp {
public:
// Question: which operand is scalar?
// Answere: NONE, FIRST, SECOND
enum ScalarFlag { NONE, FIRST, SECOND};
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
);
virtual void operator()( char* res, const char* op1, const char* op2 );
virtual void getCondenseInit(char* init);
protected:
unsigned int op1ReOff;
unsigned int op1ImOff;
unsigned int op2ReOff;
unsigned int op2ImOff;
unsigned int resReOff;
unsigned int resImOff;
ScalarFlag scalarFlag;
};
class OpIDENTITYComplex : public UnaryOp {
public:
OpIDENTITYComplex(const BaseType* , const BaseType* , unsigned int = 0, unsigned int = 0);
virtual void operator()(char* result, const char* op);
};
class OpRealPart : public UnaryOp {
public:
OpRealPart(
const BaseType* newResType,
const BaseType* newOpType,
unsigned int newResOff = 0,
unsigned int newOpOff = 0
);
virtual void operator() (char* result, const char* op);
private:
unsigned int opReOff;
};
class OpImaginarPart : public UnaryOp {
public:
OpImaginarPart(
const BaseType* newResType,
const BaseType* newOpType,
unsigned int newResOff = 0,
unsigned int newOpOff = 0
);
virtual void operator() (char* result, const char* op);
private:
unsigned int opImOff;
};
//--------------------------------------------
// OpCAST
//--------------------------------------------
/*@Doc:
OpCAST provide cast operation.
*/
class OpCAST : public UnaryOp {
public:
OpCAST(
const BaseType* newResType,
const BaseType* newOpType,
unsigned int newResOff = 0,
unsigned int newOpOff = 0
);
/// operator to carry out cast operation.
virtual void operator() (char* result, const char* op);
};
//--------------------------------------------
// OpOVERLAY
//--------------------------------------------
//@ManMemo: Module: {\bf catalogif}.
//@Doc: OP_OVERLAY
class OpOVERLAY : public BinaryOp
{
public:
/// this pattern is only 16 bytes long and empty, if your struct is longer you need to supply your own pattern
static const char* nullPattern;
/// constructor gets RasDaMan base type of result and operands.
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);
/*@ManMemo: operator to carry out operation on {\tt op1} and
{\tt op2} with result {\tt res}. */
virtual void operator()( char* res, const char* op1, const char* op2 );
private:
size_t length;
const char* pattern;
};
//--------------------------------------------
// OpBIT
//--------------------------------------------
/*@Doc:
*/
class OpBIT : public BinaryOp {
public:
OpBIT(
const BaseType* newResType,
const BaseType* newOp1Type,
const BaseType* newOp2Type,
unsigned int newResOff = 0,
unsigned int newOp1Off = 0,
unsigned int newOp2Off = 0
);
/// operator to carry out bit operation
virtual void operator()(char* res, const char* op1, const char* op2);
};
#include "autogen_ops.hh"
#endif
// LocalWords: op