Initial commitv8.0

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;
+}
+