diff options
author | Constantin Jucovschi <cj@ubuntu.localdomain> | 2009-04-24 07:20:22 -0400 |
---|---|---|
committer | Constantin Jucovschi <cj@ubuntu.localdomain> | 2009-04-24 07:20:22 -0400 |
commit | 8f27e65bddd7d4b8515ce620fb485fdd78fcdf89 (patch) | |
tree | bd328a4dd4f92d32202241b5e3a7f36177792c5f /raslib/structure.cc | |
download | rasdaman-upstream-8f27e65bddd7d4b8515ce620fb485fdd78fcdf89.tar.gz rasdaman-upstream-8f27e65bddd7d4b8515ce620fb485fdd78fcdf89.tar.xz rasdaman-upstream-8f27e65bddd7d4b8515ce620fb485fdd78fcdf89.zip |
Initial commitv8.0
Diffstat (limited to 'raslib/structure.cc')
-rw-r--r-- | raslib/structure.cc | 282 |
1 files changed, 282 insertions, 0 deletions
diff --git a/raslib/structure.cc b/raslib/structure.cc new file mode 100644 index 0000000..4c81015 --- /dev/null +++ b/raslib/structure.cc @@ -0,0 +1,282 @@ +/* +* 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>. +/ +/** + * SOURCE: structure.cc + * + * MODULE: raslib + * CLASS: r_Structure + * + * COMMENTS: + * +*/ + +#include "raslib/structure.hh" +#include "raslib/primitive.hh" +#include "raslib/structuretype.hh" +#include "raslib/error.hh" +#include "raslib/rminit.hh" +#include "mymalloc/mymalloc.h" + +#ifdef __VISUALC__ +#include <strstrea.h> +#else +#include <strstream> +#endif +#include <string.h> +#include <fstream> +#include <stdlib.h> + + + + +r_Structure::r_Structure( const char* newBuffer, const r_Structure_Type* newType ) + : r_Scalar( newType ), + numElements(0), + elements(NULL), + valueBuffer(NULL) +{ + if( newType ) + { + + numElements = newType->count_elements(); + elements = new r_Scalar*[numElements]; + + valueBuffer = (char*)mymalloc(newType->size()); + + if(newBuffer) + memcpy(valueBuffer, newBuffer, newType->size()); + else + memset(valueBuffer, 0, newType->size()); + + r_Structure_Type::attribute_iterator iter( newType->defines_attribute_begin() ); + + for( int i=0; iter != newType->defines_attribute_end(); iter++, i++ ) + { + if( (*iter).type_of().type_id() == r_Type::STRUCTURETYPE ) + elements[i] = new r_Structure( valueBuffer + (*iter).offset(), (r_Structure_Type*)&((*iter).type_of()) ); + else + elements[i] = new r_Primitive( valueBuffer + (*iter).offset(), (r_Primitive_Type*)&((*iter).type_of()) ); + } + } +} + + + +r_Structure::r_Structure( const r_Structure& obj ) + : r_Scalar( obj ), + numElements(obj.numElements), + elements(NULL), + valueBuffer(NULL) +{ + if( numElements ) + { + elements = new r_Scalar*[numElements]; + + for( unsigned int i=0; i < numElements; i++ ) + elements[i] = obj.elements[i]->clone(); + } + + valueBuffer = (char*) mymalloc(valueType->size()); + + if(obj.valueBuffer) + memcpy(valueBuffer, obj.valueBuffer, valueType->size()); + else + memset(valueBuffer, 0, valueType->size()); +} + + + +r_Structure::~r_Structure() +{ + if( numElements ) + { + for( unsigned int i =0; i < numElements; i++ ) + delete elements[i]; + + delete[] elements; + } + + if(valueBuffer) + free(valueBuffer); +} + + + +r_Scalar* +r_Structure::clone() const +{ + return new r_Structure( *this ); +} + + + +const r_Structure& +r_Structure::operator=( const r_Structure& obj ) +{ + if( this != &obj ) + { + // assign scalar + r_Scalar::operator=( obj ); + + if( numElements ) + { + for( unsigned int i =0; i < numElements; i++ ) + delete elements[i]; + + delete[] elements; + } + + if( obj.numElements ) + { + numElements = obj.numElements; + elements = new r_Scalar*[numElements]; + + for( unsigned int i =0; i < numElements; i++ ) + elements[i] = obj.elements[i]->clone(); + } + + if(valueBuffer) + free(valueBuffer); + + valueBuffer = (char*) mymalloc(valueType->size()); + + if(obj.valueBuffer) + memcpy(valueBuffer, obj.valueBuffer, valueType->size()); + else + memset(valueBuffer, 0, valueType->size()); + + } + + return *this; +} + + + +unsigned int +r_Structure::count_elements() const +{ + return numElements; +} + +const char* +r_Structure::get_buffer() const +{ + memset(valueBuffer, 0, valueType->size()); + + r_Structure_Type::attribute_iterator iter( ((r_Structure_Type*)valueType)->defines_attribute_begin() ); + + for( int i=0; iter != ((r_Structure_Type*)valueType)->defines_attribute_end(); iter++, i++ ) + if( (*iter).type_of().type_id() == r_Type::STRUCTURETYPE ) + memcpy( valueBuffer + (*iter).offset(), ((r_Structure*)elements[i])->get_buffer(), elements[i]->get_type()->size()); + else + memcpy( valueBuffer + (*iter).offset(), ((r_Primitive*)elements[i])->get_buffer(), elements[i]->get_type()->size()); + + return valueBuffer; +} + + +bool +r_Structure::isStructure() const +{ + return true; +} + + + +const r_Scalar& +r_Structure::operator[]( unsigned int index ) const throw( r_Error ) +{ + if( !valueType ) + { + RMInit::logOut << "r_Structure::operator[](" << index << ") const value type is NULL" << endl; + throw r_Error( r_Error::r_Error_TypeInvalid ); + } + + if( index > numElements ) + { + RMInit::logOut << "r_Structure::operator[](" << index << ") const index is out of bounds (" << numElements - 1 << ")" << endl; + throw r_Eindex_violation( 0, numElements, index ); + } + + return *(elements[index]); +} + + + +const r_Scalar& +r_Structure::operator[]( const char* name ) const throw( r_Error ) +{ + if( !valueType ) + { + RMInit::logOut << "r_Structure::operator[](" << name << ") value type is NULL" << endl; + r_Error err( r_Error::r_Error_TypeInvalid ); + throw( err ); + } + + r_Structure_Type* structType = (r_Structure_Type*)valueType; + + r_Structure_Type::attribute_iterator iter( structType->defines_attribute_begin() ); + + int index = 0; + for( ; iter != structType->defines_attribute_end() && strcmp((*iter).name(), name); iter++, index++ ); + + if( iter == structType->defines_attribute_end() ) + { + RMInit::logOut << "r_Structure::operator[](" << name << ") name is not valid" << endl; + r_Error err( r_Error::r_Error_NameInvalid ); + throw( err ); + } + + return *(elements[index]); +} + + +void +r_Structure::print_status( std::ostream& s ) const +{ + if( valueType ) + { + s << "{ " << std::flush; + + for( unsigned int i =0; i < numElements; i++ ) + { + s << *(elements[i]) << std::flush; + + if( i < numElements-1 ) + s << ", " << std::flush; + } + + s << " }" << std::flush; + } + else + s << "<nn>" << std::flush; +} + + + +std::ostream& operator<<( std::ostream& s, const r_Structure& obj ) +{ + obj.print_status( s ); + return s; +} + |