[svn-r3080]

Purpose:
	Support portability
Description:
	I forgot that source file extension .C will not work on Windows.
Solution:
	Changed all source file from *.C to *.cpp for portability.
Platforms tested:
	arabica (sparc-sun-solaris 2.7)

1 files changed, 323 insertions, 0 deletions

diff --git a/c++/src/H5DataSpace.cpp b/c++/src/H5DataSpace.cpp
new file mode 100644
index 0000000..746dc39
--- /dev/null
+++ b/c++/src/H5DataSpace.cpp
@@ -0,0 +1,323 @@
+#include <string>
+
+#include "H5Include.h"
+#include "H5Exception.h"
+#include "H5RefCounter.h"
+#include "H5IdComponent.h"
+#include "H5Idtemplates.h"
+#include "H5DataSpace.h"
+
+#ifndef H5_NO_NAMESPACE
+namespace H5 {
+#endif
+
+const DataSpace DataSpace::ALL( H5S_ALL );
+
+// Default constructor
+DataSpace::DataSpace() : IdComponent() {}
+
+// This constructor creates a DataSpace instance, given a dataspace type
+DataSpace::DataSpace( H5S_class_t type ) : IdComponent()
+{
+   id = H5Screate( type );
+   if( id <= 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Creates a new simple data space and opens it for access.
+DataSpace::DataSpace( int rank, const hsize_t * dims, const hsize_t * maxdims) : IdComponent()
+{
+   id = H5Screate_simple( rank, dims, maxdims );
+   if( id <= 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+/* Constructor that takes an existing dataspace id
+Description:
+	Uses an HDF5 id to create a DataSpace identifier instance.  This id can be either an existing dataspace id or a default dataspace id.  Design note: in the case of default dataspace, the identifier still has reference counter; the p_close function will take care of not to call H5Sclose on the default id.
+*/
+DataSpace::DataSpace( const hid_t space_id ) : IdComponent( space_id ) {}
+
+// Copy constructor: makes a copy of the original DataSpace instance
+DataSpace::DataSpace( const DataSpace& original ) : IdComponent( original ) {}
+
+// Makes a copy of an existing dataspace
+void DataSpace::copy( const DataSpace& like_space )
+{
+   // reset the identifier of this instance - send 'this' in so that
+   // H5Sclose can be called appropriately
+   resetIdComponent( this );
+
+   // call C routine to copy the dataspace 
+   id = H5Scopy( like_space.getId() );
+
+   // points to the same ref counter
+   ref_count = like_space.ref_count;
+
+   // increment ref counter to indicate additional references to this id
+   ref_count->increment();
+
+   if( id <= 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Determines whether this dataspace is a simple dataspace.
+bool DataSpace::isSimple () const
+{
+   htri_t simple = H5Sis_simple( id );
+   if( simple > 0 )
+      return true;
+   else if( simple == 0 )
+      return false;
+   else
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Sets the offset of this simple dataspace.
+void DataSpace::offsetSimple ( const hssize_t* offset ) const
+{
+   herr_t ret_value = H5Soffset_simple( id, offset );
+   if( ret_value < 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Retrieves dataspace dimension size and maximum size
+int DataSpace::getSimpleExtentDims ( hsize_t *dims, hsize_t *maxdims ) const
+{
+   int ndims = H5Sget_simple_extent_dims( id, dims, maxdims );
+   if( ndims < 0 )
+   {
+      throw DataSpaceIException();
+   }
+   return( ndims );
+}
+
+// Determines the dimensionality of a dataspace
+int DataSpace::getSimpleExtentNdims () const
+{
+   int ndims = H5Sget_simple_extent_ndims( id );
+   if( ndims < 0 )
+   {
+      throw DataSpaceIException();
+   }
+   return( ndims );
+}
+
+// Determines the number of elements in a dataspace
+// 12/05/00: due to C API change
+//	return type hssize_t vs. hsize_t
+//	num_elements = -1 when failure occurs vs. 0
+hssize_t DataSpace::getSimpleExtentNpoints () const
+{
+   hssize_t num_elements = H5Sget_simple_extent_npoints( id );
+
+   if( num_elements > -1 )
+      return( num_elements );
+   else
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Determine the current class of a dataspace
+H5S_class_t DataSpace::getSimpleExtentType () const
+{
+   H5S_class_t class_name = H5Sget_simple_extent_type( id );
+   if( class_name == H5S_NO_CLASS )
+   {
+      throw DataSpaceIException();
+   }
+   return( class_name );
+}
+
+// Copies the extent of a dataspace
+void DataSpace::extentCopy ( DataSpace& dest_space ) const
+{
+   hid_t dest_space_id = dest_space.getId();
+   herr_t ret_value = H5Sextent_copy( dest_space_id, id );
+   if( ret_value < 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Sets or resets the size of an existing dataspace
+void DataSpace::setExtentSimple( int rank, const hsize_t *current_size, const hsize_t *maximum_size ) const
+{
+   herr_t ret_value;
+   ret_value = H5Sset_extent_simple( id, rank, current_size, maximum_size );
+   if( ret_value < 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Removes the extent from a dataspace
+void DataSpace::setExtentNone () const
+{
+   herr_t ret_value = H5Sset_extent_none( id );
+   if( ret_value < 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Determines the number of elements in a dataspace selection
+hssize_t DataSpace::getSelectNpoints () const
+{
+   hssize_t num_elements = H5Sget_select_npoints( id );
+   if( num_elements < 0 )
+   {
+      throw DataSpaceIException();
+   }
+   return( num_elements );
+}
+
+// Get number of hyperslab blocks
+hssize_t DataSpace::getSelectHyperNblocks () const
+{
+   hssize_t num_blocks = H5Sget_select_hyper_nblocks( id );
+   if( num_blocks < 0 )
+   {
+      throw DataSpaceIException();
+   }
+   return( num_blocks );
+}
+
+// Gets the list of hyperslab blocks currently selected
+void DataSpace::getSelectHyperBlocklist( hsize_t startblock, hsize_t numblocks, hsize_t *buf ) const
+{
+   herr_t ret_value;
+   ret_value = H5Sget_select_hyper_blocklist( id, startblock, numblocks, buf );
+   if( ret_value < 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Gets the number of element points in the current selection
+hssize_t DataSpace::getSelectElemNpoints () const
+{
+   hssize_t num_points = H5Sget_select_elem_npoints( id );
+   if( num_points < 0 )
+   {
+      throw DataSpaceIException();
+   }
+   return( num_points );
+}
+
+// Gets the list of element points currently selected
+void DataSpace::getSelectElemPointlist ( hsize_t startpoint, hsize_t numpoints, hsize_t *buf ) const
+{
+   herr_t ret_value;
+   ret_value = H5Sget_select_elem_pointlist( id, startpoint, numpoints, buf );
+   if( ret_value < 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Gets the bounding box containing the current selection
+void DataSpace::getSelectBounds ( hsize_t* start, hsize_t* end ) const
+{
+   herr_t ret_value = H5Sget_select_bounds( id, start, end );
+   if( ret_value < 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Selects array elements to be included in the selection for a dataspace
+void DataSpace::selectElements ( H5S_seloper_t op, const size_t num_elements, const hssize_t *coord[ ] ) const
+{
+   herr_t ret_value;
+   ret_value = H5Sselect_elements( id, op, num_elements, coord );
+   if( ret_value < 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Selects the entire dataspace
+void DataSpace::selectAll () const
+{
+   herr_t ret_value = H5Sselect_all( id );
+   if( ret_value < 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+//Resets the selection region to include no elements
+void DataSpace::selectNone () const
+{
+  herr_t ret_value = H5Sselect_none( id );
+   if( ret_value < 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Verifies that the selection is within the extent of the dataspace
+bool DataSpace::selectValid () const
+{
+  htri_t ret_value = H5Sselect_valid( id );
+   if( ret_value > 0 )
+      return true;
+   else if( ret_value == 0 )
+      return false;
+   else
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Selects a hyperslab region to add to the current selected region
+void DataSpace::selectHyperslab( H5S_seloper_t op, const hsize_t *count, const hssize_t *start, const hsize_t *stride, const hsize_t *block ) const
+{
+   herr_t ret_value;
+   ret_value = H5Sselect_hyperslab( id, op, start, stride, count, block );
+   if( ret_value < 0 )
+   {
+      throw DataSpaceIException();
+   }
+}
+
+// Closes the dataspace if it is not a constant
+void DataSpace::p_close() const
+{
+   hid_t space_id = id;
+   if( space_id != H5S_ALL ) // not a constant, should call H5Sclose
+   {
+      herr_t ret_value = H5Sclose( space_id );
+      if( ret_value < 0 )
+      {
+         throw DataSpaceIException();
+      }
+   }
+}
+
+// The destructor of this instance calls IdComponent::reset to
+// reset its identifier - no longer true
+// Older compilers (baldric) don't support template member functions
+// and IdComponent::reset is one; so at this time, the resetId is not
+// a member function so it can be template to work around that problem.
+DataSpace::~DataSpace()
+{  
+   // The dataspace id will be closed properly
+   resetIdComponent( this );
+}  
+
+#ifndef H5_NO_NAMESPACE
+} // end namespace
+#endif