Initial commitv8.0

1 files changed, 623 insertions, 0 deletions

diff --git a/raslib/endian.cc b/raslib/endian.cc
new file mode 100644
index 0000000..45837a1
--- /dev/null
+++ b/raslib/endian.cc
@@ -0,0 +1,623 @@
+/*
+* 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>.
+/
+/**
+ * INCLUDE: endian.cc
+ *
+ * MODULE:  raslib
+ * CLASS:   r_Endian
+ *
+ * COMMENTS:
+ *		None
+*/
+
+#include <string.h>
+
+
+#include "raslib/endian.hh"
+#include "raslib/rmdebug.hh"
+#include "raslib/minterval.hh"
+#include "raslib/primitivetype.hh"
+#include "raslib/structuretype.hh"
+#include "raslib/miter.hh"
+
+
+
+
+/*
+ *  Inline code used in several places in the r_Endian class
+ */
+
+static inline r_Octet eswap( r_Octet val )
+{
+  return val;
+}
+
+static inline void eswap( r_Octet val, void *dest )
+{
+  r_Char *d = (r_Char *)dest;
+  *d = val;
+}
+
+static inline r_Short eswap( r_Short val )
+{
+  return (r_Short)(((val & 0xff) << 8) | ((val >> 8) & 0xff));
+}
+
+static inline r_UShort eswap( r_UShort val )
+{
+  return (r_UShort)(((val & 0xff) << 8) | ((val >> 8) & 0xff));
+}
+
+static inline void eswap( r_Short val, void *dest )
+{
+  r_Short *d = (r_Short *)dest;
+  *d = eswap(val);
+}
+
+static inline void eswap( r_UShort val, void *dest )
+{
+  r_UShort *d = (r_UShort *)dest;
+  *d = eswap(val);
+}
+
+static inline r_Long eswap( r_Long val )
+{
+  return (r_Long)(((val & 0xff) << 24) | ((val & 0xff00) << 8) |
+	       ((val >> 8) & 0xff00) | ((val >> 24) & 0xff));
+}
+
+static inline r_ULong eswap( r_ULong val )
+{
+  return (r_ULong)(((val & 0xff) << 24) | ((val & 0xff00) << 8) |
+	       ((val >> 8) & 0xff00) | ((val >> 24) & 0xff));
+}
+
+static inline void eswap( r_Long val, void *dest )
+{
+  r_Long *d = (r_Long *)dest;
+  *d = eswap(val);
+}
+
+static inline void eswap( r_ULong val, void *dest )
+{
+  r_ULong *d = (r_ULong *)dest;
+  *d = eswap(val);
+}
+
+/*
+these types are not supported
+static inline long eswap( long val )
+{
+  return (long)(((val & 0xff) << 24) | ((val & 0xff00) << 8) |
+		((val >> 8) & 0xff00) | ((val >> 24) & 0xff));
+}
+
+static inline r_ULong eswap( r_ULong val )
+{
+  return (r_ULong)(((val & 0xff) << 24) | ((val & 0xff00) << 8) |
+		((val >> 8) & 0xff00) | ((val >> 24) & 0xff));
+}
+
+static inline void eswap( long val, void *dest )
+{
+  long *d = (long *)dest;
+  *d = eswap(val);
+}
+
+static inline void eswap( r_ULong val, void *dest )
+{
+  r_ULong *d = (r_ULong *)dest;
+  *d = eswap(val);
+}
+*/
+
+static inline r_Float eswap( r_Float val )
+{
+  r_Long *ptr = (r_Long*)&val;
+  r_Float result;
+
+  eswap(*ptr, &result);
+
+  return result;
+}
+
+static inline void eswap( r_Float val, void *dest )
+{
+  r_Long *ptr = (r_Long*)&val;
+
+  eswap(*ptr, dest);
+}
+
+
+#ifndef __GNUG__
+inline
+#endif
+static r_Double eswap( r_Double val )
+{
+  r_Long *ptr = (r_Long*)&val;
+  r_Double result;
+  eswap(ptr[0], ((r_Octet*)&result)+sizeof(r_Long));
+  eswap(ptr[1], (r_Octet*)&result);
+/*
+#ifndef DECALPHA
+  eswap(ptr[0], ((r_Octet*)&result)+sizeof(long));
+  eswap(ptr[1], (r_Octet*)&result);
+#else
+  eswap(*ptr, &result);
+#endif
+*/
+  return result;
+}
+
+#ifndef __GNUG__
+inline
+#endif
+static void eswap( r_Double val, void *dest )
+{
+  r_Long *ptr = (r_Long*)&val;
+  eswap(ptr[0], ((r_Octet*)dest)+sizeof(r_Long));
+  eswap(ptr[1], dest);
+/*
+#ifndef DECALPHA
+  eswap(ptr[0], ((r_Octet*)dest)+sizeof(long));
+  eswap(ptr[1], dest);
+#else
+  eswap(*ptr, dest);
+#endif
+*/
+}
+
+
+/*
+ *  Template functions used throughout the code
+ */
+
+// template for special linear iteration
+template<class T>
+void swap_array_templ( r_Bytes size, T *dest, const T *src)
+{
+  const T *sptr = src;
+  T *dptr = dest;
+  r_Bytes ctr;
+  
+  for (ctr = 0; ctr < size; ctr += sizeof(T), sptr++, dptr++)
+    eswap(*sptr, dptr);
+}
+
+
+// template for identical domains for src and dest
+template<class T>
+void swap_array_templ(r_Miter &iter, T *destBase, const T *srcBase)
+{
+  while (!iter.isDone())
+  {
+    const T *src = (const T*)iter.nextCell();
+    eswap(*src, destBase + (src - srcBase));
+  }
+}
+
+
+// template for generic iteration (src is just a dummy here)
+template<class T>
+void swap_array_templ(r_Miter &siter, r_Miter &diter, const T *srcBase)
+{
+  while (!siter.isDone())
+  {
+    const T *src = (const T*)siter.nextCell();
+    T *dest = (T*)diter.nextCell();
+    eswap(*src, dest);
+  }
+}
+
+// force the instantiations; we only need the templates r_Longernally anyway
+template void swap_array_templ(r_Bytes, r_Short *, const r_Short *);
+template void swap_array_templ(r_Bytes, r_UShort *, const r_UShort *);
+template void swap_array_templ(r_Bytes, r_Long *, const r_Long *);
+template void swap_array_templ(r_Bytes, r_ULong *, const r_ULong *);
+/*
+template void swap_array_templ(r_Bytes, long *, const long *);
+template void swap_array_templ(r_Bytes, r_ULong *, const r_ULong *);
+*/
+template void swap_array_templ(r_Bytes, r_Float *, const r_Float *);
+template void swap_array_templ(r_Bytes, r_Double *, const r_Double *);
+template void swap_array_templ(r_Miter &, r_Octet *, const r_Octet *);
+template void swap_array_templ(r_Miter &, r_Short *, const r_Short *);
+template void swap_array_templ(r_Miter &, r_Long *, const r_Long *);
+template void swap_array_templ(r_Miter &, r_Float *, const r_Float *);
+template void swap_array_templ(r_Miter &, r_Double *, const r_Double *);
+template void swap_array_templ(r_Miter &, r_Miter &, const r_Octet *);
+template void swap_array_templ(r_Miter &, r_Miter &, const r_Short *);
+template void swap_array_templ(r_Miter &, r_Miter &, const r_Long *);
+template void swap_array_templ(r_Miter &, r_Miter &, const r_Float *);
+template void swap_array_templ(r_Miter &, r_Miter &, const r_Double *);
+
+
+
+
+
+/*
+ *  r_Endian members
+ */
+
+r_Short r_Endian::swap( r_Short val )
+{
+  return eswap(val);
+}
+
+r_UShort r_Endian::swap( r_UShort val )
+{
+  return eswap(val);
+}
+
+r_Long r_Endian::swap( r_Long val )
+{
+  return eswap(val);
+}
+
+r_ULong r_Endian::swap( r_ULong val )
+{
+  return eswap(val);
+}
+/*
+long r_Endian::swap( long val )
+{
+  return eswap(val);
+}
+
+r_ULong r_Endian::swap( r_ULong val )
+{
+  return eswap(val);
+}
+*/
+r_Float r_Endian::swap( r_Float val )
+{
+  return eswap(val);
+}
+
+r_Double r_Endian::swap( r_Double val )
+{
+  return eswap(val);
+}
+
+
+r_Endian::r_Endianness r_Endian::get_endianness( void )
+{
+#ifdef LITTLE_ENDIAN
+  return r_Endian_Little;
+#else
+  return r_Endian_Big;
+#endif
+}
+
+
+
+/*
+ *  Simplest array swapping: linear buffer filled with atomic type
+ */
+
+void r_Endian::swap_array( const r_Primitive_Type *type, r_Bytes size, const void *src, void *dest )
+{
+  switch (type->type_id())
+  {
+    case r_Primitive_Type::BOOL:
+    case r_Primitive_Type::CHAR:
+    case r_Primitive_Type::OCTET:
+      if (src != (const void*)dest)
+      {
+	// change of endianness on 1 byte data is a NULL operation.
+	// if src and dest differ, we have to _copy_, though.
+	memcpy(dest, src, size);
+      }
+      break;
+    case r_Primitive_Type::SHORT:
+      swap_array_templ(size, (r_Short*)dest, (const r_Short*)src);
+      break;
+    case r_Primitive_Type::USHORT:
+      swap_array_templ(size, (r_UShort*)dest, (const r_UShort*)src);
+      break;
+    case r_Primitive_Type::LONG:
+      swap_array_templ(size, (r_Long*)dest, (const r_Long*)src);
+      break;
+    case r_Primitive_Type::ULONG:
+      swap_array_templ(size, (r_ULong*)dest, (const r_ULong*)src);
+      break;
+    case r_Primitive_Type::FLOAT:
+    case r_Primitive_Type::COMPLEXTYPE1:
+      swap_array_templ(size, (r_Float*)dest, (const r_Float*)src);
+      break;
+    case r_Primitive_Type::DOUBLE:
+    case r_Primitive_Type::COMPLEXTYPE2:
+      swap_array_templ(size, (r_Double*)dest, (const r_Double*)src);
+      break;
+    default:
+      RMDBGONCE(3, RMDebug::module_raslib, "r_Endian", "swap_array(type, size, src, dest) bad typeId " << type->type_id());    
+      break;
+  }
+}
+
+
+/*
+ *  Same functionality as function above, but with the types given implicitly
+ *  by the parameters
+ */
+
+// Dummies, but useful when templates are used
+void r_Endian::swap_array( r_Bytes size, const r_Octet *src, r_Octet *dest )
+{
+}
+
+void r_Endian::swap_array( r_Bytes size, const r_Char *src, r_Char *dest )
+{
+}
+
+// Here go the real ones...
+void r_Endian::swap_array( r_Bytes size, const r_Short *src, r_Short *dest )
+{
+  swap_array_templ(size, dest, src);
+}
+
+void r_Endian::swap_array( r_Bytes size, const r_UShort *src, r_UShort *dest )
+{
+  swap_array_templ(size, dest, src);
+}
+
+void r_Endian::swap_array( r_Bytes size, const r_Long *src, r_Long *dest )
+{
+  swap_array_templ(size, dest, src);
+}
+
+void r_Endian::swap_array( r_Bytes size, const r_ULong *src, r_ULong *dest )
+{
+  swap_array_templ(size, dest, src);
+}
+/*
+void r_Endian::swap_array( r_Bytes size, const long *src, long *dest )
+{
+  swap_array_templ(size, dest, src);
+}
+
+void r_Endian::swap_array( r_Bytes size, const r_ULong *src, r_ULong *dest )
+{
+  swap_array_templ(size, dest, src);
+}
+*/
+void r_Endian::swap_array( r_Bytes size, const r_Float *src, r_Float *dest )
+{
+  swap_array_templ(size, dest, src);
+}
+
+void r_Endian::swap_array( r_Bytes size, const r_Double *src, r_Double *dest )
+{
+  swap_array_templ(size, dest, src);
+}
+
+
+/*
+ *  Same functionality as above, but with the type size given as parameter
+ */
+
+void r_Endian::swap_array( r_Bytes size, r_Bytes tsize, const void *src, void *dest )
+{
+  switch (tsize)
+  {
+    case 2:
+      swap_array_templ(size, (r_Short*)dest, (const r_Short*)src);
+      break;
+    case 4:
+      swap_array_templ(size, (r_Long*)dest, (const r_Long*)src);
+      break;
+    case 8:
+    case 16:	// complexd
+      swap_array_templ(size, (r_Double*)dest, (const r_Double*)src);
+      break;
+    default:
+      break;
+  }
+}
+
+
+
+/*
+ *  ``Half-generic'': array with arbitrary total domain and iteration
+ *  domain, but same domains for src and dest
+ */
+void r_Endian::swap_array( const r_Primitive_Type *type, const r_Minterval &srcDom, const r_Minterval &srcIterDom, const void *src, void *dest, r_ULong step )
+{
+  if ((srcDom == srcIterDom) && (step == type->size()))
+  {
+    r_ULong size = step * srcDom.cell_count();
+
+    swap_array(type, size, src, dest);
+  }
+  else
+  {
+    r_Miter iter(&srcIterDom, &srcDom, step, (const char*)src);
+
+    switch (type->type_id())
+    {
+      case r_Primitive_Type::BOOL:
+      case r_Primitive_Type::CHAR:
+      case r_Primitive_Type::OCTET:
+	if (src != (const void*)dest)
+	{
+	  swap_array_templ(iter, (r_Octet*)dest, (const r_Octet*)src);
+	}
+	break;
+      case r_Primitive_Type::SHORT:   
+	swap_array_templ(iter, (r_Short*)dest, (const r_Short*)src);
+	break;
+      case r_Primitive_Type::USHORT:
+	swap_array_templ(iter, (r_UShort*)dest, (const r_UShort*)src);
+	break;
+      case r_Primitive_Type::LONG:
+	swap_array_templ(iter, (r_Long*)dest, (const r_Long*)src);
+	break;
+      case r_Primitive_Type::ULONG:
+	swap_array_templ(iter, (r_ULong*)dest, (const r_ULong*)src);
+	break;
+      case r_Primitive_Type::FLOAT:
+      case r_Primitive_Type::COMPLEXTYPE1:
+	swap_array_templ(iter, (r_Float*)dest, (const r_Float*)src);
+	break;
+      case r_Primitive_Type::DOUBLE:
+      case r_Primitive_Type::COMPLEXTYPE2:
+	swap_array_templ(iter, (r_Double*)dest, (const r_Double*)src);
+	break;
+     default:
+        RMDBGONCE(3, RMDebug::module_raslib, "r_Endian", "swap_array(type, srcdom, srciterdom, src,  dest, step) bad typeId " << type->type_id());    
+        break;	
+    }
+  }
+}
+
+
+static void swap_array_struct( const r_Structure_Type *structType, const r_Minterval &srcDom, const r_Minterval &srcIterDom, const void *src, void *dest, r_ULong step )
+{
+  r_Structure_Type::attribute_iterator iter(structType->defines_attribute_begin());
+
+  while (iter != structType->defines_attribute_end())
+  {
+    r_Type *newType = (*iter).type_of().clone();
+    const void *srcPtr = (const void*)(((const r_Octet*)src) + (*iter).offset());
+    void *destPtr = (void*)(((r_Octet*)dest) + (*iter).offset());
+    if (newType->isStructType())
+      swap_array_struct((const r_Structure_Type*)newType, srcDom, srcIterDom, srcPtr, destPtr, step);
+    else
+      r_Endian::swap_array((const r_Primitive_Type*)newType, srcDom, srcIterDom, srcPtr, destPtr, step);
+    delete newType;
+    iter++;
+  }
+}
+
+
+void r_Endian::swap_array( const r_Base_Type *type, const r_Minterval &srcDom, const r_Minterval &srcIterDom, const void *src, void *dest )
+{
+  if (type->isStructType())
+    swap_array_struct((const r_Structure_Type*)type, srcDom, srcIterDom, src, dest, type->size());
+  else
+    swap_array((const r_Primitive_Type*)type, srcDom, srcIterDom, src, dest, type->size());
+}
+
+
+
+
+/*
+ *  Fully generic: different total domain and iteration domain for both
+ *  src and dest. Beware that the number of cells in the iteration domains
+ *  for src and dest must be identical!
+ */
+
+void r_Endian::swap_array( const r_Primitive_Type *type, const r_Minterval &srcDom, const r_Minterval &srcIterDom, const r_Minterval &destDom, const r_Minterval &destIterDom, const void *src, void *dest, r_ULong step )
+{
+  /// check if the whole thing reduces to a linear scan
+  if ((srcDom == srcIterDom) && (step == type->size()))
+  {
+    r_ULong size = step * srcDom.cell_count();
+
+    swap_array(type, size, src, dest);
+  }
+  /// no, generic code...
+  else
+  {
+    r_Miter siter(&srcIterDom, &srcDom, (r_Long)step, (const char*)src);
+    r_Miter diter(&destIterDom, &destDom, (r_Long)step, (const char*)dest);
+
+    switch (type->type_id())
+    {
+      case r_Primitive_Type::BOOL:
+      case r_Primitive_Type::CHAR:
+      case r_Primitive_Type::OCTET:
+	if (src != (const void*)dest)
+	{
+	  swap_array_templ(siter, diter, (const r_Octet*)src);
+	}
+	break;
+      case r_Primitive_Type::SHORT:
+	swap_array_templ(siter, diter, (const r_Short*)src);
+	break;
+      case r_Primitive_Type::USHORT:
+	swap_array_templ(siter, diter, (const r_UShort*)src);
+	break;
+      case r_Primitive_Type::LONG:
+	swap_array_templ(siter, diter, (const r_Long*)src);
+	break;
+      case r_Primitive_Type::ULONG:
+	swap_array_templ(siter, diter, (const r_ULong*)src);
+	break;
+      case r_Primitive_Type::FLOAT:
+      case r_Primitive_Type::COMPLEXTYPE1:
+	swap_array_templ(siter, diter, (const r_Float*)src);
+	break;
+      case r_Primitive_Type::DOUBLE:
+      case r_Primitive_Type::COMPLEXTYPE2:
+	swap_array_templ(siter, diter, (const r_Double*)src);
+	break;
+      default:
+        RMDBGONCE(3, RMDebug::module_raslib, "r_Endian", "swap_array(type, srcdom, srciterdom, destdom, destiterdom, src,  dest, step) bad typeId " << type->type_id());    
+        break;		
+    }
+  }
+}
+
+
+static void swap_array_struct( const r_Structure_Type *structType, const r_Minterval &srcDom, const r_Minterval &srcIterDom, const r_Minterval &destDom, const r_Minterval &destIterDom, const void *src, void *dest, r_ULong step)
+{
+  r_Structure_Type::attribute_iterator iter(structType->defines_attribute_begin());
+
+  while (iter != structType->defines_attribute_end())
+  {
+    r_Type *newType = (*iter).type_of().clone();
+    const void *srcPtr = (const void*)(((const r_Octet*)src) + (*iter).offset());
+    void *destPtr = (void*)(((r_Octet*)dest) + (*iter).offset());
+    if (newType->isStructType())
+      swap_array_struct((const r_Structure_Type*)newType, srcDom, srcIterDom, destDom, destIterDom, srcPtr, destPtr, step);
+    else
+      r_Endian::swap_array((const r_Primitive_Type*)newType, srcDom, srcIterDom, destDom, destIterDom, srcPtr, destPtr, step);
+    delete newType;
+    iter++;
+  }
+}
+
+void r_Endian::swap_array( const r_Base_Type *type, const r_Minterval &srcDom, const r_Minterval &srcIterDom, const r_Minterval &destDom, const r_Minterval &destIterDom, const void *src, void *dest )
+{
+  if (type->isStructType())
+    swap_array_struct((const r_Structure_Type*)type, srcDom, srcIterDom, destDom, destIterDom, src, dest, type->size());
+  else
+    swap_array((const r_Primitive_Type*)type, srcDom, srcIterDom, destDom, destIterDom, src, dest, type->size());
+}
+
+std::ostream& operator<<(std::ostream& s, r_Endian::r_Endianness& e)
+{
+	 switch(e) {
+	   case r_Endian::r_Endian_Little:
+	   	s << "Little_Endian";
+	   	break;
+	   case r_Endian::r_Endian_Big:
+	 	s << "Big_Endian";	 
+	 	break;
+	   default:
+	  	s << "Unkown r_Endiannes";
+	  	break;
+	 }
+	return s;
+}