From b1819710bc3ef8b03e453d177b9a8b308100d96d Mon Sep 17 00:00:00 2001 From: Binh-Minh Ribler Date: Thu, 5 Oct 2017 16:24:25 -0500 Subject: Adding new C++ wrappers Description: - Added wrappers for H5Tencode to class DataType and H5Tdecode to classes DataType and its subclasses. // Creates a binary object description of this datatype. void DataType::encode() // Returns the decoded type from the binary object description. virtual DataType* DataType::decode() const; virtual DataType* ArrayType::decode() const; virtual DataType* CompType::decode() const; virtual DataType* DataType::decode() const; virtual DataType* EnumType::decode() const; virtual DataType* FloatType::decode() const; virtual DataType* IntType::decode() const; virtual DataType* StrType::decode() const; virtual DataType* VarLenType::decode() const; - Replaced existing functions CommonFG::openXxxType with individual data type constructors, XxxType, to improve usability. Platforms tested: Linux/32 2.6 (jam) Linux/64 (platypus) Darwin (osx1010test) --- c++/src/H5ArrayType.cpp | 59 +++++++++++++++++ c++/src/H5ArrayType.h | 8 +++ c++/src/H5Classes.h | 2 +- c++/src/H5CompType.cpp | 60 ++++++++++++++++- c++/src/H5CompType.h | 8 +++ c++/src/H5DataType.cpp | 169 +++++++++++++++++++++++++++++++++++++++++++++-- c++/src/H5DataType.h | 31 +++++++-- c++/src/H5EnumType.cpp | 59 +++++++++++++++++ c++/src/H5EnumType.h | 8 +++ c++/src/H5FloatType.cpp | 59 +++++++++++++++++ c++/src/H5FloatType.h | 8 +++ c++/src/H5IntType.cpp | 59 +++++++++++++++++ c++/src/H5IntType.h | 8 +++ c++/src/H5Location.cpp | 5 +- c++/src/H5Location.h | 77 ++++++++++++--------- c++/src/H5Object.cpp | 36 ++++++++++ c++/src/H5Object.h | 6 +- c++/src/H5StrType.cpp | 59 +++++++++++++++++ c++/src/H5StrType.h | 8 +++ c++/src/H5VarLenType.cpp | 59 +++++++++++++++++ c++/src/H5VarLenType.h | 11 +++ 21 files changed, 754 insertions(+), 45 deletions(-) diff --git a/c++/src/H5ArrayType.cpp b/c++/src/H5ArrayType.cpp index 6d2ca83..6be1a1f 100644 --- a/c++/src/H5ArrayType.cpp +++ b/c++/src/H5ArrayType.cpp @@ -70,6 +70,44 @@ ArrayType::ArrayType(const DataType& base_type, int ndims, const hsize_t* dims) } //-------------------------------------------------------------------------- +// Function: ArrayType overloaded constructor +///\brief Creates an ArrayType instance by opening an HDF5 array datatype +/// given its name, provided as a C character string. +///\param loc - IN: Location of the type +///\param type_name - IN: Array type name +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +// Description +// In 1.8.20, this constructor was introduced and may replace the +// existing function CommonFG::openArrayType(const char*) to +// improve usability. +// -BMR, Sept 2017 +//-------------------------------------------------------------------------- +ArrayType::ArrayType(const H5Location& loc, const char *type_name) : DataType() +{ + id = p_opentype(loc, type_name); +} + +//-------------------------------------------------------------------------- +// Function: ArrayType overloaded constructor +///\brief Creates an ArrayType instance by opening an HDF5 array datatype +/// given its name, provided as an \c H5std_string. +///\param loc - IN: Location of the type +///\param type_name - IN: Array type name +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +// Description +// In 1.8.20, this constructor was introduced and may replace the +// existing function CommonFG::openArrayType(const H5std_string&) to +// improve usability. +// -BMR, Sept 2017 +//-------------------------------------------------------------------------- +ArrayType::ArrayType(const H5Location& loc, const H5std_string& type_name) : DataType() +{ + id = p_opentype(loc, type_name.c_str()); +} + +//-------------------------------------------------------------------------- // Function: ArrayType::operator= ///\brief Assignment operator ///\param rhs - IN: Reference to the existing array datatype @@ -99,6 +137,27 @@ ArrayType& ArrayType::operator=(const ArrayType& rhs) } //-------------------------------------------------------------------------- +// Function: ArrayType::decode +///\brief Returns an ArrayType object via DataType* by decoding the +/// binary object description of this type. +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +//-------------------------------------------------------------------------- +DataType* ArrayType::decode() const +{ + hid_t encoded_arrtype_id = H5I_INVALID_HID; + try { + encoded_arrtype_id = p_decode(); + } + catch (DataTypeIException &err) { + throw; + } + ArrayType *encoded_arrtype = new ArrayType; + encoded_arrtype->p_setId(encoded_arrtype_id); + return(encoded_arrtype); +} + +//-------------------------------------------------------------------------- // Function: ArrayType::getArrayNDims ///\brief Returns the number of dimensions for an array datatype. ///\return Number of dimensions diff --git a/c++/src/H5ArrayType.h b/c++/src/H5ArrayType.h index 6de11f2..952aae1 100644 --- a/c++/src/H5ArrayType.h +++ b/c++/src/H5ArrayType.h @@ -28,9 +28,17 @@ class H5_DLLCPP ArrayType : public DataType { // specified base type. ArrayType(const DataType& base_type, int ndims, const hsize_t* dims); + // Constructors that open an array datatype, given a location. + ArrayType(const H5Location& loc, const char* name); + ArrayType(const H5Location& loc, const H5std_string& name); + // Assignment operator ArrayType& operator=(const ArrayType& rhs); + // Returns an ArrayType object via DataType* by decoding the + // binary object description of this type. + virtual DataType* decode() const; + // Returns the number of dimensions of this array datatype. int getArrayNDims() const; //int getArrayNDims(); // removed 1.8.18 and 1.10.1 diff --git a/c++/src/H5Classes.h b/c++/src/H5Classes.h index 23bff29..6baa3d0 100644 --- a/c++/src/H5Classes.h +++ b/c++/src/H5Classes.h @@ -30,10 +30,10 @@ namespace H5 { class DataSpace; class AtomType; class PredType; - class EnumType; class IntType; class FloatType; class StrType; + class EnumType; class CompType; class AbstractDs; class DataSet; diff --git a/c++/src/H5CompType.cpp b/c++/src/H5CompType.cpp index 16a7d2f..6d879bd 100644 --- a/c++/src/H5CompType.cpp +++ b/c++/src/H5CompType.cpp @@ -84,6 +84,65 @@ CompType::CompType(const DataSet& dataset) : DataType() } //-------------------------------------------------------------------------- +// Function: CompType overloaded constructor +///\brief Creates an CompType instance by opening an HDF5 compound +/// given its name, provided as a C character string. +///\param loc - IN: Location of the type +///\param type_name - IN: Compound type name +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +// Description +// In 1.8.20, this constructor was introduced and may replace the +// existing function CommonFG::openCompType(const char*) to +// improve usability. +// -BMR, Sept 2017 +//-------------------------------------------------------------------------- +CompType::CompType(const H5Location& loc, const char *type_name) : DataType() +{ + id = p_opentype(loc, type_name); +} + +//-------------------------------------------------------------------------- +// Function: CompType overloaded constructor +///\brief Creates an CompType instance by opening an HDF5 compound +/// datatype given its name, provided as an \c H5std_string. +///\param loc - IN: Location of the type +///\param type_name - IN: Compound type name +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +// Description +// In 1.8.20, this constructor was introduced and may replace the +// existing function CommonFG::openCompType(const H5std_string&) to +// improve usability. +// -BMR, Sept 2017 +//-------------------------------------------------------------------------- +CompType::CompType(const H5Location& loc, const H5std_string& type_name) : DataType() +{ + id = p_opentype(loc, type_name.c_str()); +} + +//-------------------------------------------------------------------------- +// Function: CompType::decode +///\brief Returns a CompType object via DataType* by decoding the +/// binary object description of this datatype. +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +//-------------------------------------------------------------------------- +DataType* CompType::decode() const +{ + hid_t encoded_cmptype_id = H5I_INVALID_HID; + try { + encoded_cmptype_id = p_decode(); + } + catch (DataTypeIException &err) { + throw; + } + CompType *encoded_cmptype = new CompType; + encoded_cmptype->p_setId(encoded_cmptype_id); + return(encoded_cmptype); +} + +//-------------------------------------------------------------------------- // Function: CompType::getNmembers ///\brief Returns the number of members in this compound datatype. ///\return Number of members @@ -155,7 +214,6 @@ int CompType::getMemberIndex(const H5std_string& name) const /// respect to the beginning of the compound data type datum. ///\param member_num - IN: Zero-based index of the member ///\return Byte offset -///\exception H5::DataTypeIException // Programmer Binh-Minh Ribler - 2000 // Description /// Members are stored in no particular order with numbers 0 diff --git a/c++/src/H5CompType.h b/c++/src/H5CompType.h index f6d77f4..3aabf55 100644 --- a/c++/src/H5CompType.h +++ b/c++/src/H5CompType.h @@ -43,6 +43,14 @@ class H5_DLLCPP CompType : public DataType { // Copy constructor - makes a copy of original object CompType(const CompType& original); + // Constructors that open a compound datatype, given a location. + CompType(const H5Location& loc, const char* name); + CompType(const H5Location& loc, const H5std_string& name); + + // Returns a CompType object via DataType* by decoding the binary + // object description of this type. + virtual DataType* decode() const; + // Returns the type class of the specified member of this compound // datatype. It provides to the user a way of knowing what type // to create another datatype of the same class diff --git a/c++/src/H5DataType.cpp b/c++/src/H5DataType.cpp index 6162bec..ffa2a21 100644 --- a/c++/src/H5DataType.cpp +++ b/c++/src/H5DataType.cpp @@ -18,6 +18,7 @@ #endif #include +#include "H5private.h" // for HDcalloc #include "H5Include.h" #include "H5Exception.h" #include "H5IdComponent.h" @@ -45,7 +46,7 @@ namespace H5 { ///\brief Default constructor: Creates a stub datatype // Programmer Binh-Minh Ribler - 2000 //-------------------------------------------------------------------------- -DataType::DataType() : H5Object(), id(H5I_INVALID_HID) {} +DataType::DataType() : H5Object(), id(H5I_INVALID_HID), encoded_buf(NULL), buf_size(0) {} //-------------------------------------------------------------------------- // Function: DataType overloaded constructor @@ -60,7 +61,7 @@ DataType::DataType() : H5Object(), id(H5I_INVALID_HID) {} // Removed second argument, "predefined", after changing to the // new ref counting mechanism that relies on C's ref counting. //-------------------------------------------------------------------------- -DataType::DataType(const hid_t existing_id) : H5Object(), id(existing_id) +DataType::DataType(const hid_t existing_id) : H5Object(), id(existing_id), encoded_buf(NULL), buf_size(0) { incRefCount(); // increment number of references to this id } @@ -73,7 +74,7 @@ DataType::DataType(const hid_t existing_id) : H5Object(), id(existing_id) ///\exception H5::DataTypeIException // Programmer Binh-Minh Ribler - 2000 //-------------------------------------------------------------------------- -DataType::DataType(const H5T_class_t type_class, size_t size) : H5Object() +DataType::DataType(const H5T_class_t type_class, size_t size) : H5Object(), encoded_buf(NULL), buf_size(0) { // Call C routine to create the new datatype id = H5Tcreate(type_class, size); @@ -96,7 +97,7 @@ DataType::DataType(const H5T_class_t type_class, size_t size) : H5Object() // Jul, 2008 // Added for application convenience. //-------------------------------------------------------------------------- -DataType::DataType(const H5Location& loc, const void* ref, H5R_type_t ref_type) : H5Object(), id(H5I_INVALID_HID) +DataType::DataType(const H5Location& loc, const void* ref, H5R_type_t ref_type) : H5Object(), encoded_buf(NULL), buf_size(0) { id = H5Location::p_dereference(loc.getId(), ref, ref_type, "constructor - by dereference"); } @@ -114,7 +115,7 @@ DataType::DataType(const H5Location& loc, const void* ref, H5R_type_t ref_type) // Jul, 2008 // Added for application convenience. //-------------------------------------------------------------------------- -DataType::DataType(const Attribute& attr, const void* ref, H5R_type_t ref_type) : H5Object() +DataType::DataType(const Attribute& attr, const void* ref, H5R_type_t ref_type) : H5Object(), id(H5I_INVALID_HID), encoded_buf(NULL), buf_size(0) { id = H5Location::p_dereference(attr.getId(), ref, ref_type, "constructor - by dereference"); } @@ -124,7 +125,7 @@ DataType::DataType(const Attribute& attr, const void* ref, H5R_type_t ref_type) ///\brief Copy constructor: makes a copy of the original DataType object. // Programmer Binh-Minh Ribler - 2000 //-------------------------------------------------------------------------- -DataType::DataType(const DataType& original) : H5Object(), id(original.id) +DataType::DataType(const DataType& original) : H5Object(), id(original.id), encoded_buf(NULL), buf_size(0) { incRefCount(); // increment number of references to this id } @@ -142,7 +143,7 @@ DataType::DataType(const DataType& original) : H5Object(), id(original.id) // unnecessarily and will produce undefined behavior. // -BMR, Apr 2015 //-------------------------------------------------------------------------- -DataType::DataType(const PredType& pred_type) : H5Object() +DataType::DataType(const PredType& pred_type) : H5Object(), encoded_buf(NULL), buf_size(0) { // call C routine to copy the datatype id = H5Tcopy(pred_type.getId()); @@ -151,6 +152,44 @@ DataType::DataType(const PredType& pred_type) : H5Object() } //-------------------------------------------------------------------------- +// Function: DataType overloaded constructor +///\brief Creates a DataType instance by opening an HDF5 datatype given +/// its name as a char*. +///\param loc - IN: Location of the type +///\param type_name - IN: Datatype name +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +// Description +// In 1.8.20, this constructor was introduced and may replace the +// existing function CommonFG::openDataType(const char*) to +// improve usability. +// -BMR, Sept 2017 +//-------------------------------------------------------------------------- +DataType::DataType(const H5Location& loc, const char *type_name) : H5Object(), encoded_buf(NULL), buf_size(0) +{ + id = p_opentype(loc, type_name); +} + +//-------------------------------------------------------------------------- +// Function: DataType overloaded constructor +///\brief Creates a DataType instance by opening an HDF5 datatype given +/// its name as an \c H5std_string. +///\param loc - IN: Location of the type +///\param type_name - IN: Datatype name +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +// Description +// In 1.8.20, this constructor was introduced and may replace the +// existing function CommonFG::openDataType(const H5std_string&) +// to improve usability. +// -BMR, Sept 2017 +//-------------------------------------------------------------------------- +DataType::DataType(const H5Location& loc, const H5std_string& type_name) : H5Object(), encoded_buf(NULL), buf_size(0) +{ + id = p_opentype(loc, type_name.c_str()); +} + +//-------------------------------------------------------------------------- // Function: DataType::copy ///\brief Copies an existing datatype to this datatype object ///\param like_type - IN: Datatype to be copied @@ -204,6 +243,102 @@ void DataType::copy(const DataSet& dset) } //-------------------------------------------------------------------------- +// Function: DataType::p_decode +// Purpose Returns an id of a type by decoding the binary object +/// description of this datatype. +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +//-------------------------------------------------------------------------- +hid_t DataType::p_decode() const +{ + // Make sure that the buffer can be decoded + if (encoded_buf == NULL) + { + throw DataTypeIException("DataType::p_decode", "No encoded buffer"); + } + + // Call C function to decode the binary object description + hid_t encoded_dtype_id = H5Tdecode(encoded_buf); + + // If H5Tdecode fails, raise exception + if (encoded_dtype_id < 0) + { + throw DataTypeIException("DataType::p_decode", "H5Tdecode failed"); + } + else + { + return(encoded_dtype_id); + } +} + +//-------------------------------------------------------------------------- +// Function: DataType::decode +///\brief Returns a DataType instance by decoding the binary object +/// description of this datatype. +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +//-------------------------------------------------------------------------- +DataType* DataType::decode() const +{ + hid_t encoded_dtype_id = H5I_INVALID_HID; + try { + encoded_dtype_id = p_decode(); + } + catch (DataTypeIException &err) { + throw; + } + DataType *encoded_dtype = new DataType; + encoded_dtype->p_setId(encoded_dtype_id); + return(encoded_dtype); +} + +//-------------------------------------------------------------------------- +// Function: DataType::encode +///\brief Creates a binary object description of this datatype. +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +//-------------------------------------------------------------------------- +void DataType::encode() +{ + // Call H5Tencode passing in null to determine the size of the buffer + herr_t ret_value = H5Tencode(id, NULL, &buf_size); + if (ret_value < 0) + { + throw DataTypeIException("DataType::encode", "Failed to get buf_size"); + } + + // Allocate buffer and call C function again to encode + if (buf_size > 0) + { + encoded_buf = (unsigned char *)HDcalloc((size_t)1, buf_size); + ret_value = H5Tencode(id, encoded_buf, &buf_size); + if (ret_value < 0) + { + throw DataTypeIException("DataType::encode", "H5Tencode failed"); + } + } + else + { + throw DataTypeIException("DataType::encode", "Failed to allocate buffer for encoding"); + } +} + +//-------------------------------------------------------------------------- +// Function: DataType::hasBinaryDesc +///\brief Determines whether this datatype has a binary object +/// description. +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +//-------------------------------------------------------------------------- +bool DataType::hasBinaryDesc() const +{ + if (encoded_buf != NULL) + return true; + else + return false; +} + +//-------------------------------------------------------------------------- // Function: DataType::operator= ///\brief Assignment operator ///\param rhs - IN: Reference to the existing datatype @@ -722,6 +857,26 @@ hid_t DataType::getId() const #ifndef DOXYGEN_SHOULD_SKIP_THIS //-------------------------------------------------------------------------- +// Function: DataType::p_opentype (private) +///\brief Opens an HDF5 datatype given its name +///\param loc - IN: Location of the type +///\param type_name - IN: Datatype name +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +// Description +// This function was introduced in 1.8.20 to be used by the +// new XxxType constructors that open a datatype. -BMR, Sept 2017 +//-------------------------------------------------------------------------- +hid_t DataType::p_opentype(const H5Location& loc, const char *type_name) const +{ + // Call C function to open the named datatype at this location + hid_t ret_value = H5Topen2(loc.getId(), type_name, H5P_DEFAULT); + if (ret_value < 0) + throw DataTypeIException(inMemFunc("constructor"), "H5Topen2 failed"); + return(ret_value); +} + +//-------------------------------------------------------------------------- // Function: DataType::p_setId ///\brief Sets the identifier of this object to a new value. /// diff --git a/c++/src/H5DataType.h b/c++/src/H5DataType.h index 8970a8d..5e10c20 100644 --- a/c++/src/H5DataType.h +++ b/c++/src/H5DataType.h @@ -36,6 +36,10 @@ class H5_DLLCPP DataType : public H5Object { // Creates a copy of a predefined type DataType(const PredType& pred_type); + // Opens a generic named datatype at a given location. + DataType(const H5Location& loc, const char* name); + DataType(const H5Location& loc, const H5std_string& name); + // Creates a datatype by way of dereference. DataType(const H5Location& loc, const void* ref, H5R_type_t ref_type = H5R_OBJECT); DataType(const Attribute& attr, const void* ref, H5R_type_t ref_type = H5R_OBJECT); @@ -49,6 +53,13 @@ class H5_DLLCPP DataType : public H5Object { // Copies the datatype of dset to this datatype object. void copy(const DataSet& dset); + // Returns a DataType instance by decoding the binary object + // description of this datatype. + virtual DataType* decode() const; + + // Creates a binary object description of this datatype. + void encode(); + // Returns the datatype class identifier. H5T_class_t getClass() const; @@ -56,10 +67,6 @@ class H5_DLLCPP DataType : public H5Object { // a named datatype which can be accessed from the location. void commit(const H5Location& loc, const char* name); void commit(const H5Location& loc, const H5std_string& name); - // These two overloaded functions are kept for backward compatibility - // only; they missed the const - removed from 1.8.18 and 1.10.1 - //void commit(H5Location& loc, const char* name); - //void commit(H5Location& loc, const H5std_string& name); // Determines whether this datatype is a named datatype or // a transient datatype. @@ -121,6 +128,9 @@ class H5_DLLCPP DataType : public H5Object { // Default constructor DataType(); + // Determines whether this datatype has a binary object description. + bool hasBinaryDesc() const; + // Gets the datatype id. virtual hid_t getId() const; @@ -131,11 +141,24 @@ class H5_DLLCPP DataType : public H5Object { #ifndef DOXYGEN_SHOULD_SKIP_THIS hid_t id; // HDF5 datatype id + // Returns an id of a type by decoding the binary object + // description of this datatype. + hid_t p_decode() const; + // Sets the datatype id. virtual void p_setId(const hid_t new_id); + + // Opens a datatype and returns the id. + hid_t p_opentype(const H5Location& loc, const char* dtype_name) const; + #endif // DOXYGEN_SHOULD_SKIP_THIS private: + // Buffer for binary object description of this datatype, allocated + // in DataType::encode and used in DataType::decode + unsigned char *encoded_buf; + size_t buf_size; + // Friend function to set DataType id. For library use only. friend void f_DataType_setId(DataType* dtype, hid_t new_id); diff --git a/c++/src/H5EnumType.cpp b/c++/src/H5EnumType.cpp index 0c26728..4b06ca5 100644 --- a/c++/src/H5EnumType.cpp +++ b/c++/src/H5EnumType.cpp @@ -106,6 +106,65 @@ EnumType::EnumType(const IntType& data_type) : DataType() } //-------------------------------------------------------------------------- +// Function: EnumType overloaded constructor +///\brief Creates an EnumType instance by opening an HDF5 enum datatype +/// given its name, provided as a C character string. +///\param loc - IN: Location of the type +///\param type_name - IN: Enum datatype name +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +// Description +// In 1.8.20, this constructor was introduced and may replace the +// existing function CommonFG::openEnumType(const char*) to +// improve usability. +// -BMR, Sept 2017 +//-------------------------------------------------------------------------- +EnumType::EnumType(const H5Location& loc, const char *type_name) : DataType() +{ + id = p_opentype(loc, type_name); +} + +//-------------------------------------------------------------------------- +// Function: EnumType overloaded constructor +///\brief Creates an EnumType instance by opening an HDF5 enum datatype +/// given its name, provided as an \c H5std_string. +///\param loc - IN: Location of the type +///\param type_name - IN: Enum datatype name +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +// Description +// In 1.8.20, this constructor was introduced and may replace the +// existing function CommonFG::openEnumType(const H5std_string&) +// to improve usability. +// -BMR, Sept 2017 +//-------------------------------------------------------------------------- +EnumType::EnumType(const H5Location& loc, const H5std_string& type_name) : DataType() +{ + id = p_opentype(loc, type_name.c_str()); +} + +//-------------------------------------------------------------------------- +// Function: EnumType::decode +///\brief Returns an EnumType object via DataType* by decoding the +/// binary object description of this type. +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +//-------------------------------------------------------------------------- +DataType* EnumType::decode() const +{ + hid_t encoded_enumtype_id = H5I_INVALID_HID; + try { + encoded_enumtype_id = p_decode(); + } + catch (DataTypeIException &err) { + throw; + } + EnumType *encoded_enumtype = new EnumType; + encoded_enumtype->p_setId(encoded_enumtype_id); + return(encoded_enumtype); +} + +//-------------------------------------------------------------------------- // Function: EnumType::insert ///\brief Inserts a new member to this enumeration datatype. ///\param name - IN: Name of the new member diff --git a/c++/src/H5EnumType.h b/c++/src/H5EnumType.h index 5cbe262..745c09b 100644 --- a/c++/src/H5EnumType.h +++ b/c++/src/H5EnumType.h @@ -34,6 +34,14 @@ class H5_DLLCPP EnumType : public DataType { // Creates a new enum datatype based on an integer datatype EnumType(const IntType& data_type); // H5Tenum_create + // Constructors that open an enum datatype, given a location. + EnumType(const H5Location& loc, const char* name); + EnumType(const H5Location& loc, const H5std_string& name); + + // Returns an EnumType object via DataType* by decoding the + // binary object description of this type. + virtual DataType* decode() const; + // Returns the number of members in this enumeration datatype. int getNmembers () const; diff --git a/c++/src/H5FloatType.cpp b/c++/src/H5FloatType.cpp index 0abf52a..05284f9 100644 --- a/c++/src/H5FloatType.cpp +++ b/c++/src/H5FloatType.cpp @@ -87,6 +87,65 @@ FloatType::FloatType(const DataSet& dataset) : AtomType() } //-------------------------------------------------------------------------- +// Function: FloatType overloaded constructor +///\brief Creates an FloatType instance by opening an HDF5 float datatype +/// given its name, provided as a C character string. +///\param loc - IN: Location of the type +///\param type_name - IN: Float type name +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +// Description +// In 1.8.20, this constructor was introduced and may replace the +// existing function CommonFG::openFloatType(const char*) +// to improve usability. +// -BMR, Sept 2017 +//-------------------------------------------------------------------------- +FloatType::FloatType(const H5Location& loc, const char *type_name) : AtomType() +{ + id = p_opentype(loc, type_name); +} + +//-------------------------------------------------------------------------- +// Function: FloatType overloaded constructor +///\brief Creates an FloatType instance by opening an HDF5 float datatype +/// given its name, provided as an \c H5std_string. +///\param loc - IN: Location of the type +///\param type_name - IN: Float type name +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +// Description +// In 1.8.20, this constructor was introduced and may replace the +// existing function CommonFG::openFloatType(const H5std_string&) +// to improve usability. +// -BMR, Sept 2017 +//-------------------------------------------------------------------------- +FloatType::FloatType(const H5Location& loc, const H5std_string& type_name) : AtomType() +{ + id = p_opentype(loc, type_name.c_str()); +} + +//-------------------------------------------------------------------------- +// Function: FloatType::decode +///\brief Returns an FloatType object via DataType* by decoding the +/// binary object description of this type. +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +//-------------------------------------------------------------------------- +DataType* FloatType::decode() const +{ + hid_t encoded_flttype_id = H5I_INVALID_HID; + try { + encoded_flttype_id = p_decode(); + } + catch (DataTypeIException &err) { + throw; + } + FloatType *encoded_flttype = new FloatType; + encoded_flttype->p_setId(encoded_flttype_id); + return(encoded_flttype); +} + +//-------------------------------------------------------------------------- // Function: FloatType::getFields ///\brief Retrieves floating point datatype bit field information. ///\param spos - OUT: Retrieved floating-point sign bit diff --git a/c++/src/H5FloatType.h b/c++/src/H5FloatType.h index d0256e1..d26df5c 100644 --- a/c++/src/H5FloatType.h +++ b/c++/src/H5FloatType.h @@ -30,6 +30,14 @@ class H5_DLLCPP FloatType : public AtomType { // Gets the floating-point datatype of the specified dataset. FloatType(const DataSet& dataset); + // Constructors that open an HDF5 float datatype, given a location. + FloatType(const H5Location& loc, const char* name); + FloatType(const H5Location& loc, const H5std_string& name); + + // Returns an FloatType object via DataType* by decoding the + // binary object description of this type. + virtual DataType* decode() const; + // Retrieves the exponent bias of a floating-point type. size_t getEbias() const; diff --git a/c++/src/H5IntType.cpp b/c++/src/H5IntType.cpp index 7d48314..6af2dc2 100644 --- a/c++/src/H5IntType.cpp +++ b/c++/src/H5IntType.cpp @@ -86,6 +86,65 @@ IntType::IntType(const DataSet& dataset) : AtomType() } //-------------------------------------------------------------------------- +// Function: IntType overloaded constructor +///\brief Creates a IntType instance by opening an HDF5 integer datatype +/// given its name as a char*. +///\param loc - IN: Location of the type +///\param type_name - IN: Integer type name +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +// Description +// In 1.8.20, this constructor was introduced and may replace the +// existing function CommonFG::openIntType(const char*) to +// improve usability. +// -BMR, Sept 2017 +//-------------------------------------------------------------------------- +IntType::IntType(const H5Location& loc, const char *type_name) : AtomType() +{ + id = p_opentype(loc, type_name); +} + +//-------------------------------------------------------------------------- +// Function: IntType overloaded constructor +///\brief Creates a IntType instance by opening an HDF5 integer datatype +/// given its name, provided as an \c H5std_string. +///\param loc - IN: Location of the type +///\param type_name - IN: Integer type name +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +// Description +// In 1.8.20, this constructor was introduced and may replace the +// existing function CommonFG::openIntType(const H5std_string&) +// to improve usability. +// -BMR, Sept 2017 +//-------------------------------------------------------------------------- +IntType::IntType(const H5Location& loc, const H5std_string& type_name) : AtomType() +{ + id = p_opentype(loc, type_name.c_str()); +} + +//-------------------------------------------------------------------------- +// Function: IntType::decode +///\brief Returns an IntType object via DataType* by decoding the +/// binary object description of this type. +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +//-------------------------------------------------------------------------- +DataType* IntType::decode() const +{ + hid_t encoded_inttype_id = H5I_INVALID_HID; + try { + encoded_inttype_id = p_decode(); + } + catch (DataTypeIException &err) { + throw; + } + IntType *encoded_inttype = new IntType; + encoded_inttype->p_setId(encoded_inttype_id); + return(encoded_inttype); +} + +//-------------------------------------------------------------------------- // Function: IntType::getSign ///\brief Retrieves the sign type for an integer type. ///\return Valid sign type diff --git a/c++/src/H5IntType.h b/c++/src/H5IntType.h index 5602b32..3e10111 100644 --- a/c++/src/H5IntType.h +++ b/c++/src/H5IntType.h @@ -32,6 +32,14 @@ class H5_DLLCPP IntType : public AtomType { // Gets the integer datatype of the specified dataset IntType(const DataSet& dataset); + // Constructors that open an HDF5 integer datatype, given a location. + IntType(const H5Location& loc, const char* name); + IntType(const H5Location& loc, const H5std_string& name); + + // Returns an IntType object via DataType* by decoding the + // binary object description of this type. + virtual DataType* decode() const; + // Retrieves the sign type for an integer type H5T_sign_t getSign() const; diff --git a/c++/src/H5Location.cpp b/c++/src/H5Location.cpp index ab09305..4ef5d82 100644 --- a/c++/src/H5Location.cpp +++ b/c++/src/H5Location.cpp @@ -338,10 +338,13 @@ void H5Location::renameAttr(const H5std_string& oldname, const H5std_string& new //-------------------------------------------------------------------------- // Function: H5Location::getNumAttrs -///\brief Returns the number of attributes attached to this HDF5 object. +///\brief Deprecated - Returns the number of attributes attached to +/// this HDF5 object. ///\return Number of attributes ///\exception H5::AttributeIException // Programmer Binh-Minh Ribler - 2000 +// Modification +// - Moved to H5Object in 1.8.20. -BMR //-------------------------------------------------------------------------- int H5Location::getNumAttrs() const { diff --git a/c++/src/H5Location.h b/c++/src/H5Location.h index bbeb30f..7a54c2b 100644 --- a/c++/src/H5Location.h +++ b/c++/src/H5Location.h @@ -41,20 +41,6 @@ class UserData4Aiterate { // user data for attribute iteration // Inheritance: IdComponent class H5_DLLCPP H5Location : public IdComponent { public: - // Creates an attribute for the specified object at this location - // PropList is currently not used, so always be default. - virtual Attribute createAttribute(const char* name, const DataType& type, const DataSpace& space, const PropList& create_plist = PropList::DEFAULT) const; - virtual Attribute createAttribute(const H5std_string& name, const DataType& type, const DataSpace& space, const PropList& create_plist = PropList::DEFAULT) const; - - // Given its name, opens the attribute that belongs to an object at - // this location. - virtual Attribute openAttribute(const char* name) const; - virtual Attribute openAttribute(const H5std_string& name) const; - - // Given its index, opens the attribute that belongs to an object at - // this location. - virtual Attribute openAttribute(const unsigned int idx) const; - // Checks if a link of a given name exists in this location bool nameExists(const char* name, const LinkAccPropList& lapl = LinkAccPropList::DEFAULT) const; bool nameExists(const H5std_string& name, const LinkAccPropList& lapl = LinkAccPropList::DEFAULT) const; @@ -66,7 +52,8 @@ class H5_DLLCPP H5Location : public IdComponent { H5std_string getFileName() const; // Determines the number of attributes at this location. - int getNumAttrs() const; + // - moved to H5Object (1.8.20) + int getNumAttrs() const; // Deprecated #ifndef H5_NO_DEPRECATED_SYMBOLS // Retrieves the type of object that an object reference points to. @@ -78,21 +65,6 @@ class H5_DLLCPP H5Location : public IdComponent { // Note: getRefObjType deprecates getObjType, but getObjType's name is // misleading, so getRefObjType is used in the new function instead. - // Iterate user's function over the attributes at this location. - virtual int iterateAttrs(attr_operator_t user_op, unsigned* idx = NULL, void* op_data = NULL); - - // Checks whether the named attribute exists at this location. - virtual bool attrExists(const char* name) const; - virtual bool attrExists(const H5std_string& name) const; - - // Renames the named attribute to a new name. - virtual void renameAttr(const char* oldname, const char* newname) const; - virtual void renameAttr(const H5std_string& oldname, const H5std_string& newname) const; - - // Removes the named attribute from this location. - virtual void removeAttr(const char* name) const; - virtual void removeAttr(const H5std_string& name) const; - // Returns the object header version of an object unsigned objVersion() const; @@ -140,6 +112,51 @@ class H5_DLLCPP H5Location : public IdComponent { ///\brief Returns an identifier. (pure virtual) virtual hid_t getId() const = 0; +/*************************************************************************** + Notes for H5A wrappers + ====================== + These H5A wrappers are marked "deprecated" in 1.8.19. + They are moved to H5Object to prevent the object id from being + passed in to H5A APIs. +***************************************************************************/ + + // Creates an attribute for the specified object at this location + // PropList is currently not used, so always be default. + // Deprecated + virtual Attribute createAttribute(const char* name, const DataType& type, const DataSpace& space, const PropList& create_plist = PropList::DEFAULT) const; + virtual Attribute createAttribute(const H5std_string& name, const DataType& type, const DataSpace& space, const PropList& create_plist = PropList::DEFAULT) const; + + // Given its name, opens the attribute that belongs to an object at + // this location. + // Deprecated + virtual Attribute openAttribute(const char* name) const; + virtual Attribute openAttribute(const H5std_string& name) const; + + // Given its index, opens the attribute that belongs to an object at + // this location. + virtual Attribute openAttribute(const unsigned int idx) const; // Deprecated + + // Iterate user's function over the attributes at this location. + virtual int iterateAttrs(attr_operator_t user_op, unsigned* idx = NULL, + void* op_data = NULL); // Deprecated + + // Checks whether the named attribute exists at this location. + // Deprecated + virtual bool attrExists(const char* name) const; + virtual bool attrExists(const H5std_string& name) const; + + // Renames the named attribute to a new name. + // Deprecated + virtual void renameAttr(const char* oldname, const char* newname) const; + virtual void renameAttr(const H5std_string& oldname, const H5std_string& newname) const; + + // Removes the named attribute from this location. + // Deprecated + virtual void removeAttr(const char* name) const; + virtual void removeAttr(const H5std_string& name) const; + +/**************************** End of H5A note *******************************/ + protected: #ifndef DOXYGEN_SHOULD_SKIP_THIS // Default constructor, diff --git a/c++/src/H5Object.cpp b/c++/src/H5Object.cpp index b35206e..8fe8e56 100644 --- a/c++/src/H5Object.cpp +++ b/c++/src/H5Object.cpp @@ -29,6 +29,23 @@ namespace H5 { #ifndef DOXYGEN_SHOULD_SKIP_THIS +// userAttrOpWrpr simply interfaces between the user's function and the +// C library function H5Aiterate2; used to resolve the different prototype +// problem. May be moved to Iterator later. + /* extern "C" herr_t userAttrOpWrpr(hid_t loc_id, const char *attr_name, + const H5A_info_t *ainfo, void *op_data) +{ + H5std_string s_attr_name = H5std_string(attr_name); +#ifdef NO_STATIC_CAST + UserData4Aiterate* myData = (UserData4Aiterate *) op_data; +#else + UserData4Aiterate* myData = static_cast (op_data); +#endif + myData->op(*myData->location, s_attr_name, myData->opData); + return 0; +} + */ + //-------------------------------------------------------------------------- // Function: H5Object default constructor (protected) // Programmer Binh-Minh Ribler - 2000 @@ -272,6 +289,25 @@ void H5Object::renameAttr(const H5std_string& oldname, const H5std_string& newna // end of Notes for H5A wrappers //-------------------------------------------------------------------------- +// Function: H5Object::getNumAttrs +///\brief Returns the number of attributes attached to this HDF5 object. +///\return Number of attributes +///\exception H5::AttributeIException +// Programmer Binh-Minh Ribler - 2000 +// Modification +// - Moved from H5Location in 1.8.20. -BMR Oct, 2017 +//-------------------------------------------------------------------------- +int H5Object::getNumAttrs() const +{ + H5O_info_t oinfo; /* Object info */ + + if(H5Oget_info(getId(), &oinfo) < 0) + throw AttributeIException(inMemFunc("getNumAttrs"), "H5Oget_info failed"); + else + return(static_cast(oinfo.num_attrs)); +} + +//-------------------------------------------------------------------------- // Function: getObjName ///\brief Given an id, returns the type of the object. ///\return The name of the object diff --git a/c++/src/H5Object.h b/c++/src/H5Object.h index 8d9cb45..afeea7d 100644 --- a/c++/src/H5Object.h +++ b/c++/src/H5Object.h @@ -33,6 +33,7 @@ namespace H5 { Apr 2, 2014: Added wrapper getObjName for H5Iget_name -BMR */ // Inheritance: H5Location -> IdComponent + class H5_DLLCPP H5Object : public H5Location { public: // Creates an attribute for the specified object @@ -59,6 +60,9 @@ class H5_DLLCPP H5Object : public H5Location { void removeAttr(const char* name) const; void removeAttr(const H5std_string& name) const; + // Determines the number of attributes belong to this object. + int getNumAttrs() const; + // Gets the name of this HDF5 object, i.e., Group, DataSet, or // DataType. ssize_t getObjName(char *obj_name, size_t buf_size = 0) const; @@ -81,7 +85,7 @@ class H5_DLLCPP H5Object : public H5Location { // removal does not raise any problems in two 1.10 releases. // Creates a copy of an existing object giving the object id - H5Object(const hid_t object_id); + // H5Object(const hid_t object_id); // Copy constructor: makes copy of an H5Object object. // H5Object(const H5Object& original); diff --git a/c++/src/H5StrType.cpp b/c++/src/H5StrType.cpp index ef63ccb..00fbe20 100644 --- a/c++/src/H5StrType.cpp +++ b/c++/src/H5StrType.cpp @@ -142,6 +142,65 @@ StrType::StrType(const DataSet& dataset) : AtomType () } //-------------------------------------------------------------------------- +// Function: StrType overloaded constructor +///\brief Creates an StrType instance by opening an HDF5 string datatype +/// given its name, provided as a C character string. +///\param loc - IN: Location of the type +///\param type_name - IN: String type name +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +// Description +// In 1.8.20, this constructor was introduced and may replace the +// existing function CommonFG::openStrType(const char*) +// to improve usability. +// -BMR, Sept 2017 +//-------------------------------------------------------------------------- +StrType::StrType(const H5Location& loc, const char *type_name) : AtomType() +{ + id = p_opentype(loc, type_name); +} + +//-------------------------------------------------------------------------- +// Function: StrType overloaded constructor +///\brief Creates an StrType instance by opening an HDF5 string datatype +/// given its name, provided as an \c H5std_string. +///\param loc - IN: Location of the type +///\param type_name - IN: String type name +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +// Description +// In 1.8.20, this constructor was introduced and may replace the +// existing function CommonFG::openStrType(const H5std_string&) +// to improve usability. +// -BMR, Sept 2017 +//-------------------------------------------------------------------------- +StrType::StrType(const H5Location& loc, const H5std_string& type_name) : AtomType() +{ + id = p_opentype(loc, type_name.c_str()); +} + +//-------------------------------------------------------------------------- +// Function: StrType::decode +///\brief Returns an StrType object via DataType* by decoding the +/// binary object description of this type. +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +//-------------------------------------------------------------------------- +DataType* StrType::decode() const +{ + hid_t encoded_strtype_id = H5I_INVALID_HID; + try { + encoded_strtype_id = p_decode(); + } + catch (DataTypeIException &err) { + throw; + } + StrType *encoded_strtype = new StrType; + encoded_strtype->p_setId(encoded_strtype_id); + return(encoded_strtype); +} + +//-------------------------------------------------------------------------- // Function: StrType::getCset ///\brief Retrieves the character set type of this string datatype. ///\return Character set type, which can be: diff --git a/c++/src/H5StrType.h b/c++/src/H5StrType.h index 7ae33ee..24c9ca3 100644 --- a/c++/src/H5StrType.h +++ b/c++/src/H5StrType.h @@ -36,6 +36,14 @@ class H5_DLLCPP StrType : public AtomType { // Gets the string datatype of the specified dataset StrType(const DataSet& dataset); + // Constructors that open an HDF5 string datatype, given a location. + StrType(const H5Location& loc, const char* name); + StrType(const H5Location& loc, const H5std_string& name); + + // Returns an StrType object via DataType* by decoding the + // binary object description of this type. + virtual DataType* decode() const; + // Retrieves the character set type of this string datatype. H5T_cset_t getCset() const; diff --git a/c++/src/H5VarLenType.cpp b/c++/src/H5VarLenType.cpp index c3d5e58..8d9e3a1 100644 --- a/c++/src/H5VarLenType.cpp +++ b/c++/src/H5VarLenType.cpp @@ -70,6 +70,65 @@ VarLenType::VarLenType(const DataType* base_type) : DataType() } //-------------------------------------------------------------------------- +// Function: VarLenType overloaded constructor +///\brief Creates an VarLenType instance by opening an HDF5 variable +/// length datatype given its name, provided as a C char*. +///\param loc - IN: Location of the type +///\param type_name - IN: Variable length type name +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +// Description +// In 1.8.20, this constructor was introduced and may replace the +// existing function CommonFG::openVarLenType(const char*) to +// improve usability. +// -BMR, Sept 2017 +//-------------------------------------------------------------------------- +VarLenType::VarLenType(const H5Location& loc, const char *type_name) : DataType() +{ + id = p_opentype(loc, type_name); +} + +//-------------------------------------------------------------------------- +// Function: VarLenType overloaded constructor +///\brief Creates an VarLenType instance by opening an HDF5 variable +/// length datatype given its name, provided as an \c H5std_string. +///\param loc - IN: Location of the type +///\param type_name - IN: Variable length type name +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +// Description +// In 1.8.20, this constructor was introduced and may replace the +// existing function CommonFG::openVarLenType(const H5std_string&) to +// improve usability. +// -BMR, Sept 2017 +//-------------------------------------------------------------------------- +VarLenType::VarLenType(const H5Location& loc, const H5std_string& type_name) : DataType() +{ + id = p_opentype(loc, type_name.c_str()); +} + +//-------------------------------------------------------------------------- +// Function: VarLenType::decode +///\brief Returns an VarLenType object via DataType* by decoding the +/// binary object description of this type. +///\exception H5::DataTypeIException +// Programmer Binh-Minh Ribler - Sept 2017 +//-------------------------------------------------------------------------- +DataType* VarLenType::decode() const +{ + hid_t encoded_vltype_id = H5I_INVALID_HID; + try { + encoded_vltype_id = p_decode(); + } + catch (DataTypeIException &err) { + throw; + } + VarLenType *encoded_vltype = new VarLenType; + encoded_vltype->p_setId(encoded_vltype_id); + return(encoded_vltype); +} + +//-------------------------------------------------------------------------- // Function: VarLenType destructor ///\brief Properly terminates access to this datatype. // Programmer Binh-Minh Ribler - May, 2004 diff --git a/c++/src/H5VarLenType.h b/c++/src/H5VarLenType.h index 1b93876..a9713ad 100644 --- a/c++/src/H5VarLenType.h +++ b/c++/src/H5VarLenType.h @@ -26,8 +26,19 @@ class H5_DLLCPP VarLenType : public DataType { public: // Constructor that creates a variable-length datatype based // on the specified base type. + VarLenType(const DataType& base_type); + + // Deprecated - will be removed after 1.8.20 VarLenType(const DataType* base_type); + // Constructors that open a variable-length datatype, given a location. + VarLenType(const H5Location& loc, const char* name); + VarLenType(const H5Location& loc, const H5std_string& name); + + // Returns an VarLenType object via DataType* by decoding the + // binary object description of this type. + virtual DataType* decode() const; + ///\brief Returns this class name. virtual H5std_string fromClass () const { return("VarLenType"); } -- cgit v0.12