1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
|
#include <string>
#include "H5Include.h"
#include "H5RefCounter.h"
#include "H5Exception.h"
#include "H5IdComponent.h"
#include "H5PropList.h"
#include "H5Object.h"
#include "H5Alltypes.h"
#include "H5AbstractDs.h"
#include "H5DxferProp.h"
#include "H5DataSpace.h"
#include "H5DataSet.h"
#ifndef H5_NO_NAMESPACE
namespace H5 {
#endif
// Creates a new compound datatype
CompType::CompType( size_t size ) : DataType( H5T_COMPOUND, size ) {}
// Creates a compound datatype using an existing id
CompType::CompType( const hid_t existing_id ) : DataType( existing_id ) {}
// Default constructor
CompType::CompType() : DataType() {}
// Copy constructor: makes copy of the original CompType object
CompType::CompType( const CompType& original ) : DataType( original ) {}
// Gets the compound datatype of the specified dataset - reimplement this
CompType::CompType( const DataSet& dataset ) : DataType()
{
// Calls C function H5Dget_type to get the id of the datatype
id = H5Dget_type( dataset.getId() );
// If the datatype id is invalid, throw exception
if( id <= 0 )
{
throw DataSetIException();
}
}
// Retrieves the number of members in this compound datatype.
int CompType::getNmembers() const
{
int num_members = H5Tget_nmembers( id );
if( num_members < 0 )
{
throw DataTypeIException();
}
return( num_members );
}
// Retrieves the name of a member of this compound datatype.
string CompType::getMemberName( int member_num ) const
{
char* member_name_C = H5Tget_member_name( id, member_num );
if( member_name_C == NULL ) // should this be returned also???
{
throw DataTypeIException();
}
string member_name = string( member_name_C );
return( member_name );
}
// Retrieves the offset of a member of a compound datatype.
size_t CompType::getMemberOffset( int member_num ) const
{
size_t offset = H5Tget_member_offset( id, member_num );
// Q. said: for now, 0 is not a failure
//if( offset == 0 )
//{
//throw DataTypeIException();
//}
return( offset );
}
// Returns the dimensionality of the member.
int CompType::getMemberDims( int member_num, size_t* dims, int* perm ) const
{
throw DataTypeIException( "Error: getMemberDims is no longer supported." );
}
// Gets the type class of the specified member.
H5T_class_t CompType::getMemberClass( int member_num ) const
{
// get the member datatype first
hid_t member_type_id = H5Tget_member_type( id, member_num );
if( member_type_id <= 0 )
{
throw DataTypeIException();
}
// then get its class
H5T_class_t member_class = H5Tget_class( member_type_id );
if( member_class == H5T_NO_CLASS )
{
throw DataTypeIException();
}
return( member_class );
}
// This private member function calls the C API to get the identifier
// of the specified member. It is used by the getMemberXxxType
// below for the sub-types.
hid_t CompType::p_getMemberType( int member_num ) const
{
hid_t member_type_id = H5Tget_member_type( id, member_num );
if( member_type_id > 0 )
return( member_type_id );
else
{
throw DataTypeIException();
}
}
// Returns the datatype of the specified member in this compound datatype.
DataType CompType::getMemberDataType( int member_num ) const
{
DataType datatype( p_getMemberType( member_num ));
return( datatype );
}
EnumType CompType::getMemberEnumType( int member_num ) const
{
EnumType enumtype( p_getMemberType( member_num ));
return( enumtype );
}
CompType CompType::getMemberCompType( int member_num ) const
{
CompType comptype( p_getMemberType( member_num ));
return( comptype );
}
IntType CompType::getMemberIntType( int member_num ) const
{
IntType inttype( p_getMemberType( member_num ));
return( inttype );
}
FloatType CompType::getMemberFloatType( int member_num ) const
{
FloatType floatype( p_getMemberType( member_num ));
return( floatype );
}
StrType CompType::getMemberStrType( int member_num ) const
{
StrType strtype( p_getMemberType( member_num ));
return( strtype );
}
/* old style of getMemberType - using overloads; new style above
returns the appropriate datatypes but has different named functions.
// Returns the datatype of the specified member in this compound datatype.
// Several overloading of getMemberType are for different datatypes
void CompType::getMemberType( int member_num, EnumType& enumtype ) const
{
p_getMemberType( member_num, enumtype );
}
void CompType::getMemberType( int member_num, CompType& comptype ) const
{
p_getMemberType( member_num, comptype );
}
void CompType::getMemberType( int member_num, IntType& inttype ) const
{
p_getMemberType( member_num, inttype );
}
void CompType::getMemberType( int member_num, FloatType& floatype ) const
{
p_getMemberType( member_num, floatype );
}
void CompType::getMemberType( int member_num, StrType& strtype ) const
{
p_getMemberType( member_num, strtype );
}
// end of overloading of getMemberType
*/
// Adds a new member to a compound datatype
void CompType::insertMember( const string name, size_t offset, const DataType& new_member ) const
{
// Convert string to C-string
const char* name_C;
name_C = name.c_str(); // name_C refers to the contents of name as a C-str
hid_t new_member_id = new_member.getId(); // get new_member id for C API
// Call C routine H5Tinsert to add the new member
herr_t ret_value = H5Tinsert( id, name_C, offset, new_member_id );
if( ret_value < 0 )
{
throw DataTypeIException();
}
}
// Adds an array member to this compound datatype.
void CompType::insertMember( const string member_name, size_t offset, int ndims, const size_t* dim, const int* perm, const DataType& new_member ) const
{
throw DataTypeIException( "Error: insertMember is no longer supported.");
}
// Recursively removes padding from within a compound datatype.
void CompType::pack() const
{
// Calls C routine H5Tpack to remove padding
herr_t ret_value = H5Tpack( id );
if( ret_value < 0 )
{
throw DataTypeIException();
}
}
// This destructor just invokes the base-class' destructor
CompType::~CompType() {}
#ifndef H5_NO_NAMESPACE
} // end namespace
#endif
|
