summaryrefslogtreecommitdiffstats
path: root/c++/src/H5DataSpace.cpp
diff options
context:
space:
mode:
authorBinh-Minh Ribler <bmribler@hdfgroup.org>2000-12-07 00:04:08 (GMT)
committerBinh-Minh Ribler <bmribler@hdfgroup.org>2000-12-07 00:04:08 (GMT)
commitf148ff3caf533e9f6029798617f0a8087bcd6c05 (patch)
tree00bb6ca4d0e50aa0e591eed6a0d739c04c93c5e7 /c++/src/H5DataSpace.cpp
parent7df8cd5cfe22372f603ea058334647fe4017008e (diff)
downloadhdf5-f148ff3caf533e9f6029798617f0a8087bcd6c05.zip
hdf5-f148ff3caf533e9f6029798617f0a8087bcd6c05.tar.gz
hdf5-f148ff3caf533e9f6029798617f0a8087bcd6c05.tar.bz2
[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)
Diffstat (limited to 'c++/src/H5DataSpace.cpp')
-rw-r--r--c++/src/H5DataSpace.cpp323
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