/*
* 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 .
*/
/*************************************************************
*
*
* COMMENTS: Automaticaly generated
*
************************************************************/
const QtNode::QtNodeType QtAbs::nodeType = QtNode::QT_ABS;
QtAbs::QtAbs(QtOperation* initInput): QtUnaryInduce(initInput) {}
QtData* QtAbs::evaluate(QtDataList* inputList) {
QtData* returnValue = NULL;
QtData* operand = NULL;
if(getOperand(inputList, operand)) {
try {
returnValue = computeOp( operand, Ops::OP_ABS );
}
catch(...) {
operand->deleteRef();
throw;
}
}
// delete old operand
if(operand) operand->deleteRef();
return returnValue;
}
void QtAbs::printTree(int tab, ostream& s, QtChildType mode) {
s << SPACE_STR(tab).c_str() << "QtAbsObject " << getNodeType() << endl;
QtUnaryInduce::printTree( tab + 2, s, mode );
}
void QtAbs::printAlgebraicExpression(ostream& s) {
s << "abs(";
if(input)
input->printAlgebraicExpression(s);
else
s << "";
s << ")";
}
const QtTypeElement& QtAbs::checkType(QtTypeTuple* typeTuple) {
RMDBCLASS( "QtAbs", "checkType( QtTypeTuple* )", "qlparser", __FILE__, __LINE__ )
dataStreamType.setDataType( QT_TYPE_UNKNOWN );
// check operand branches
if(input) {
// get input types
const QtTypeElement& inputType = input->checkType( typeTuple );
RMDBGIF( 4, RMDebug::module_qlparser, "AutoGen", \
RMInit::dbgOut << "Operand: " << flush; \
inputType.printStatus( RMInit::dbgOut ); \
RMInit::dbgOut << endl; \
)
if(inputType.getDataType() == QT_MDD) {
const BaseType* baseType = ((MDDBaseType*)(inputType.getType()))->getBaseType();
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_ABS, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtAbs::checkType() - induce operand type is not support" << endl;
parseInfo.setErrorNo(366);
throw parseInfo;
}
MDDBaseType* resultMDDType = new MDDBaseType( "tmp", resultBaseType );
TypeFactory::addTempType( resultMDDType );
dataStreamType.setType( resultMDDType );
}
else if(inputType.isBaseType()) {
BaseType* baseType = (BaseType*)(inputType.getType());
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_ABS, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtAbs::checkType() - operand type is not supported." << endl;
parseInfo.setErrorNo(367);
throw parseInfo;
}
dataStreamType.setType( resultBaseType );
}
else {
RMInit::logOut << "Error: QtAbs::checkType() - operation is not supported for strings." << endl;
parseInfo.setErrorNo(385);
throw parseInfo;
}
}
else
RMInit::logOut << "Error: QtAbs::checkType() - operand branch invalid." << endl;
return dataStreamType;
}
const QtNode::QtNodeType QtSqrt::nodeType = QtNode::QT_SQRT;
QtSqrt::QtSqrt(QtOperation* initInput): QtUnaryInduce(initInput) {}
QtData* QtSqrt::evaluate(QtDataList* inputList) {
QtData* returnValue = NULL;
QtData* operand = NULL;
if(getOperand(inputList, operand)) {
try {
returnValue = computeOp( operand, Ops::OP_SQRT );
}
catch(...) {
operand->deleteRef();
throw;
}
}
// delete old operand
if(operand) operand->deleteRef();
return returnValue;
}
void QtSqrt::printTree(int tab, ostream& s, QtChildType mode) {
s << SPACE_STR(tab).c_str() << "QtSqrtObject " << getNodeType() << endl;
QtUnaryInduce::printTree( tab + 2, s, mode );
}
void QtSqrt::printAlgebraicExpression(ostream& s) {
s << "sqrt(";
if(input)
input->printAlgebraicExpression(s);
else
s << "";
s << ")";
}
const QtTypeElement& QtSqrt::checkType(QtTypeTuple* typeTuple) {
RMDBCLASS( "QtSqrt", "checkType( QtTypeTuple* )", "qlparser", __FILE__, __LINE__ )
dataStreamType.setDataType( QT_TYPE_UNKNOWN );
// check operand branches
if(input) {
// get input types
const QtTypeElement& inputType = input->checkType( typeTuple );
RMDBGIF( 4, RMDebug::module_qlparser, "AutoGen", \
RMInit::dbgOut << "Operand: " << flush; \
inputType.printStatus( RMInit::dbgOut ); \
RMInit::dbgOut << endl; \
)
if(inputType.getDataType() == QT_MDD) {
const BaseType* baseType = ((MDDBaseType*)(inputType.getType()))->getBaseType();
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_SQRT, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtSqrt::checkType() - induce operand type is not support" << endl;
parseInfo.setErrorNo(366);
throw parseInfo;
}
MDDBaseType* resultMDDType = new MDDBaseType( "tmp", resultBaseType );
TypeFactory::addTempType( resultMDDType );
dataStreamType.setType( resultMDDType );
}
else if(inputType.isBaseType()) {
BaseType* baseType = (BaseType*)(inputType.getType());
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_SQRT, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtSqrt::checkType() - operand type is not supported." << endl;
parseInfo.setErrorNo(367);
throw parseInfo;
}
dataStreamType.setType( resultBaseType );
}
else {
RMInit::logOut << "Error: QtSqrt::checkType() - operation is not supported for strings." << endl;
parseInfo.setErrorNo(385);
throw parseInfo;
}
}
else
RMInit::logOut << "Error: QtSqrt::checkType() - operand branch invalid." << endl;
return dataStreamType;
}
const QtNode::QtNodeType QtExp::nodeType = QtNode::QT_EXP;
QtExp::QtExp(QtOperation* initInput): QtUnaryInduce(initInput) {}
QtData* QtExp::evaluate(QtDataList* inputList) {
QtData* returnValue = NULL;
QtData* operand = NULL;
if(getOperand(inputList, operand)) {
try {
returnValue = computeOp( operand, Ops::OP_EXP );
}
catch(...) {
operand->deleteRef();
throw;
}
}
// delete old operand
if(operand) operand->deleteRef();
return returnValue;
}
void QtExp::printTree(int tab, ostream& s, QtChildType mode) {
s << SPACE_STR(tab).c_str() << "QtExpObject " << getNodeType() << endl;
QtUnaryInduce::printTree( tab + 2, s, mode );
}
void QtExp::printAlgebraicExpression(ostream& s) {
s << "exp(";
if(input)
input->printAlgebraicExpression(s);
else
s << "";
s << ")";
}
const QtTypeElement& QtExp::checkType(QtTypeTuple* typeTuple) {
RMDBCLASS( "QtExp", "checkType( QtTypeTuple* )", "qlparser", __FILE__, __LINE__ )
dataStreamType.setDataType( QT_TYPE_UNKNOWN );
// check operand branches
if(input) {
// get input types
const QtTypeElement& inputType = input->checkType( typeTuple );
RMDBGIF( 4, RMDebug::module_qlparser, "AutoGen", \
RMInit::dbgOut << "Operand: " << flush; \
inputType.printStatus( RMInit::dbgOut ); \
RMInit::dbgOut << endl; \
)
if(inputType.getDataType() == QT_MDD) {
const BaseType* baseType = ((MDDBaseType*)(inputType.getType()))->getBaseType();
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_EXP, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtExp::checkType() - induce operand type is not support" << endl;
parseInfo.setErrorNo(366);
throw parseInfo;
}
MDDBaseType* resultMDDType = new MDDBaseType( "tmp", resultBaseType );
TypeFactory::addTempType( resultMDDType );
dataStreamType.setType( resultMDDType );
}
else if(inputType.isBaseType()) {
BaseType* baseType = (BaseType*)(inputType.getType());
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_EXP, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtExp::checkType() - operand type is not supported." << endl;
parseInfo.setErrorNo(367);
throw parseInfo;
}
dataStreamType.setType( resultBaseType );
}
else {
RMInit::logOut << "Error: QtExp::checkType() - operation is not supported for strings." << endl;
parseInfo.setErrorNo(385);
throw parseInfo;
}
}
else
RMInit::logOut << "Error: QtExp::checkType() - operand branch invalid." << endl;
return dataStreamType;
}
const QtNode::QtNodeType QtLog::nodeType = QtNode::QT_LOG;
QtLog::QtLog(QtOperation* initInput): QtUnaryInduce(initInput) {}
QtData* QtLog::evaluate(QtDataList* inputList) {
QtData* returnValue = NULL;
QtData* operand = NULL;
if(getOperand(inputList, operand)) {
try {
returnValue = computeOp( operand, Ops::OP_LOG );
}
catch(...) {
operand->deleteRef();
throw;
}
}
// delete old operand
if(operand) operand->deleteRef();
return returnValue;
}
void QtLog::printTree(int tab, ostream& s, QtChildType mode) {
s << SPACE_STR(tab).c_str() << "QtLogObject " << getNodeType() << endl;
QtUnaryInduce::printTree( tab + 2, s, mode );
}
void QtLog::printAlgebraicExpression(ostream& s) {
s << "log(";
if(input)
input->printAlgebraicExpression(s);
else
s << "";
s << ")";
}
const QtTypeElement& QtLog::checkType(QtTypeTuple* typeTuple) {
RMDBCLASS( "QtLog", "checkType( QtTypeTuple* )", "qlparser", __FILE__, __LINE__ )
dataStreamType.setDataType( QT_TYPE_UNKNOWN );
// check operand branches
if(input) {
// get input types
const QtTypeElement& inputType = input->checkType( typeTuple );
RMDBGIF( 4, RMDebug::module_qlparser, "AutoGen", \
RMInit::dbgOut << "Operand: " << flush; \
inputType.printStatus( RMInit::dbgOut ); \
RMInit::dbgOut << endl; \
)
if(inputType.getDataType() == QT_MDD) {
const BaseType* baseType = ((MDDBaseType*)(inputType.getType()))->getBaseType();
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_LOG, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtLog::checkType() - induce operand type is not support" << endl;
parseInfo.setErrorNo(366);
throw parseInfo;
}
MDDBaseType* resultMDDType = new MDDBaseType( "tmp", resultBaseType );
TypeFactory::addTempType( resultMDDType );
dataStreamType.setType( resultMDDType );
}
else if(inputType.isBaseType()) {
BaseType* baseType = (BaseType*)(inputType.getType());
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_LOG, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtLog::checkType() - operand type is not supported." << endl;
parseInfo.setErrorNo(367);
throw parseInfo;
}
dataStreamType.setType( resultBaseType );
}
else {
RMInit::logOut << "Error: QtLog::checkType() - operation is not supported for strings." << endl;
parseInfo.setErrorNo(385);
throw parseInfo;
}
}
else
RMInit::logOut << "Error: QtLog::checkType() - operand branch invalid." << endl;
return dataStreamType;
}
const QtNode::QtNodeType QtLn::nodeType = QtNode::QT_LN;
QtLn::QtLn(QtOperation* initInput): QtUnaryInduce(initInput) {}
QtData* QtLn::evaluate(QtDataList* inputList) {
QtData* returnValue = NULL;
QtData* operand = NULL;
if(getOperand(inputList, operand)) {
try {
returnValue = computeOp( operand, Ops::OP_LN );
}
catch(...) {
operand->deleteRef();
throw;
}
}
// delete old operand
if(operand) operand->deleteRef();
return returnValue;
}
void QtLn::printTree(int tab, ostream& s, QtChildType mode) {
s << SPACE_STR(tab).c_str() << "QtLnObject " << getNodeType() << endl;
QtUnaryInduce::printTree( tab + 2, s, mode );
}
void QtLn::printAlgebraicExpression(ostream& s) {
s << "ln(";
if(input)
input->printAlgebraicExpression(s);
else
s << "";
s << ")";
}
const QtTypeElement& QtLn::checkType(QtTypeTuple* typeTuple) {
RMDBCLASS( "QtLn", "checkType( QtTypeTuple* )", "qlparser", __FILE__, __LINE__ )
dataStreamType.setDataType( QT_TYPE_UNKNOWN );
// check operand branches
if(input) {
// get input types
const QtTypeElement& inputType = input->checkType( typeTuple );
RMDBGIF( 4, RMDebug::module_qlparser, "AutoGen", \
RMInit::dbgOut << "Operand: " << flush; \
inputType.printStatus( RMInit::dbgOut ); \
RMInit::dbgOut << endl; \
)
if(inputType.getDataType() == QT_MDD) {
const BaseType* baseType = ((MDDBaseType*)(inputType.getType()))->getBaseType();
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_LN, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtLn::checkType() - induce operand type is not support" << endl;
parseInfo.setErrorNo(366);
throw parseInfo;
}
MDDBaseType* resultMDDType = new MDDBaseType( "tmp", resultBaseType );
TypeFactory::addTempType( resultMDDType );
dataStreamType.setType( resultMDDType );
}
else if(inputType.isBaseType()) {
BaseType* baseType = (BaseType*)(inputType.getType());
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_LN, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtLn::checkType() - operand type is not supported." << endl;
parseInfo.setErrorNo(367);
throw parseInfo;
}
dataStreamType.setType( resultBaseType );
}
else {
RMInit::logOut << "Error: QtLn::checkType() - operation is not supported for strings." << endl;
parseInfo.setErrorNo(385);
throw parseInfo;
}
}
else
RMInit::logOut << "Error: QtLn::checkType() - operand branch invalid." << endl;
return dataStreamType;
}
const QtNode::QtNodeType QtSin::nodeType = QtNode::QT_SIN;
QtSin::QtSin(QtOperation* initInput): QtUnaryInduce(initInput) {}
QtData* QtSin::evaluate(QtDataList* inputList) {
QtData* returnValue = NULL;
QtData* operand = NULL;
if(getOperand(inputList, operand)) {
try {
returnValue = computeOp( operand, Ops::OP_SIN );
}
catch(...) {
operand->deleteRef();
throw;
}
}
// delete old operand
if(operand) operand->deleteRef();
return returnValue;
}
void QtSin::printTree(int tab, ostream& s, QtChildType mode) {
s << SPACE_STR(tab).c_str() << "QtSinObject " << getNodeType() << endl;
QtUnaryInduce::printTree( tab + 2, s, mode );
}
void QtSin::printAlgebraicExpression(ostream& s) {
s << "sin(";
if(input)
input->printAlgebraicExpression(s);
else
s << "";
s << ")";
}
const QtTypeElement& QtSin::checkType(QtTypeTuple* typeTuple) {
RMDBCLASS( "QtSin", "checkType( QtTypeTuple* )", "qlparser", __FILE__, __LINE__ )
dataStreamType.setDataType( QT_TYPE_UNKNOWN );
// check operand branches
if(input) {
// get input types
const QtTypeElement& inputType = input->checkType( typeTuple );
RMDBGIF( 4, RMDebug::module_qlparser, "AutoGen", \
RMInit::dbgOut << "Operand: " << flush; \
inputType.printStatus( RMInit::dbgOut ); \
RMInit::dbgOut << endl; \
)
if(inputType.getDataType() == QT_MDD) {
const BaseType* baseType = ((MDDBaseType*)(inputType.getType()))->getBaseType();
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_SIN, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtSin::checkType() - induce operand type is not support" << endl;
parseInfo.setErrorNo(366);
throw parseInfo;
}
MDDBaseType* resultMDDType = new MDDBaseType( "tmp", resultBaseType );
TypeFactory::addTempType( resultMDDType );
dataStreamType.setType( resultMDDType );
}
else if(inputType.isBaseType()) {
BaseType* baseType = (BaseType*)(inputType.getType());
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_SIN, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtSin::checkType() - operand type is not supported." << endl;
parseInfo.setErrorNo(367);
throw parseInfo;
}
dataStreamType.setType( resultBaseType );
}
else {
RMInit::logOut << "Error: QtSin::checkType() - operation is not supported for strings." << endl;
parseInfo.setErrorNo(385);
throw parseInfo;
}
}
else
RMInit::logOut << "Error: QtSin::checkType() - operand branch invalid." << endl;
return dataStreamType;
}
const QtNode::QtNodeType QtCos::nodeType = QtNode::QT_COS;
QtCos::QtCos(QtOperation* initInput): QtUnaryInduce(initInput) {}
QtData* QtCos::evaluate(QtDataList* inputList) {
QtData* returnValue = NULL;
QtData* operand = NULL;
if(getOperand(inputList, operand)) {
try {
returnValue = computeOp( operand, Ops::OP_COS );
}
catch(...) {
operand->deleteRef();
throw;
}
}
// delete old operand
if(operand) operand->deleteRef();
return returnValue;
}
void QtCos::printTree(int tab, ostream& s, QtChildType mode) {
s << SPACE_STR(tab).c_str() << "QtCosObject " << getNodeType() << endl;
QtUnaryInduce::printTree( tab + 2, s, mode );
}
void QtCos::printAlgebraicExpression(ostream& s) {
s << "cos(";
if(input)
input->printAlgebraicExpression(s);
else
s << "";
s << ")";
}
const QtTypeElement& QtCos::checkType(QtTypeTuple* typeTuple) {
RMDBCLASS( "QtCos", "checkType( QtTypeTuple* )", "qlparser", __FILE__, __LINE__ )
dataStreamType.setDataType( QT_TYPE_UNKNOWN );
// check operand branches
if(input) {
// get input types
const QtTypeElement& inputType = input->checkType( typeTuple );
RMDBGIF( 4, RMDebug::module_qlparser, "AutoGen", \
RMInit::dbgOut << "Operand: " << flush; \
inputType.printStatus( RMInit::dbgOut ); \
RMInit::dbgOut << endl; \
)
if(inputType.getDataType() == QT_MDD) {
const BaseType* baseType = ((MDDBaseType*)(inputType.getType()))->getBaseType();
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_COS, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtCos::checkType() - induce operand type is not support" << endl;
parseInfo.setErrorNo(366);
throw parseInfo;
}
MDDBaseType* resultMDDType = new MDDBaseType( "tmp", resultBaseType );
TypeFactory::addTempType( resultMDDType );
dataStreamType.setType( resultMDDType );
}
else if(inputType.isBaseType()) {
BaseType* baseType = (BaseType*)(inputType.getType());
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_COS, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtCos::checkType() - operand type is not supported." << endl;
parseInfo.setErrorNo(367);
throw parseInfo;
}
dataStreamType.setType( resultBaseType );
}
else {
RMInit::logOut << "Error: QtCos::checkType() - operation is not supported for strings." << endl;
parseInfo.setErrorNo(385);
throw parseInfo;
}
}
else
RMInit::logOut << "Error: QtCos::checkType() - operand branch invalid." << endl;
return dataStreamType;
}
const QtNode::QtNodeType QtTan::nodeType = QtNode::QT_TAN;
QtTan::QtTan(QtOperation* initInput): QtUnaryInduce(initInput) {}
QtData* QtTan::evaluate(QtDataList* inputList) {
QtData* returnValue = NULL;
QtData* operand = NULL;
if(getOperand(inputList, operand)) {
try {
returnValue = computeOp( operand, Ops::OP_TAN );
}
catch(...) {
operand->deleteRef();
throw;
}
}
// delete old operand
if(operand) operand->deleteRef();
return returnValue;
}
void QtTan::printTree(int tab, ostream& s, QtChildType mode) {
s << SPACE_STR(tab).c_str() << "QtTanObject " << getNodeType() << endl;
QtUnaryInduce::printTree( tab + 2, s, mode );
}
void QtTan::printAlgebraicExpression(ostream& s) {
s << "tan(";
if(input)
input->printAlgebraicExpression(s);
else
s << "";
s << ")";
}
const QtTypeElement& QtTan::checkType(QtTypeTuple* typeTuple) {
RMDBCLASS( "QtTan", "checkType( QtTypeTuple* )", "qlparser", __FILE__, __LINE__ )
dataStreamType.setDataType( QT_TYPE_UNKNOWN );
// check operand branches
if(input) {
// get input types
const QtTypeElement& inputType = input->checkType( typeTuple );
RMDBGIF( 4, RMDebug::module_qlparser, "AutoGen", \
RMInit::dbgOut << "Operand: " << flush; \
inputType.printStatus( RMInit::dbgOut ); \
RMInit::dbgOut << endl; \
)
if(inputType.getDataType() == QT_MDD) {
const BaseType* baseType = ((MDDBaseType*)(inputType.getType()))->getBaseType();
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_TAN, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtTan::checkType() - induce operand type is not support" << endl;
parseInfo.setErrorNo(366);
throw parseInfo;
}
MDDBaseType* resultMDDType = new MDDBaseType( "tmp", resultBaseType );
TypeFactory::addTempType( resultMDDType );
dataStreamType.setType( resultMDDType );
}
else if(inputType.isBaseType()) {
BaseType* baseType = (BaseType*)(inputType.getType());
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_TAN, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtTan::checkType() - operand type is not supported." << endl;
parseInfo.setErrorNo(367);
throw parseInfo;
}
dataStreamType.setType( resultBaseType );
}
else {
RMInit::logOut << "Error: QtTan::checkType() - operation is not supported for strings." << endl;
parseInfo.setErrorNo(385);
throw parseInfo;
}
}
else
RMInit::logOut << "Error: QtTan::checkType() - operand branch invalid." << endl;
return dataStreamType;
}
const QtNode::QtNodeType QtSinh::nodeType = QtNode::QT_SINH;
QtSinh::QtSinh(QtOperation* initInput): QtUnaryInduce(initInput) {}
QtData* QtSinh::evaluate(QtDataList* inputList) {
QtData* returnValue = NULL;
QtData* operand = NULL;
if(getOperand(inputList, operand)) {
try {
returnValue = computeOp( operand, Ops::OP_SINH );
}
catch(...) {
operand->deleteRef();
throw;
}
}
// delete old operand
if(operand) operand->deleteRef();
return returnValue;
}
void QtSinh::printTree(int tab, ostream& s, QtChildType mode) {
s << SPACE_STR(tab).c_str() << "QtSinhObject " << getNodeType() << endl;
QtUnaryInduce::printTree( tab + 2, s, mode );
}
void QtSinh::printAlgebraicExpression(ostream& s) {
s << "sinh(";
if(input)
input->printAlgebraicExpression(s);
else
s << "";
s << ")";
}
const QtTypeElement& QtSinh::checkType(QtTypeTuple* typeTuple) {
RMDBCLASS( "QtSinh", "checkType( QtTypeTuple* )", "qlparser", __FILE__, __LINE__ )
dataStreamType.setDataType( QT_TYPE_UNKNOWN );
// check operand branches
if(input) {
// get input types
const QtTypeElement& inputType = input->checkType( typeTuple );
RMDBGIF( 4, RMDebug::module_qlparser, "AutoGen", \
RMInit::dbgOut << "Operand: " << flush; \
inputType.printStatus( RMInit::dbgOut ); \
RMInit::dbgOut << endl; \
)
if(inputType.getDataType() == QT_MDD) {
const BaseType* baseType = ((MDDBaseType*)(inputType.getType()))->getBaseType();
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_SINH, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtSinh::checkType() - induce operand type is not support" << endl;
parseInfo.setErrorNo(366);
throw parseInfo;
}
MDDBaseType* resultMDDType = new MDDBaseType( "tmp", resultBaseType );
TypeFactory::addTempType( resultMDDType );
dataStreamType.setType( resultMDDType );
}
else if(inputType.isBaseType()) {
BaseType* baseType = (BaseType*)(inputType.getType());
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_SINH, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtSinh::checkType() - operand type is not supported." << endl;
parseInfo.setErrorNo(367);
throw parseInfo;
}
dataStreamType.setType( resultBaseType );
}
else {
RMInit::logOut << "Error: QtSinh::checkType() - operation is not supported for strings." << endl;
parseInfo.setErrorNo(385);
throw parseInfo;
}
}
else
RMInit::logOut << "Error: QtSinh::checkType() - operand branch invalid." << endl;
return dataStreamType;
}
const QtNode::QtNodeType QtCosh::nodeType = QtNode::QT_COSH;
QtCosh::QtCosh(QtOperation* initInput): QtUnaryInduce(initInput) {}
QtData* QtCosh::evaluate(QtDataList* inputList) {
QtData* returnValue = NULL;
QtData* operand = NULL;
if(getOperand(inputList, operand)) {
try {
returnValue = computeOp( operand, Ops::OP_COSH );
}
catch(...) {
operand->deleteRef();
throw;
}
}
// delete old operand
if(operand) operand->deleteRef();
return returnValue;
}
void QtCosh::printTree(int tab, ostream& s, QtChildType mode) {
s << SPACE_STR(tab).c_str() << "QtCoshObject " << getNodeType() << endl;
QtUnaryInduce::printTree( tab + 2, s, mode );
}
void QtCosh::printAlgebraicExpression(ostream& s) {
s << "cosh(";
if(input)
input->printAlgebraicExpression(s);
else
s << "";
s << ")";
}
const QtTypeElement& QtCosh::checkType(QtTypeTuple* typeTuple) {
RMDBCLASS( "QtCosh", "checkType( QtTypeTuple* )", "qlparser", __FILE__, __LINE__ )
dataStreamType.setDataType( QT_TYPE_UNKNOWN );
// check operand branches
if(input) {
// get input types
const QtTypeElement& inputType = input->checkType( typeTuple );
RMDBGIF( 4, RMDebug::module_qlparser, "AutoGen", \
RMInit::dbgOut << "Operand: " << flush; \
inputType.printStatus( RMInit::dbgOut ); \
RMInit::dbgOut << endl; \
)
if(inputType.getDataType() == QT_MDD) {
const BaseType* baseType = ((MDDBaseType*)(inputType.getType()))->getBaseType();
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_COSH, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtCosh::checkType() - induce operand type is not support" << endl;
parseInfo.setErrorNo(366);
throw parseInfo;
}
MDDBaseType* resultMDDType = new MDDBaseType( "tmp", resultBaseType );
TypeFactory::addTempType( resultMDDType );
dataStreamType.setType( resultMDDType );
}
else if(inputType.isBaseType()) {
BaseType* baseType = (BaseType*)(inputType.getType());
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_COSH, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtCosh::checkType() - operand type is not supported." << endl;
parseInfo.setErrorNo(367);
throw parseInfo;
}
dataStreamType.setType( resultBaseType );
}
else {
RMInit::logOut << "Error: QtCosh::checkType() - operation is not supported for strings." << endl;
parseInfo.setErrorNo(385);
throw parseInfo;
}
}
else
RMInit::logOut << "Error: QtCosh::checkType() - operand branch invalid." << endl;
return dataStreamType;
}
const QtNode::QtNodeType QtTanh::nodeType = QtNode::QT_TANH;
QtTanh::QtTanh(QtOperation* initInput): QtUnaryInduce(initInput) {}
QtData* QtTanh::evaluate(QtDataList* inputList) {
QtData* returnValue = NULL;
QtData* operand = NULL;
if(getOperand(inputList, operand)) {
try {
returnValue = computeOp( operand, Ops::OP_TANH );
}
catch(...) {
operand->deleteRef();
throw;
}
}
// delete old operand
if(operand) operand->deleteRef();
return returnValue;
}
void QtTanh::printTree(int tab, ostream& s, QtChildType mode) {
s << SPACE_STR(tab).c_str() << "QtTanhObject " << getNodeType() << endl;
QtUnaryInduce::printTree( tab + 2, s, mode );
}
void QtTanh::printAlgebraicExpression(ostream& s) {
s << "tanh(";
if(input)
input->printAlgebraicExpression(s);
else
s << "";
s << ")";
}
const QtTypeElement& QtTanh::checkType(QtTypeTuple* typeTuple) {
RMDBCLASS( "QtTanh", "checkType( QtTypeTuple* )", "qlparser", __FILE__, __LINE__ )
dataStreamType.setDataType( QT_TYPE_UNKNOWN );
// check operand branches
if(input) {
// get input types
const QtTypeElement& inputType = input->checkType( typeTuple );
RMDBGIF( 4, RMDebug::module_qlparser, "AutoGen", \
RMInit::dbgOut << "Operand: " << flush; \
inputType.printStatus( RMInit::dbgOut ); \
RMInit::dbgOut << endl; \
)
if(inputType.getDataType() == QT_MDD) {
const BaseType* baseType = ((MDDBaseType*)(inputType.getType()))->getBaseType();
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_TANH, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtTanh::checkType() - induce operand type is not support" << endl;
parseInfo.setErrorNo(366);
throw parseInfo;
}
MDDBaseType* resultMDDType = new MDDBaseType( "tmp", resultBaseType );
TypeFactory::addTempType( resultMDDType );
dataStreamType.setType( resultMDDType );
}
else if(inputType.isBaseType()) {
BaseType* baseType = (BaseType*)(inputType.getType());
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_TANH, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtTanh::checkType() - operand type is not supported." << endl;
parseInfo.setErrorNo(367);
throw parseInfo;
}
dataStreamType.setType( resultBaseType );
}
else {
RMInit::logOut << "Error: QtTanh::checkType() - operation is not supported for strings." << endl;
parseInfo.setErrorNo(385);
throw parseInfo;
}
}
else
RMInit::logOut << "Error: QtTanh::checkType() - operand branch invalid." << endl;
return dataStreamType;
}
const QtNode::QtNodeType QtArcsin::nodeType = QtNode::QT_ARCSIN;
QtArcsin::QtArcsin(QtOperation* initInput): QtUnaryInduce(initInput) {}
QtData* QtArcsin::evaluate(QtDataList* inputList) {
QtData* returnValue = NULL;
QtData* operand = NULL;
if(getOperand(inputList, operand)) {
try {
returnValue = computeOp( operand, Ops::OP_ARCSIN );
}
catch(...) {
operand->deleteRef();
throw;
}
}
// delete old operand
if(operand) operand->deleteRef();
return returnValue;
}
void QtArcsin::printTree(int tab, ostream& s, QtChildType mode) {
s << SPACE_STR(tab).c_str() << "QtArcsinObject " << getNodeType() << endl;
QtUnaryInduce::printTree( tab + 2, s, mode );
}
void QtArcsin::printAlgebraicExpression(ostream& s) {
s << "arcsin(";
if(input)
input->printAlgebraicExpression(s);
else
s << "";
s << ")";
}
const QtTypeElement& QtArcsin::checkType(QtTypeTuple* typeTuple) {
RMDBCLASS( "QtArcsin", "checkType( QtTypeTuple* )", "qlparser", __FILE__, __LINE__ )
dataStreamType.setDataType( QT_TYPE_UNKNOWN );
// check operand branches
if(input) {
// get input types
const QtTypeElement& inputType = input->checkType( typeTuple );
RMDBGIF( 4, RMDebug::module_qlparser, "AutoGen", \
RMInit::dbgOut << "Operand: " << flush; \
inputType.printStatus( RMInit::dbgOut ); \
RMInit::dbgOut << endl; \
)
if(inputType.getDataType() == QT_MDD) {
const BaseType* baseType = ((MDDBaseType*)(inputType.getType()))->getBaseType();
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_ARCSIN, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtArcsin::checkType() - induce operand type is not support" << endl;
parseInfo.setErrorNo(366);
throw parseInfo;
}
MDDBaseType* resultMDDType = new MDDBaseType( "tmp", resultBaseType );
TypeFactory::addTempType( resultMDDType );
dataStreamType.setType( resultMDDType );
}
else if(inputType.isBaseType()) {
BaseType* baseType = (BaseType*)(inputType.getType());
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_ARCSIN, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtArcsin::checkType() - operand type is not supported." << endl;
parseInfo.setErrorNo(367);
throw parseInfo;
}
dataStreamType.setType( resultBaseType );
}
else {
RMInit::logOut << "Error: QtArcsin::checkType() - operation is not supported for strings." << endl;
parseInfo.setErrorNo(385);
throw parseInfo;
}
}
else
RMInit::logOut << "Error: QtArcsin::checkType() - operand branch invalid." << endl;
return dataStreamType;
}
const QtNode::QtNodeType QtArccos::nodeType = QtNode::QT_ARCCOS;
QtArccos::QtArccos(QtOperation* initInput): QtUnaryInduce(initInput) {}
QtData* QtArccos::evaluate(QtDataList* inputList) {
QtData* returnValue = NULL;
QtData* operand = NULL;
if(getOperand(inputList, operand)) {
try {
returnValue = computeOp( operand, Ops::OP_ARCCOS );
}
catch(...) {
operand->deleteRef();
throw;
}
}
// delete old operand
if(operand) operand->deleteRef();
return returnValue;
}
void QtArccos::printTree(int tab, ostream& s, QtChildType mode) {
s << SPACE_STR(tab).c_str() << "QtArccosObject " << getNodeType() << endl;
QtUnaryInduce::printTree( tab + 2, s, mode );
}
void QtArccos::printAlgebraicExpression(ostream& s) {
s << "arccos(";
if(input)
input->printAlgebraicExpression(s);
else
s << "";
s << ")";
}
const QtTypeElement& QtArccos::checkType(QtTypeTuple* typeTuple) {
RMDBCLASS( "QtArccos", "checkType( QtTypeTuple* )", "qlparser", __FILE__, __LINE__ )
dataStreamType.setDataType( QT_TYPE_UNKNOWN );
// check operand branches
if(input) {
// get input types
const QtTypeElement& inputType = input->checkType( typeTuple );
RMDBGIF( 4, RMDebug::module_qlparser, "AutoGen", \
RMInit::dbgOut << "Operand: " << flush; \
inputType.printStatus( RMInit::dbgOut ); \
RMInit::dbgOut << endl; \
)
if(inputType.getDataType() == QT_MDD) {
const BaseType* baseType = ((MDDBaseType*)(inputType.getType()))->getBaseType();
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_ARCCOS, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtArccos::checkType() - induce operand type is not support" << endl;
parseInfo.setErrorNo(366);
throw parseInfo;
}
MDDBaseType* resultMDDType = new MDDBaseType( "tmp", resultBaseType );
TypeFactory::addTempType( resultMDDType );
dataStreamType.setType( resultMDDType );
}
else if(inputType.isBaseType()) {
BaseType* baseType = (BaseType*)(inputType.getType());
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_ARCCOS, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtArccos::checkType() - operand type is not supported." << endl;
parseInfo.setErrorNo(367);
throw parseInfo;
}
dataStreamType.setType( resultBaseType );
}
else {
RMInit::logOut << "Error: QtArccos::checkType() - operation is not supported for strings." << endl;
parseInfo.setErrorNo(385);
throw parseInfo;
}
}
else
RMInit::logOut << "Error: QtArccos::checkType() - operand branch invalid." << endl;
return dataStreamType;
}
const QtNode::QtNodeType QtArctan::nodeType = QtNode::QT_ARCTAN;
QtArctan::QtArctan(QtOperation* initInput): QtUnaryInduce(initInput) {}
QtData* QtArctan::evaluate(QtDataList* inputList) {
QtData* returnValue = NULL;
QtData* operand = NULL;
if(getOperand(inputList, operand)) {
try {
returnValue = computeOp( operand, Ops::OP_ARCTAN );
}
catch(...) {
operand->deleteRef();
throw;
}
}
// delete old operand
if(operand) operand->deleteRef();
return returnValue;
}
void QtArctan::printTree(int tab, ostream& s, QtChildType mode) {
s << SPACE_STR(tab).c_str() << "QtArctanObject " << getNodeType() << endl;
QtUnaryInduce::printTree( tab + 2, s, mode );
}
void QtArctan::printAlgebraicExpression(ostream& s) {
s << "arctan(";
if(input)
input->printAlgebraicExpression(s);
else
s << "";
s << ")";
}
const QtTypeElement& QtArctan::checkType(QtTypeTuple* typeTuple) {
RMDBCLASS( "QtArctan", "checkType( QtTypeTuple* )", "qlparser", __FILE__, __LINE__ )
dataStreamType.setDataType( QT_TYPE_UNKNOWN );
// check operand branches
if(input)
{
// get input types
const QtTypeElement& inputType = input->checkType( typeTuple );
RMDBGIF( 4, RMDebug::module_qlparser, "AutoGen", \
RMInit::dbgOut << "Operand: " << flush; \
inputType.printStatus( RMInit::dbgOut ); \
RMInit::dbgOut << endl; \
)
if(inputType.getDataType() == QT_MDD) {
const BaseType* baseType = ((MDDBaseType*)(inputType.getType()))->getBaseType();
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_ARCTAN, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtArctan::checkType() - induce operand type is not support" << endl;
parseInfo.setErrorNo(366);
throw parseInfo;
}
MDDBaseType* resultMDDType = new MDDBaseType( "tmp", resultBaseType );
TypeFactory::addTempType( resultMDDType );
dataStreamType.setType( resultMDDType );
}
else if(inputType.isBaseType()) {
BaseType* baseType = (BaseType*)(inputType.getType());
BaseType* resultBaseType = (BaseType*)(Ops::getResultType( Ops::OP_ARCTAN, baseType ));
if(!resultBaseType) {
RMInit::logOut << "Error: QtArctan::checkType() - operand type is not supported." << endl;
parseInfo.setErrorNo(367);
throw parseInfo;
}
dataStreamType.setType( resultBaseType );
}
else {
RMInit::logOut << "Error: QtArctan::checkType() - operation is not supported for strings." << endl;
parseInfo.setErrorNo(385);
throw parseInfo;
}
}
else
RMInit::logOut << "Error: QtArctan::checkType() - operand branch invalid." << endl;
return dataStreamType;
}