summaryrefslogtreecommitdiffstats
path: root/c++
diff options
context:
space:
mode:
Diffstat (limited to 'c++')
-rw-r--r--c++/src/H5ArrayType.cpp21
-rw-r--r--c++/src/H5ArrayType.h4
-rw-r--r--c++/src/H5Classes.h2
-rw-r--r--c++/src/H5CompType.cpp21
-rw-r--r--c++/src/H5CompType.h4
-rw-r--r--c++/src/H5DataType.cpp123
-rw-r--r--c++/src/H5DataType.h19
-rw-r--r--c++/src/H5EnumType.cpp21
-rw-r--r--c++/src/H5EnumType.h4
-rw-r--r--c++/src/H5FloatType.cpp23
-rw-r--r--c++/src/H5FloatType.h4
-rw-r--r--c++/src/H5IntType.cpp21
-rw-r--r--c++/src/H5IntType.h4
-rw-r--r--c++/src/H5StrType.cpp21
-rw-r--r--c++/src/H5StrType.h4
-rw-r--r--c++/src/H5VarLenType.cpp21
-rw-r--r--c++/src/H5VarLenType.h4
-rw-r--r--c++/test/ttypes.cpp252
18 files changed, 543 insertions, 30 deletions
diff --git a/c++/src/H5ArrayType.cpp b/c++/src/H5ArrayType.cpp
index 9d4a973..c39ef35 100644
--- a/c++/src/H5ArrayType.cpp
+++ b/c++/src/H5ArrayType.cpp
@@ -139,6 +139,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 - Aug 2017
+//--------------------------------------------------------------------------
+DataType* ArrayType::decode() const
+{
+ hid_t encoded_arrtype_id;
+ 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 ffb8712..e3709cd 100644
--- a/c++/src/H5ArrayType.h
+++ b/c++/src/H5ArrayType.h
@@ -36,6 +36,10 @@ class H5_DLLCPP ArrayType : public DataType {
ArrayType(const H5Location& loc, const char* name);
ArrayType(const H5Location& loc, const H5std_string& name);
+ // 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 f0f6359..8b1e6ed 100644
--- a/c++/src/H5Classes.h
+++ b/c++/src/H5Classes.h
@@ -31,10 +31,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 f7862c9..95fddc1 100644
--- a/c++/src/H5CompType.cpp
+++ b/c++/src/H5CompType.cpp
@@ -124,6 +124,27 @@ CompType::CompType(const H5Location& loc, const H5std_string& dtype_name) : Data
}
//--------------------------------------------------------------------------
+// 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 - Aug 2017
+//--------------------------------------------------------------------------
+DataType* CompType::decode() const
+{
+ hid_t encoded_cmptype_id;
+ 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
diff --git a/c++/src/H5CompType.h b/c++/src/H5CompType.h
index 018d875..bf687de 100644
--- a/c++/src/H5CompType.h
+++ b/c++/src/H5CompType.h
@@ -44,6 +44,10 @@ class H5_DLLCPP CompType : public DataType {
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 57f9361..11b30cc 100644
--- a/c++/src/H5DataType.cpp
+++ b/c++/src/H5DataType.cpp
@@ -48,7 +48,7 @@ using std::endl;
///\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
@@ -63,7 +63,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
}
@@ -76,7 +76,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);
@@ -100,7 +100,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, const PropList& plist) : H5Object()
+DataType::DataType(const H5Location& loc, const void* ref, H5R_type_t ref_type, const PropList& plist) : H5Object(), encoded_buf(NULL), buf_size(0)
{
id = H5Location::p_dereference(loc.getId(), ref, ref_type, plist, "constructor - by dereference");
}
@@ -119,7 +119,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, const PropList& plist) : H5Object(), id(H5I_INVALID_HID)
+ /* DataType::DataType(const Attribute& attr, const void* ref, H5R_type_t ref_type, const PropList& plist) : H5Object(), id(H5I_INVALID_HID), encoded_buf(NULL), buf_size(0)
{
id = H5Location::p_dereference(attr.getId(), ref, ref_type, plist, "constructor - by dereference");
}
@@ -130,7 +130,7 @@ DataType::DataType(const H5Location& loc, 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
}
@@ -148,7 +148,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());
@@ -170,7 +170,7 @@ DataType::DataType(const PredType& pred_type) : H5Object()
// improve usability.
// -BMR, Dec 2016
//--------------------------------------------------------------------------
-DataType::DataType(const H5Location& loc, const char *dtype_name) : H5Object()
+DataType::DataType(const H5Location& loc, const char *dtype_name) : H5Object(), encoded_buf(NULL), buf_size(0)
{
id = p_opentype(loc, dtype_name);
}
@@ -189,7 +189,7 @@ DataType::DataType(const H5Location& loc, const char *dtype_name) : H5Object()
// improve usability.
// -BMR, Dec 2016
//--------------------------------------------------------------------------
-DataType::DataType(const H5Location& loc, const H5std_string& dtype_name) : H5Object()
+DataType::DataType(const H5Location& loc, const H5std_string& dtype_name) : H5Object(), encoded_buf(NULL), buf_size(0)
{
id = p_opentype(loc, dtype_name.c_str());
}
@@ -248,6 +248,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 - Aug 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 - Aug 2017
+//--------------------------------------------------------------------------
+DataType* DataType::decode() const
+{
+ hid_t encoded_dtype_id;
+ 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 - Aug 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 - Aug 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
@@ -827,8 +923,15 @@ void DataType::close()
{
throw DataTypeIException(inMemFunc("close"), "H5Tclose failed");
}
- // reset the id
+ // Reset the id
id = H5I_INVALID_HID;
+
+ // Free and reset buffer of encoded object description if it's been used
+ if (encoded_buf != NULL)
+ {
+ HDfree(encoded_buf);
+ buf_size = 0;
+ }
}
}
diff --git a/c++/src/H5DataType.h b/c++/src/H5DataType.h
index 32a79fa..50d2fc1 100644
--- a/c++/src/H5DataType.h
+++ b/c++/src/H5DataType.h
@@ -50,6 +50,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;
@@ -130,6 +137,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;
@@ -140,6 +150,10 @@ 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);
@@ -149,6 +163,11 @@ class H5_DLLCPP DataType : public H5Object {
#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 a96239c..f9046be 100644
--- a/c++/src/H5EnumType.cpp
+++ b/c++/src/H5EnumType.cpp
@@ -146,6 +146,27 @@ EnumType::EnumType(const H5Location& loc, const H5std_string& dtype_name) : Data
}
//--------------------------------------------------------------------------
+// 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 - Aug 2017
+//--------------------------------------------------------------------------
+DataType* EnumType::decode() const
+{
+ hid_t encoded_cmptype_id;
+ try {
+ encoded_cmptype_id = p_decode();
+ }
+ catch (DataTypeIException &err) {
+ throw;
+ }
+ EnumType *encoded_cmptype = new EnumType;
+ encoded_cmptype->p_setId(encoded_cmptype_id);
+ return(encoded_cmptype);
+}
+
+//--------------------------------------------------------------------------
// 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 fc8089e..6468bf7 100644
--- a/c++/src/H5EnumType.h
+++ b/c++/src/H5EnumType.h
@@ -40,6 +40,10 @@ class H5_DLLCPP EnumType : public DataType {
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 6bb3fd6..66a7466 100644
--- a/c++/src/H5FloatType.cpp
+++ b/c++/src/H5FloatType.cpp
@@ -71,7 +71,7 @@ FloatType::FloatType(const hid_t existing_id) : AtomType( existing_id ) {}
FloatType::FloatType(const FloatType& original) : AtomType( original ){}
//--------------------------------------------------------------------------
-// Function: EnumType overloaded constructor
+// Function: FloatType overloaded constructor
///\brief Gets the floating-point datatype of the specified dataset
///\param dataset - IN: Dataset that this floating-point datatype
/// associates with
@@ -128,6 +128,27 @@ FloatType::FloatType(const H5Location& loc, const H5std_string& dtype_name) : At
}
//--------------------------------------------------------------------------
+// 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 - Aug 2017
+//--------------------------------------------------------------------------
+DataType* FloatType::decode() const
+{
+ hid_t encoded_flttype_id;
+ 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 e84f50b..4f277c3 100644
--- a/c++/src/H5FloatType.h
+++ b/c++/src/H5FloatType.h
@@ -35,6 +35,10 @@ class H5_DLLCPP FloatType : public AtomType {
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 fb7e476..8408732 100644
--- a/c++/src/H5IntType.cpp
+++ b/c++/src/H5IntType.cpp
@@ -127,6 +127,27 @@ IntType::IntType(const H5Location& loc, const H5std_string& dtype_name) : AtomTy
}
//--------------------------------------------------------------------------
+// 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 - Aug 2017
+//--------------------------------------------------------------------------
+DataType* IntType::decode() const
+{
+ hid_t encoded_inttype_id;
+ 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 82a7cfd..54a4975 100644
--- a/c++/src/H5IntType.h
+++ b/c++/src/H5IntType.h
@@ -35,6 +35,10 @@ class H5_DLLCPP IntType : public AtomType {
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/H5StrType.cpp b/c++/src/H5StrType.cpp
index d5fb744..cbb2103 100644
--- a/c++/src/H5StrType.cpp
+++ b/c++/src/H5StrType.cpp
@@ -181,6 +181,27 @@ StrType::StrType(const H5Location& loc, const H5std_string& dtype_name) : AtomTy
}
//--------------------------------------------------------------------------
+// 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 - Aug 2017
+//--------------------------------------------------------------------------
+DataType* StrType::decode() const
+{
+ hid_t encoded_strtype_id;
+ 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 abac8de..fd0402e 100644
--- a/c++/src/H5StrType.h
+++ b/c++/src/H5StrType.h
@@ -41,6 +41,10 @@ class H5_DLLCPP StrType : public AtomType {
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 22e1a66..fcea8cd 100644
--- a/c++/src/H5VarLenType.cpp
+++ b/c++/src/H5VarLenType.cpp
@@ -109,6 +109,27 @@ VarLenType::VarLenType(const H5Location& loc, const H5std_string& dtype_name) :
}
//--------------------------------------------------------------------------
+// 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 - Aug 2017
+//--------------------------------------------------------------------------
+DataType* VarLenType::decode() const
+{
+ hid_t encoded_vltype_id;
+ 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 4048a4e..17d812f 100644
--- a/c++/src/H5VarLenType.h
+++ b/c++/src/H5VarLenType.h
@@ -29,6 +29,10 @@ class H5_DLLCPP VarLenType : public DataType {
// on the specified base type.
VarLenType(const DataType* base_type);
+ // 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"); }
diff --git a/c++/test/ttypes.cpp b/c++/test/ttypes.cpp
index f76f780..ec644a8 100644
--- a/c++/test/ttypes.cpp
+++ b/c++/test/ttypes.cpp
@@ -80,6 +80,12 @@ typedef enum int_t {
INT_LONG, INT_ULONG, INT_LLONG, INT_ULLONG, INT_OTHER
} int_t;
+typedef struct {
+ int a;
+ float b;
+ long c;
+ double d;
+} src_typ_t;
/*-------------------------------------------------------------------------
* Function: test_classes
@@ -125,9 +131,7 @@ static void test_classes()
*
* Purpose Test datatype copy functionality
*
- * Return Success: 0
- *
- * Failure: number of errors
+ * Return None
*
* Programmer Binh-Minh Ribler (using C version)
* January, 2007
@@ -183,9 +187,7 @@ static void test_copy()
*
* Purpose Tests query functions of compound and enumeration types.
*
- * Return Success: 0
- *
- * Failure: number of errors
+ * Return None
*
* Programmer Binh-Minh Ribler (use C version)
* January, 2007
@@ -200,12 +202,6 @@ const H5std_string EnumT_NAME("Enum_type");
static void test_query()
{
- typedef struct {
- int a;
- float b;
- long c;
- double d;
- } src_typ_t;
short enum_val;
// Output message about test being performed
@@ -317,9 +313,7 @@ static void test_query()
*
* Purpose Tests transient datatypes.
*
- * Return Success: 0
- *
- * Failure: number of errors
+ * Return None
*
* Programmer Binh-Minh Ribler (use C version)
* January, 2007
@@ -396,9 +390,7 @@ static void test_transient ()
*
* Purpose Tests named datatypes.
*
- * Return Success: 0
- *
- * Failure: number of errors
+ * Return None
*
* Programmer Binh-Minh Ribler (use C version)
* January, 2007
@@ -556,6 +548,229 @@ static void test_named ()
} // test_named
+/*-------------------------------------------------------------------------
+ * Function: test_encode_decode
+ *
+ * Purpose Test datatype encode/decode functionality.
+ *
+ * Return None
+ *
+ * Programmer Binh-Minh Ribler (using C version)
+ * August, 2017
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+const H5std_string filename3("encode_decode.h5");
+const int ARRAY1_RANK = 1;
+const int ARRAY1_DIM = 10;
+static void test_encode_decode()
+{
+ short enum_val;
+
+ SUBTEST("DataType::encode() and DataType::decode()");
+ try {
+ // Create the file.
+ H5File file(filename3, H5F_ACC_TRUNC);
+
+ //
+ // Test with CompType
+ //
+
+ // Create a compound datatype
+ CompType cmptyp(sizeof(src_typ_t));
+
+ cmptyp.insertMember("a", HOFFSET(src_typ_t, a), PredType::NATIVE_INT);
+ cmptyp.insertMember("b", HOFFSET(src_typ_t, b), PredType::NATIVE_FLOAT);
+ cmptyp.insertMember("c", HOFFSET(src_typ_t, c), PredType::NATIVE_LONG);
+ cmptyp.insertMember("d", HOFFSET(src_typ_t, d), PredType::NATIVE_DOUBLE);
+
+ // Encode compound type in its buffer
+ cmptyp.encode();
+
+ // Verify that encoding had been done
+ verify_val(cmptyp.hasBinaryDesc(), true, "DataType::encode", __LINE__, __FILE__);
+
+ // Decode compound type's buffer to a new CompType
+ CompType* decoded_cmp_ptr(static_cast<CompType *>(cmptyp.decode()));
+
+ // Verify that the datatype was copied exactly via encoding/decoding
+ verify_val(cmptyp == *decoded_cmp_ptr, true, "DataType::decode", __LINE__, __FILE__);
+
+ // Verify again via querying member number and member index by name.
+ verify_val(decoded_cmp_ptr->getNmembers(), 4, "DataType::decode", __LINE__, __FILE__);
+ verify_val(decoded_cmp_ptr->getMemberIndex("c"), 2, "DataType::decode", __LINE__, __FILE__);
+
+ // Create a CompType instance from the pointer and verify it
+ CompType cmptyp_clone(*decoded_cmp_ptr);
+ verify_val(cmptyp == cmptyp_clone, true, "DataType::decode", __LINE__, __FILE__);
+ verify_val(cmptyp_clone.getNmembers(), 4, "DataType::decode", __LINE__, __FILE__);
+ verify_val(cmptyp_clone.getMemberIndex("c"), 2, "DataType::decode", __LINE__, __FILE__);
+
+ delete decoded_cmp_ptr;
+
+ //
+ // Test with EnumType
+ //
+
+ // Create a enumerate datatype
+ EnumType enumtyp(sizeof(short));
+
+ enumtyp.insert("RED", (enum_val=0,&enum_val));
+ enumtyp.insert("GREEN", (enum_val=1,&enum_val));
+ enumtyp.insert("BLUE", (enum_val=2,&enum_val));
+ enumtyp.insert("ORANGE", (enum_val=3,&enum_val));
+ enumtyp.insert("YELLOW", (enum_val=4,&enum_val));
+
+ // Encode compound type in a buffer
+ enumtyp.encode();
+
+ // Verify that encoding had been done
+ verify_val(enumtyp.hasBinaryDesc(), true, "DataType::encode", __LINE__, __FILE__);
+
+ // Decode enumeration type's buffer to a new EnumType
+ EnumType* decoded_enum_ptr(static_cast<EnumType *>(enumtyp.decode()));
+
+ // Verify that the datatype was copied exactly via encoding/decoding
+ verify_val(enumtyp == *decoded_enum_ptr, true, "DataType::decode", __LINE__, __FILE__);
+
+ // Verify again via querying member number and member index by name.
+ verify_val(decoded_enum_ptr->getNmembers(), 5, "DataType::decode", __LINE__, __FILE__);
+ verify_val(decoded_enum_ptr->getMemberIndex("GREEN"), 1, "DataType::decode", __LINE__, __FILE__);
+
+ // Create a EnumType instance from the pointer and verify it
+ EnumType enumtyp_clone(*decoded_enum_ptr);
+ verify_val(enumtyp == enumtyp_clone, true, "DataType::decode", __LINE__, __FILE__);
+ verify_val(enumtyp_clone.getNmembers(), 5, "DataType::decode", __LINE__, __FILE__);
+ verify_val(enumtyp_clone.getMemberIndex("GREEN"), 1, "DataType::decode", __LINE__, __FILE__);
+
+ delete decoded_enum_ptr;
+
+ //
+ // Test with variable-length string
+ //
+
+ // Create a variable-length string type
+ StrType vlsttyp(PredType::C_S1);
+ vlsttyp.setSize(H5T_VARIABLE);
+
+ // Encode the variable-length type in its buffer
+ vlsttyp.encode();
+
+ // Verify that encoding had been done
+ verify_val(vlsttyp.hasBinaryDesc(), true, "DataType::encode", __LINE__, __FILE__);
+
+ // Decode the variable-length type's buffer to a new StrType
+ StrType* decoded_str_ptr(static_cast<StrType *>(vlsttyp.decode()));
+
+ verify_val(vlsttyp == *decoded_str_ptr, true, "DataType::decode", __LINE__, __FILE__);
+ verify_val(decoded_str_ptr->isVariableStr(), true, "DataType::decode", __LINE__, __FILE__);
+
+ delete decoded_str_ptr;
+
+ // Test decoding the type by way of DataType*
+
+ // Decode variable-length string type to a new DataType
+ DataType* decoded_vlstr_ptr(vlsttyp.decode());
+
+ // Create a StrType instance from the DataType object and verify it
+ StrType decoded_vlsttyp(decoded_vlstr_ptr->getId());
+ verify_val(vlsttyp == decoded_vlsttyp, true, "DataType::decode", __LINE__, __FILE__);
+ verify_val(decoded_vlsttyp.isVariableStr(), true, "DataType::decode", __LINE__, __FILE__);
+
+ delete decoded_vlstr_ptr;
+
+ //
+ // Test with ArrayType
+ //
+
+ hsize_t tdims1[] = {ARRAY1_DIM};
+
+ // Create an array datatype of the compound datatype
+ ArrayType arrtyp(cmptyp, ARRAY1_RANK, tdims1);
+
+ // Encode the array type in its buffer
+ arrtyp.encode();
+
+ // Verify that encoding had been done
+ verify_val(arrtyp.hasBinaryDesc(), true, "DataType::encode", __LINE__, __FILE__);
+
+ // Create an ArrayType instance from the decoded pointer and verify it
+ ArrayType* decoded_arr_ptr(static_cast<ArrayType *>(arrtyp.decode()));
+
+ verify_val(arrtyp == *decoded_arr_ptr, true, "DataType::decode", __LINE__, __FILE__);
+
+ delete decoded_arr_ptr;
+
+ // Test decoding the type by way of DataType*
+
+ // Decode the array type's buffer
+ DataType *decoded_dt_ptr = arrtyp.decode();
+
+ // Create a ArrayType instance from the decoded pointer and verify it
+ ArrayType decoded_arrtyp(decoded_dt_ptr->getId());
+ verify_val(arrtyp == decoded_arrtyp, true, "DataType::decode", __LINE__, __FILE__);
+ verify_val(decoded_arrtyp.getArrayNDims(), ARRAY1_RANK, "DataType::decode", __LINE__, __FILE__);
+
+ delete decoded_dt_ptr;
+
+ //
+ // Test with IntType
+ //
+
+ // Create an int datatype
+ IntType inttyp(PredType::NATIVE_UINT);
+
+ // Encode the array type in its buffer
+ inttyp.encode();
+
+ // Verify that encoding had been done
+ verify_val(inttyp.hasBinaryDesc(), true, "DataType::encode", __LINE__, __FILE__);
+
+ // Create an IntType instance from the decoded pointer and verify it
+ IntType* decoded_int_ptr(static_cast<IntType *>(inttyp.decode()));
+ H5T_sign_t int_sign = decoded_int_ptr->getSign();
+ verify_val(int_sign, H5T_SGN_NONE, "DataType::decode", __LINE__, __FILE__);
+ verify_val(inttyp == *decoded_int_ptr, true, "DataType::decode", __LINE__, __FILE__);
+
+ delete decoded_int_ptr;
+
+ //
+ // Test decoding FloatType by way of DataType*
+ //
+
+ // Create a float datatype
+ FloatType flttyp(PredType::NATIVE_FLOAT);
+
+ // Encode the float type in its buffer
+ flttyp.encode();
+
+ // Verify that encoding had been done
+ verify_val(flttyp.hasBinaryDesc(), true, "DataType::encode", __LINE__, __FILE__);
+
+ // Decode the array type's buffer
+ DataType* decoded_flt_ptr(flttyp.decode());
+
+ // Create a IntType instance from the decoded pointer and verify it
+ FloatType decoded_flttyp(decoded_flt_ptr->getId());
+ verify_val(flttyp == decoded_flttyp, true, "DataType::decode", __LINE__, __FILE__);
+
+ H5std_string norm_string;
+ H5T_norm_t mant_norm = decoded_flttyp.getNorm(norm_string);
+ //verify_val(decoded_flttyp.isVariableStr(), true, "DataType::decode", __LINE__, __FILE__);
+
+ delete decoded_flt_ptr;
+
+ PASSED();
+ }
+ catch (Exception& E)
+ {
+ issue_fail_msg("test_encode_decode", __LINE__, __FILE__, E.getCDetailMsg());
+ }
+}
+
+
/****************************************************************
**
** test_types(): Main datatypes testing routine.
@@ -573,6 +788,7 @@ void test_types()
test_query();
test_transient();
test_named();
+ test_encode_decode();
} // test_types()