1 files changed, 414 insertions, 0 deletions
diff --git a/qlparser/qtunaryfunc.cc b/qlparser/qtunaryfunc.cc
new file mode 100644
index 0000000..fa151fd
--- /dev/null
+++ b/qlparser/qtunaryfunc.cc
@@ -0,0 +1,414 @@
+/*
+* 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 <http://www.gnu.org/licenses/>.
+*
+* Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009 Peter Baumann /
+rasdaman GmbH.
+*
+* For more information please see <http://www.rasdaman.org>
+* or contact Peter Baumann via <baumann@rasdaman.com>.
+*/
+/*************************************************************
+ *
+ *
+ * PURPOSE:
+ *
+ *
+ * COMMENTS:
+ *
+ ************************************************************/
+
+static const char rcsid[] = "@(#)qlparser, QtIntervalLoOp, QtIntervalHiOp, QtSDom: $Header: /home/rasdev/CVS-repository/rasdaman/qlparser/qtunaryfunc.cc,v 1.11 2003/12/27 20:51:28 rasdev Exp $";
+
+#include "qlparser/qtunaryfunc.hh"
+#include "qlparser/qtintervaldata.hh"
+#include "qlparser/qtatomicdata.hh"
+#include "qlparser/qtmintervaldata.hh"
+#include "qlparser/qtmdd.hh"
+
+const QtNode::QtNodeType QtIntervalLoOp::nodeType = QtNode::QT_LO;
+
+
+QtIntervalLoOp::QtIntervalLoOp( QtOperation* newInput )
+  : QtUnaryOperation( newInput )
+{
+}
+
+
+
+QtData*
+QtIntervalLoOp::evaluate( QtDataList* inputList )
+{
+  RMDBCLASS( "QtIntervalLoOp", "evaluate( QtDataList* )", "qlparser", __FILE__, __LINE__ )
+
+  QtData* returnValue = NULL;
+  QtData* operand = NULL;
+
+  operand = input->evaluate( inputList );
+
+  if( operand )
+  {
+#ifdef QT_RUNTIME_TYPE_CHECK
+    if( operand->getDataType() != QT_INTERVAL )
+    {
+      RMInit::logOut << "Internal error in QtIntervalLoOp::evaluate() - "
+                     << "runtime type checking failed (INTERVAL)." << std::endl; 
+
+      // delete old operand
+      if( operand ) operand->deleteRef();
+      return 0;
+    }
+#endif
+
+    QtIntervalData* intervalData = (QtIntervalData*)operand;
+
+    r_Sinterval sinterval = intervalData->getIntervalData();
+
+    if( sinterval.is_low_fixed() )
+    {
+      returnValue = new QtAtomicData( (r_Long)(sinterval.low()), 4 );
+    }
+    else
+    {
+      RMInit::logOut << "Error: QtIntervalLoOp::evaluate() - operation lo() can not be used for an open bound." << std::endl;
+
+      // delete old operand
+      if( operand ) operand->deleteRef();
+
+      parseInfo.setErrorNo(394);
+      throw parseInfo;
+    }            
+
+    // delete old operand
+    if( operand ) operand->deleteRef();
+
+  }
+  else
+  {
+    RMDBGMIDDLE( 1, RMDebug::module_qlparser, "QtIntervalLoOp", "Information: QtIntervalLoOp::evaluate() - operand is not provided." )
+  }
+
+  return returnValue;
+}
+
+
+
+void
+QtIntervalLoOp::printTree( int tab, std::ostream& s, QtChildType mode )
+{
+  s << SPACE_STR(tab).c_str() << "QtIntervalLoOp Object: " << std::endl;
+
+  QtUnaryOperation::printTree( tab, s, mode );
+}
+
+
+
+void
+QtIntervalLoOp::printAlgebraicExpression( std::ostream& s )
+{
+  s << "(" << std::flush;
+
+  if( input )
+    input->printAlgebraicExpression( s );
+  else
+    s << "<nn>";
+
+  s << ").lo ";  
+}
+
+
+
+const QtTypeElement&
+QtIntervalLoOp::checkType( QtTypeTuple* typeTuple )
+{
+  RMDBCLASS( "QtIntervalLoOp", "checkType( QtTypeTuple* )", "qlparser", __FILE__, __LINE__ )
+
+  dataStreamType.setDataType( QT_TYPE_UNKNOWN );  
+
+  // check operand branches
+  if( input )
+  {
+
+  // get input type
+  const QtTypeElement& inputType = input->checkType( typeTuple ); 
+
+  if( inputType.getDataType() != QT_INTERVAL )
+  {
+    RMInit::logOut << "Error: QtIntervalLoOp::checkType() - operation lo() must be of type interval." << std::endl;
+    parseInfo.setErrorNo(393);
+    throw parseInfo;
+  }
+
+  dataStreamType.setDataType( QT_LONG );
+  }
+  else
+    RMInit::logOut << "Error: QtIntervalLoOp::checkType() - operand branch invalid." << std::endl;
+  
+  return dataStreamType;
+}
+
+
+
+const QtNode::QtNodeType QtIntervalHiOp::nodeType = QtNode::QT_HI;
+
+
+QtIntervalHiOp::QtIntervalHiOp( QtOperation* newInput )
+  : QtUnaryOperation( newInput )
+{
+}
+
+
+
+QtData*
+QtIntervalHiOp::evaluate( QtDataList* inputList )
+{
+  RMDBCLASS( "QtIntervalHiOp", "evaluate( QtDataList* )", "qlparser", __FILE__, __LINE__ )
+
+  QtData* returnValue = NULL;
+  QtData* operand = NULL;
+
+  operand = input->evaluate( inputList );
+
+  if( operand )
+  {
+#ifdef QT_RUNTIME_TYPE_CHECK
+    if( operand->getDataType() != QT_INTERVAL )
+    {
+      RMInit::logOut << "Internal error in QtIntervalHiOp::evaluate() - "
+                     << "runtime type checking failed (INTERVAL)." << std::endl; 
+
+      // delete old operand
+      if( operand ) operand->deleteRef();
+      return 0;
+    }
+#endif
+
+    QtIntervalData* intervalData = (QtIntervalData*)operand;
+
+    r_Sinterval sinterval = intervalData->getIntervalData();
+
+    if( sinterval.is_high_fixed() )
+    {
+      returnValue = new QtAtomicData( (r_Long)(sinterval.high()), 4 );
+    }
+    else
+    {
+      RMInit::logOut << "Error: QtIntervalHiOp::evaluate() - operation lo() can not be used for an open bound." << std::endl;
+
+      // delete old operand
+      if( operand ) operand->deleteRef();
+
+      parseInfo.setErrorNo(394);
+      throw parseInfo;
+    }            
+
+    // delete old operand
+    if( operand ) operand->deleteRef();
+  }
+  else
+  {
+    RMDBGMIDDLE( 1, RMDebug::module_qlparser, "QtIntervalHiOp", "Information: QtIntervalHiOp::evaluate() - operand is not provided." )
+  }
+ 
+  return returnValue;
+}
+
+
+
+void
+QtIntervalHiOp::printTree( int tab, std::ostream& s, QtChildType mode )
+{
+  s << SPACE_STR(tab).c_str() << "QtIntervalHiOp Object: " << std::endl;
+
+  QtUnaryOperation::printTree( tab, s, mode );
+}
+
+
+
+void
+QtIntervalHiOp::printAlgebraicExpression( std::ostream& s )
+{
+  s << "(" << std::flush;
+
+  if( input )
+    input->printAlgebraicExpression( s );
+  else
+    s << "<nn>";
+
+  s << ").hi ";  
+}
+
+
+
+const QtTypeElement&
+QtIntervalHiOp::checkType( QtTypeTuple* typeTuple )
+{
+  RMDBCLASS( "QtIntervalHiOp", "checkType( QtTypeTuple* )", "qlparser", __FILE__, __LINE__ )
+
+  dataStreamType.setDataType( QT_TYPE_UNKNOWN );  
+
+  // check operand branches
+  if( input )
+  {
+
+  // get input type
+  const QtTypeElement& inputType = input->checkType( typeTuple ); 
+
+  if( inputType.getDataType() != QT_INTERVAL )
+  {
+    RMInit::logOut << "Error: QtIntervalHiOp::checkType() - operation lo() must be of type interval." << std::endl;
+    parseInfo.setErrorNo(393);
+    throw parseInfo;
+  }
+
+  dataStreamType.setDataType( QT_LONG );
+  }
+  else
+    RMInit::logOut << "Error: QtIntervalHiOp::checkType() - operand branch invalid." << std::endl;
+  return dataStreamType;
+}
+
+
+
+
+const QtNode::QtNodeType QtSDom::nodeType = QtNode::QT_SDOM;
+
+
+QtSDom::QtSDom( QtOperation* newInput )
+  : QtUnaryOperation( newInput )
+{
+}
+
+
+
+QtData*
+QtSDom::evaluate( QtDataList* inputList )
+{
+  RMDBCLASS( "QtSDom", "evaluate( QtDataList* )", "qlparser", __FILE__, __LINE__ )
+
+  QtData* returnValue = NULL;
+  QtData* operand = NULL;
+
+  operand = input->evaluate( inputList );
+
+  if( operand )
+  {
+#ifdef QT_RUNTIME_TYPE_CHECK
+    if( operand->getDataType() != QT_MDD )
+    {
+      RMInit::logOut << "Internal error in QtSDom::evaluate() - "
+                     << "runtime type checking failed (MDD)." << std::endl; 
+
+      // delete old operand
+      if( operand ) operand->deleteRef();
+      return 0;
+    }
+#endif
+
+    QtMDD*  qtMDD  = (QtMDD*) operand;
+
+    returnValue = new QtMintervalData( qtMDD->getLoadDomain() );
+
+    // delete old operand
+    if( operand ) operand->deleteRef();
+  }
+  else
+  {
+    RMDBGMIDDLE( 1, RMDebug::module_qlparser, "QtSDom", "Information: QtSDom::evaluate() - operand is not provided." )
+  }
+
+  return returnValue;
+}
+
+
+
+void
+QtSDom::optimizeLoad( QtTrimList* trimList )
+{
+  RMDBCLASS( "QtSDom", "optimizeLoad( QtTrimList* )", "qlparser", __FILE__, __LINE__ )
+
+  // reset trimList because optimization enters a new MDD area
+
+  // delete list
+  vector<QtNode::QtTrimElement*>::iterator iter;
+  for( iter=trimList->begin(); iter!=trimList->end(); iter++ )
+  {
+    delete *iter;
+    *iter=NULL;
+  }
+  delete trimList;
+  trimList=NULL;
+
+  if( input )
+    input->optimizeLoad( new QtNode::QtTrimList );
+}
+
+
+
+void
+QtSDom::printTree( int tab, std::ostream& s, QtChildType mode )
+{
+  s << SPACE_STR(tab).c_str() << "QtSDom Object: " << std::endl;
+
+  QtUnaryOperation::printTree( tab, s, mode );
+}
+
+
+
+void
+QtSDom::printAlgebraicExpression( std::ostream& s )
+{
+  s << "sdom(" << std::flush;
+
+  if( input )
+    input->printAlgebraicExpression( s );
+  else
+    s << "<nn>";
+
+  s << ")";  
+}
+
+
+
+const QtTypeElement&
+QtSDom::checkType( QtTypeTuple* typeTuple )
+{
+  RMDBCLASS( "QtSDom", "checkType( QtTypeTuple* )", "qlparser", __FILE__, __LINE__ )
+
+  dataStreamType.setDataType( QT_TYPE_UNKNOWN );  
+
+  // check operand branches
+  if( input )
+  {
+
+  // get input type
+  const QtTypeElement& inputType = input->checkType( typeTuple ); 
+
+  if( inputType.getDataType() != QT_MDD )
+  {
+    RMInit::logOut << "Error: QtSDom::checkType() - operand must be of type MDD." << std::endl;
+    parseInfo.setErrorNo(395);
+    throw parseInfo;
+  }
+
+  dataStreamType.setDataType( QT_MINTERVAL );
+  }
+  else
+    RMInit::logOut << "Error: QtSDom::checkType() - operand branch invalid." << std::endl;
+  
+  return dataStreamType;
+}
+
+