/* ---- This file is part of SECONDO. Copyright (C) 2004, University in Hagen, Department of Computer Science, Database Systems for New Applications. SECONDO 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 2 of the License, or (at your option) any later version. SECONDO 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 SECONDO; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ---- //paragraph [1] Title: [{\Large \bf \begin{center}] [\end{center}}] //[TOC] [\tableofcontents] [1] ConstLengthUnit.h April 2015 - Rene Steinbrueck 1 Overview [TOC] 2 Defines, includes, and constants */ #ifndef CONST_LENGTH_UNIT_H #define CONST_LENGTH_UNIT_H #include "StandardLengthUnit.h" /* 3 C++ Classes (Defintion) 3.1 ConstLengthUnit This class will be used in the ~const~ type constructor. It constructs constant length units, i.e. it has a constant value and the length function always return this value. The explicit purpose of the ~const~ type constructor is to define length units for ~int~, ~string~, and ~bool~, i.e., for types where their values change only in discrete steps. This class inherits a defined flag! */ template class ConstLengthUnit : public StandardLengthUnit { public: /* 3.1.1 Constructors and Destructor 3.1.1.1 Standard constructor */ ConstLengthUnit() {} /* The simple constructor. This constructor should not be used. 3.1.1.2 Default constructor */ ConstLengthUnit(bool is_defined): StandardLengthUnit(is_defined), constValue(is_defined) { } /* This constructor initializes the LInterval and the constValue with zero. If the passed bool flag is true start, end and the constValue are defined, otherwise not. The produced linterval is left and right closed. 3.1.1.3 Setting constructor */ ConstLengthUnit( const LInterval& linterval, const Alpha& m ): StandardLengthUnit( linterval ), constValue(m) { this->del.isDefined = true; } /* This constructor intializes the length interval of the ConstLengthUnit with the passes linterval and the constValue with the passed value a. 3.1.1.4 Copy constructor */ ConstLengthUnit( const ConstLengthUnit& u ): StandardLengthUnit( u.lengthInterval ), constValue(u.constValue) { this->del.isDefined = u.del.isDefined; } /* This constructor intializes the ConstLengthUnit wiht the values of the passed ConstLengthUnit u. 3.1.2 Member functions 3.1.2.1 LengthFunction */ virtual void LengthFunction( const CcReal& l, Alpha& result, bool ignoreLimits = false ) const { if ( !this->IsDefined() || !l.IsDefined() || (!this->lengthInterval.Contains( l ) && !ignoreLimits)) { result.SetDefined( false ); } else { result.CopyFrom( &constValue ); result.SetDefined( true ); } } /* ~LengthFunction~ returns an undefined result if the LengthUnit or the CcReal is undefined, or the CcReal is not within the unit's lengthInterval. 3.1.2.2 EqualValue */ virtual bool EqualValue( const LengthUnit& i) const { return EqualValue( *((const ConstLengthUnit*)&i)); } virtual bool EqualValue( const ConstLengthUnit& i ) const { return this->IsDefined() && (constValue.Compare( &i.constValue ) == 0); } /* Returns ~true~ if the value of this length unit is defined and equal to the value of the length unit ~i~ and ~false~ if they are different. 3.1.3 Operator Redefinitions 3.1.3.1 Operation ~copy~ */ virtual ConstLengthUnit& operator=( const ConstLengthUnit& i ) { this->del.isDefined = i.del.isDefined; if( !i.IsDefined() ) { return *this; } *((LengthUnit*)this) = *((LengthUnit*)&i); constValue.CopyFrom( &i.constValue ); return *this; } /* Redefinition of the copy operator ~=~. 3.1.3.2 Operation $=$ (~equal~) */ virtual bool operator==( const ConstLengthUnit& i ) const { if( !this->IsDefined() && !i.IsDefined() ) { return true; } return ( (this->IsDefined()) && (i.IsDefined()) && *((LengthUnit*)this) == *((LengthUnit*)&i) && (constValue.Compare( &i.constValue ) == 0) ); } /* Two ConstLengthUnits are equal, if both are either undefined, or both are defined and represent the same length function Returns ~true~ if this length unit is equal to the length unit ~i~ and ~false~ if they are different. 3.1.3.3 Operation $\neq$ (~not equal~) */ virtual bool operator!=( const ConstLengthUnit& i ) const { return !( *this == i ); } /* Returns ~true~ if this length unit is different to the length unit ~i~ and ~false~ if they are equal. 3.1.4 Functions to be part of relations 3.1.4.1 Compare */ virtual int Compare( const Attribute* arg ) const { ConstLengthUnit* clu = (ConstLengthUnit*)arg; if (this->IsDefined() && !clu->IsDefined()) return 0; if (!this->IsDefined()) return -1; if (!clu->IsDefined()) return 1; int cmp = this->lengthInterval.CompareTo(clu->lengthInterval); if(cmp) { return cmp; } return constValue.Compare(&(clu->constValue)); } /* 3.1.4.2 Adjacent */ virtual bool Adjacent( const Attribute* arg ) const { return false; } /* 3.1.4.3 HashValue */ virtual size_t HashValue() const { if(!this->IsDefined()) { return 0; } return static_cast ( this->lengthInterval.start.HashValue()^ this->lengthInterval.end.HashValue() ); } /* 3.1.4.4 CopyFrom */ virtual void CopyFrom( const Attribute* right ) { const ConstLengthUnit* clu = (const ConstLengthUnit*)right; this->SetDefined(clu->IsDefined()); this->lengthInterval.CopyFrom( clu->lengthInterval ); constValue.CopyFrom( &(clu->constValue) ); } /* 3.1.4.5 NumOfFLOBs */ inline int NumOfFLOBs() const {return constValue.NumOfFLOBs();} /* 3.1.4.6 GetFLOB */ inline Flob *GetFLOB(const int i) {return constValue.GetFLOB(i);} /* 3.1.4.7 Print */ virtual std::ostream& Print( std::ostream &os ) const { if( this->IsDefined() ) { os << ConstLengthUnit::BasicType() << ": ( "; LengthUnit::lengthInterval.Print(os); os << ", "; constValue.Print(os); os << " ) " << endl; return os; } else return os << ConstLengthUnit::BasicType()<<": (undef) "; } /* 3.1.4.8 Basic Type */ inline static const std::string BasicType() { return "lu"+Alpha::BasicType(); } /* 3.1.4.9 Check Type */ static const bool checkType(const ListExpr type) { return listutils::isSymbol(type, BasicType()); } /* 3.1.4.10 Clone Function */ virtual ConstLengthUnit* Clone() const { return new ConstLengthUnit(*this); } /* 3.1.4.11 SizeOf Funtion */ virtual size_t Sizeof() const { return sizeof( *this ); } /* 3.1.5 Attributes */ Alpha constValue; /* The constant value of the length unit. */ }; /* 3.2 Class ~LUBool~ */ typedef ConstLengthUnit LUBool; /* 3.3 Class ~LUInt~ */ typedef ConstLengthUnit LUInt; /* 3.4 Class ~LUString~ */ typedef ConstLengthUnit LUString; /* 3 Type Constructors 1.1 Type Constructor ~ConstLengthUnit~ 1.1.1 ~Out~-function */ template ListExpr OutConstLengthUnit( ListExpr typeInfo, Word value ) { //1.get the address of the object and have a class object ConstLengthUnit* constunit = (ConstLengthUnit*)(value.addr); //2.test for undefined value if ( !constunit->IsDefined() ) return (nl->SymbolAtom(Symbol::UNDEFINED())); //3.get the length interval NL ListExpr intervalList = nl->FourElemList( OutCcReal( nl->TheEmptyList(), SetWord(&constunit->lengthInterval.start) ), OutCcReal( nl->TheEmptyList(), SetWord(&constunit->lengthInterval.end) ), nl->BoolAtom( constunit->lengthInterval.lc ), nl->BoolAtom( constunit->lengthInterval.rc)); //4. return the final result return nl->TwoElemList ( intervalList, OutFun( nl->TheEmptyList(), SetWord( &constunit->constValue ) ) ); } /* 1.1.2 ~In~-function */ template Word InConstLengthUnit( const ListExpr typeInfo, const ListExpr instance, const int errorPos, ListExpr& errorInfo, bool& correct ) { std::string errmsg; if( nl->ListLength( instance ) == 2 ) { //1. deal with the length interval ListExpr first = nl->First( instance ); if( nl->ListLength( first ) == 4 && nl->IsAtom( nl->Third( first ) ) && nl->AtomType( nl->Third( first ) ) == BoolType && nl->IsAtom( nl->Fourth( first ) ) && nl->AtomType( nl->Fourth( first ) ) == BoolType ) { CcReal *start = (CcReal *)InCcReal( nl->TheEmptyList(), nl->First( first ), errorPos, errorInfo, correct ).addr; if( !correct ) { errmsg = "InConstLengthUnit(): Error in first instant."; errorInfo = nl->Append(errorInfo, nl->StringAtom(errmsg)); delete start; return SetWord( Address(0) ); } CcReal *end = (CcReal *)InCcReal( nl->TheEmptyList(), nl->Second( first ), errorPos, errorInfo, correct ).addr; if( !correct ) { errmsg = "InConstLengthUnit(): Error in second instant."; errorInfo = nl->Append(errorInfo, nl->StringAtom(errmsg)); delete start; delete end; return SetWord( Address(0) ); } // get closedness parameters bool lc = nl->BoolValue( nl->Third( first ) ); bool rc = nl->BoolValue( nl->Fourth( first ) ); LInterval linterval( *start, *end, lc, rc ); delete start; delete end; // check, wether linterval is well defined correct = linterval.IsValid(); if ( !correct ) { errmsg = "InConstLengthUnit(): Non valid length interval."; errorInfo = nl->Append(errorInfo, nl->StringAtom(errmsg)); return SetWord( Address(0) ); } //2. deal with the alpha value Alpha *value = (Alpha *)InFun( nl->TheEmptyList(), nl->Second( instance ), errorPos, errorInfo, correct ).addr; //3. create the class object if( correct ) { ConstLengthUnit *constunit = new ConstLengthUnit( linterval, *value ); if( constunit->IsValid() ) { delete value; return SetWord( constunit ); } delete constunit; } delete value; } } else if ( listutils::isSymbolUndefined( instance ) ) { ConstLengthUnit *constunit = new ConstLengthUnit(); constunit->SetDefined(false); constunit->lengthInterval= LInterval(true); correct = true; return (SetWord( constunit )); } errmsg = "InConstLengthUnit(): Error in representation."; errorInfo = nl->Append(errorInfo, nl->StringAtom(errmsg)); correct = false; return SetWord( Address(0) ); } /* 1.1.3 ~Create~-function */ template Word CreateConstLengthUnit( const ListExpr typeInfo ) { return (SetWord( new ConstLengthUnit(false) )); } /* 1.1.4 ~Delete~-function */ template void DeleteConstLengthUnit( const ListExpr typeInfo, Word& w ) { delete (ConstLengthUnit *)w.addr; w.addr = 0; } /* 1.1.5 ~Close~-function */ template void CloseConstLengthUnit( const ListExpr typeInfo, Word& w ) { delete (ConstLengthUnit *)w.addr; w.addr = 0; } /* 1.1.6 ~Clone~-function */ template Word CloneConstLengthUnit( const ListExpr typeInfo, const Word& w ) { ConstLengthUnit *constunit = (ConstLengthUnit *)w.addr; return SetWord( new ConstLengthUnit( *constunit ) ); } /* 1.1.7 ~Sizeof~-function */ template int SizeOfConstLengthUnit() { return sizeof(ConstLengthUnit); } /* 1.1.8 ~Cast~-function */ template void* CastConstLengthUnit(void* addr) { return new (addr) ConstLengthUnit; } #endif //CONST_LENGTH_UNIT_H