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
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
|
<html>
<head>
<title>HDF5 C++ API Interfaces</title>
</head>
<body bgcolor=#FFFFFF>
<pre>
HDF5 C++ Interfaces
===================
// HDF5 dataset and attribute have some common characteristics, so the
// term abstract dataset is used to name the element that can represent
// both objects, dataset and attribute.
//
// Class AbstractDs is an abstract base class, from which Attribute and
// DataSet inherit. It provides the services that are common to both
// Attribute and DataSet. It also inherits from H5Object and passes down
// the services that H5Object provides.
class AbstractDs : public H5Object
// Gets the dataspace of this abstract dataset - pure virtual
virtual DataSpace getSpace() const = 0;
// Gets the class of the datatype that is used by this abstract
// dataset
H5T_class_t getTypeClass() const;
// Gets a copy of the datatype that this abstract dataset uses.
// Note that this datatype is a generic one and can only be accessed
// via generic member functions, i.e., member functions belong to
// DataType. To get specific datatype, i.e. EnumType, FloatType,
// etc..., use the specific functions, that follow, instead.
DataType getDataType() const;
// Gets a copy of the specific datatype of this abstract dataset
EnumType getEnumType() const;
CompType getCompType() const;
IntType getIntType() const;
FloatType getFloatType() const;
StrType getStrType() const;
// Copy constructor
AbstractDs( const AbstractDs& original );
virtual ~AbstractDs();
// end of class AbstractDs
// Atomic datatype can be an integer, float, string, or predefined datatype.
//
// Class AtomType is a base class, from which IntType, FloatType, StrType,
// and PredType inherit. It provides the services that are common to these
// subclasses. It also inherits from DataType and passes down the
// services that are common to all the datatypes.
class AtomType : public DataType
// Sets the total size for an atomic datatype.
void setSize( size_t size ) const;
// Returns the byte order of an atomic datatype.
H5T_order_t getOrder( string& order_string ) const;
// Sets the byte ordering of an atomic datatype.
void setOrder( H5T_order_t order ) const;
// Returns the precision of an atomic datatype.
size_t getPrecision() const;
// Sets the precision of an atomic datatype.
void setPrecision( size_t precision ) const;
// Gets the bit offset of the first significant bit.
int getOffset() const;
// Sets the bit offset of the first significant bit.
void setOffset( size_t offset ) const;
// Copy constructor
AtomType( const AtomType& original );
virtual ~AtomType();
// end of class AtomType
// An attribute is an abstract dataset because it has some characteristics
// that a dataset also has, but not all.
//
// Class Attribute inherits from AbstractDs and provides accesses to an
// attribute.
class Attribute : public AbstractDs
// Writes data to this attribute.
void write(const DataType& mem_type, void *buf ) const;
// Reads data from this attribute.
void read( const DataType& mem_type, void *buf ) const;
// Gets a copy of the dataspace for this attribute.
virtual DataSpace getSpace() const;
// Gets the name of this attribute.
string getName( size_t buf_size ) const;
// An attribute doesn't have the ability to iterate, simply because
// it doesn't have any attributes associated with it. Thus, the
// implementation of this member which is inherited from H5Object
// is overwritten to do nothing here.
int iterateAttrs() const;
// Creates a copy of an existing attribute using the attribute id
Attribute( const hid_t attr_id );
// Copy constructor
Attribute( const Attribute& original );
virtual ~Attribute();
// CommonFG is a protocol class. Its existence is simply to provide the
// common services that are provided by H5File and Group. The file or
// group in the context of this class is referred to as 'location'.
class CommonFG
// Creates a new group at this location.
Group createGroup( const string& name, size_t size_hint = 0 ) const;
Group createGroup( const char* name, size_t size_hint = 0 ) const;
// Opens an existing group in a location.
Group openGroup( const string& name ) const;
Group openGroup( const char* name ) const;
// Creates a new dataset at this location.
DataSet createDataSet( const string& name, const DataType& data_type, const DataSpace& data_space, const DSetCreatPropList& create_plist = DSetCreatPropList::DEFAULT ) const;
DataSet createDataSet( const char* name, const DataType& data_type, const DataSpace& data_space, const DSetCreatPropList& create_plist = DSetCreatPropList::DEFAULT ) const;
// Opens an existing dataset at this location.
DataSet openDataSet( const string& name ) const;
DataSet openDataSet( const char* name ) const;
// Creates a link of the specified type from new_name to current_name;
// both names are interpreted relative to this location.
void link( H5G_link_t link_type, const string& curr_name, const string& new_name ) const;
void link( H5G_link_t link_type, const char* curr_name, const char* new_name ) const;
// Removes the specified name at this location.
void unlink( const string& name ) const;
void unlink( const char* name ) const;
// Renames an HDF5 object at this location.
void move( const string& src, const string& dst ) const;
void move( const char* src, const char* dst ) const;
// Returns information about an HDF5 object, given by its name, at this location.
void getObjinfo( const string& name, hbool_t follow_link, H5G_stat_t& statbuf ) const;
void getObjinfo( const char* name, hbool_t follow_link, H5G_stat_t& statbuf ) const;
// Returns the name of the HDF5 object that the symbolic link points to.
string getLinkval( const string& name, size_t size ) const;
string getLinkval( const char* name, size_t size ) const;
// Sets the comment for the HDF5 object specified by its name.
void setComment( const string& name, const string& comment ) const;
void setComment( const char* name, const char* comment ) const;
// Retrieves comment for the HDF5 object specified by its name.
string getComment( const string& name, size_t bufsize ) const;
string getComment( const char* name, size_t bufsize ) const;
// Mounts the file 'child' onto this location.
void mount( const string& name, H5File& child, PropList& plist ) const;
void mount( const char* name, H5File& child, PropList& plist) const;
// Unmounts the file named 'name' from this location.
void unmount( const string& name ) const;
void unmount( const char* name ) const;
// Iterates over the elements of this location - not implemented in
// C++ style yet
int iterateElems( const string& name, int *idx, H5G_iterate_t op, void *op_data );
int iterateElems( const char* name, int *idx, H5G_iterate_t op, void *op_data );
// Opens a generic named datatype at this location
DataType openDataType( const string& name ) const;
DataType openDataType( const char* name ) const;
// Opens a named enumeration datatype at this location
EnumType openEnumType( const string& name ) const;
EnumType openEnumType( const char* name ) const;
// Opens a named compound datatype at this location
CompType openCompType( const string& name ) const;
CompType openCompType( const char* name ) const;
// Opens a named integer datatype at this location
IntType openIntType( const string& name ) const;
IntType openIntType( const char* name ) const;
// Opens a named floating-point datatype at this location
FloatType openFloatType( const string& name ) const;
FloatType openFloatType( const char* name ) const;
// Opens a named string datatype at this location
StrType openStrType( const string& name ) const;
StrType openStrType( const char* name ) const;
// For H5File and Group to throw appropriate exception - pure virtual
virtual void throwException() const = 0;
// Get id of the location, either group or file - pure virtual
virtual hid_t getLocId() const = 0;
CommonFG();
virtual ~CommonFG();
// end of CommonFG declaration
// Class CompType inherits from DataType and provides accesses to a compound
// datatype.
class CompType : public DataType
// Creates a new compound datatype, given the type's size.
CompType( size_t size );
// Creates a compound datatype using an existing id.
CompType( const hid_t existing_id );
// Gets the compound datatype of the specified dataset.
CompType( const DataSet& dataset );
// Returns the number of members in this compound datatype.
int getNmembers() const;
// Returns the name of a member of this compound datatype.
string getMemberName( int member_num ) const;
// Returns the offset of a member of this compound datatype.
size_t getMemberOffset( int memb_no ) const;
// Returns the dimensionality of the specified member of this compound datatype.
int getMemberDims( int member_num, size_t* dims, int* perm ) 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.
H5T_class_t getMemberClass( int member_num ) const;
// Returns the generic datatype of the specified member in
// this compound datatype.
DataType getMemberDataType( int member_num ) const;
// Returns the enumeration datatype of the specified member in
// this compound datatype.
EnumType getMemberEnumType( int member_num ) const;
// Returns the compound datatype of the specified member in
// this compound datatype.
CompType getMemberCompType( int member_num ) const;
// Returns the integer datatype of the specified member in
// this compound datatype.
IntType getMemberIntType( int member_num ) const;
// Returns the floating-point datatype of the specified member in
// this compound datatype.
FloatType getMemberFloatType( int member_num ) const;
// Returns the string datatype of the specified member in
// this compound datatype.
StrType getMemberStrType( int member_num ) const;
// Adds a new member to this compound datatype.
void insertMember( const string name, size_t offset, const DataType& new_member ) const;
// Recursively removes padding from within this compound datatype.
void pack() const;
// Default constructor
CompType();
// Copy constructor
CompType( const CompType& original );
virtual ~CompType();
// end of class CompType
// Class DataSet inherits from AbstractDs and provides accesses to a dataset.
class DataSet : public AbstractDs
// Gets the dataspace of this dataset.
virtual DataSpace getSpace() const;
// Gets the creation property list of this dataset.
DSetCreatPropList getCreatePlist() const;
// Gets the storage size of this dataset.
hsize_t getStorageSize() const;
// Reads the data of this dataset and stores it in the provided buffer.
// The memory and file dataspaces and the transferring property list
// can be defaults.
void read( void* buf, const DataType& mem_type, const DataSpace& mem_space = DataSpace::ALL, const DataSpace& file_space = DataSpace::ALL, const DSetMemXferPropList& xfer_plist = DSetMemXferPropList::DEFAULT ) const;
// Writes the buffered data to this dataset.
// The memory and file dataspaces and the transferring property list
// can be defaults.
void write( const void* buf, const DataType& mem_type, const DataSpace& mem_space = DataSpace::ALL, const DataSpace& file_space = DataSpace::ALL, const DSetMemXferPropList& xfer_plist = DSetMemXferPropList::DEFAULT ) const;
// Extends the dataset with unlimited dimension.
void extend( const hsize_t* size ) const;
// Default constructor
DataSet();
// Copy constructor
DataSet( const DataSet& original );
virtual ~DataSet();
// end of class DataSet
// Class DataSpace provides accesses to the dataspace.
class DataSpace : public IdComponent
// Default DataSpace objects
static const DataSpace ALL;
// Creates a dataspace object given the space type.
DataSpace( H5S_class_t type );
// Creates a simple dataspace.
DataSpace( int rank, const hsize_t * dims, const hsize_t * maxdims = NULL);
// Makes copy of an existing dataspace.
void copy( const DataSpace& like_space );
// Determines if this dataspace is a simple one.
bool isSimple () const;
// Sets the offset of this simple dataspace.
void offsetSimple ( const hssize_t* offset ) const;
// Retrieves dataspace dimension size and maximum size.
int getSimpleExtentDims ( hsize_t *dims, hsize_t *maxdims = NULL ) const;
// Gets the dimensionality of this dataspace.
int getSimpleExtentNdims () const;
// Gets the number of elements in this dataspace.
hssize_t getSimpleExtentNpoints () const;
// Gets the current class of this dataspace.
H5S_class_t getSimpleExtentType () const;
// Copies the extent of this dataspace.
void extentCopy ( DataSpace& dest_space ) const;
// Sets or resets the size of this dataspace.
void setExtentSimple( int rank, const hsize_t *current_size, const hsize_t *maximum_size = NULL ) const;
// Removes the extent from this dataspace.
void setExtentNone () const;
// Gets the number of elements in this dataspace selection.
hssize_t getSelectNpoints () const;
// Get number of hyperslab blocks.
hssize_t getSelectHyperNblocks () const;
// Gets the list of hyperslab blocks currently selected.
void getSelectHyperBlocklist( hsize_t startblock, hsize_t numblocks, hsize_t *buf ) const;
// Gets the number of element points in the current selection.
hssize_t getSelectElemNpoints () const;
// Retrieves the list of element points currently selected.
void getSelectElemPointlist ( hsize_t startpoint, hsize_t numpoints, hsize_t *buf ) const;
// Gets the bounding box containing the current selection.
void getSelectBounds ( hsize_t* start, hsize_t* end ) const;
// Selects array elements to be included in the selection for
// this dataspace.
void selectElements ( H5S_seloper_t op, const size_t num_elements, const hssize_t* coord[ ] ) const;
// Selects the entire dataspace.
void selectAll () const;
// Resets the selection region to include no elements.
void selectNone () const;
// Verifies that the selection is within the extent of the dataspace.
bool selectValid () const;
// Selects a hyperslab region to add to the current selected region.
void selectHyperslab( H5S_seloper_t op, const hsize_t *count, const hssize_t *start, const hsize_t *stride = NULL, const hsize_t *block = NULL ) const;
// Default constructor
DataSpace();
// Create a dataspace object from a dataspace identifier
DataSpace( const hid_t space_id );
// Copy constructor
DataSpace( const DataSpace& original );
virtual ~DataSpace();
// end of class DataSpace
// HDF5 datatype can be an atom datatype, a compound datatype, or an
// enumeration datatype. A datatype is itself a kind of HDF5 object.
//
// Class DataType provides accesses to a generic HDF5 datatype. It has
// characteristics which AtomType, CompType, and EnumType inherit. It also
// inherits from H5Object and passes down the services to its subclasses.
class DataType : public H5Object
// Creates a datatype given its class and size.
DataType( const H5T_class_t type_class, size_t size );
// Copies an existing datatype to this datatype instance.
void copy( const DataType& like_type );
// Returns the datatype class identifier of this datatype.
H5T_class_t getClass() const;
// Commits a transient datatype to a file; this datatype becomes
// a named datatype which can be accessed from the location.
void commit( H5Object& loc, const string& name ) const;
void commit( H5Object& loc, const char* name ) const;
// Determines whether this datatype is a named datatype or
// a transient datatype.
bool committed() const;
// Finds a conversion function that can handle the conversion
// of this datatype to the given datatype, dest.
H5T_conv_t find( const DataType& dest, H5T_cdata_t **pcdata ) const;
// Converts data from this datatype into the specified datatype, dest.
void convert( const DataType& dest, size_t nelmts, void *buf, void *background, PropList& plist ) const;
// Sets the overflow handler to a specified function.
void setOverflow(H5T_overflow_t func) const;
// Returns a pointer to the current global overflow function.
H5T_overflow_t getOverflow(void) const;
// Locks a datatype.
void lock() const;
// Returns the size of this datatype.
size_t getSize() const;
// Returns the base datatype from which a datatype is derived.
// Not implemented yet
DataType getSuper() const;
// Registers a conversion function.
void registerFunc(H5T_pers_t pers, const string& name, const DataType& dest, H5T_conv_t func ) const;
void registerFunc(H5T_pers_t pers, const char* name, const DataType& dest, H5T_conv_t func ) const;
// Removes a conversion function from all conversion paths.
void unregister( H5T_pers_t pers, const string& name, const DataType& dest, H5T_conv_t func ) const;
void unregister( H5T_pers_t pers, const char* name, const DataType& dest, H5T_conv_t func ) const;
// Tags an opaque datatype.
void setTag( const string& tag ) const;
void setTag( const char* tag ) const;
// Gets the tag associated with an opaque datatype.
string getTag() const;
// Creates a DataType using an existing id - this datatype is
// not a predefined type
DataType( const hid_t type_id, bool predtype = false );
// Default constructor
DataType();
// Copy constructor
DataType( const DataType& original );
virtual ~DataType();
// end of class DataType
// Class DSetCreatPropList provides accesses to a dataset creation
// property list.
class DSetCreatPropList : public PropList
// Default DSetCreatPropList object
static const DSetCreatPropList DEFAULT;
// Copies a dataset creation property list using assignment statement.
DSetCreatPropList& operator=( const DSetCreatPropList& rhs );
// Sets the type of storage used to store the raw data for the
// dataset that uses this property list.
void setLayout( hid_t plist, H5D_layout_t layout ) const;
// Gets the layout of the raw data storage of the data that uses this
// property list.
H5D_layout_t getLayout() const;
// Sets the size of the chunks used to store a chunked layout dataset.
void setChunk( int ndims, const hsize_t* dim ) const;
// Retrieves the size of the chunks used to store a chunked layout dataset.
int getChunk( int max_ndims, hsize_t* dim ) const;
// Sets compression method and compression level
void setDeflate( int level ) const;
// Sets a dataset fill value.
void setFillValue( DataType& fvalue_type, const void* value ) const;
// Retrieves a dataset fill value.
void getFillValue( DataType& fvalue_type, void* value ) const;
// Adds a filter to the filter pipeline
void setFilter( H5Z_filter_t filter, unsigned int flags, size_t cd_nelmts, const unsigned int cd_values[] ) const;
// Returns the number of filters in the pipeline.
int getNfilters() const;
// Returns information about a filter in a pipeline.
H5Z_filter_t getFilter( int filter_number, unsigned int& flags, size_t& cd_nelmts, unsigned int* cd_values, size_t namelen, char name[] ) const;
// Adds an external file to the list of external files.
void setExternal( const char* name, off_t offset, hsize_t size ) const;
// Returns the number of external files for a dataset.
int getExternalCount() const;
// Returns information about an external file
void getExternal( int idx, size_t name_size, char* name, off_t& offset, hsize_t& size ) const;
// Creates a copy of an existing dataset creation property list
// using the property list id
DSetCreatPropList( const hid_t plist_id );
// Default constructor
DSetCreatPropList();
// Copy constructor
DSetCreatPropList( const DSetCreatPropList& original );
virtual ~DSetCreatPropList();
// end of class DSetCreatPropList
// Class DSetMemXferPropList provides accesses to a dataset memory and
// transfer property list.
class DSetMemXferPropList : public PropList
// Default object for dataset memory and transfer property list
static const DSetMemXferPropList DEFAULT;
// Copies a dataset memory and transfer property list using
// assignment statement
DSetMemXferPropList& operator=( const DSetMemXferPropList& rhs );
// Sets type conversion and background buffers
void setBuffer( size_t size, void* tconv, void* bkg ) const;
// Reads buffer settings
size_t getBuffer( void** tconv, void** bkg ) const;
// Sets the dataset transfer property list status to TRUE or FALSE
void setPreserve( bool status ) const;
// Checks status of the dataset transfer property list
bool getPreserve() const;
// Indicates whether to cache hyperslab blocks during I/O
void setHyperCache( bool cache, unsigned limit = 0 ) const;
// Returns information regarding the caching of hyperslab blocks during I/O
void getHyperCache( bool& cache, unsigned& limit ) const;
// Sets B-tree split ratios for a dataset transfer property list
void setBtreeRatios( double left, double middle, double right ) const;
// Gets B-tree split ratios for a dataset transfer property list
void getBtreeRatios( double& left, double& middle, double& right ) const;
// Sets the memory manager for variable-length datatype
// allocation in H5Dread and H5Dvlen_reclaim
void setVlenMemManager( H5MM_allocate_t alloc, void* alloc_info,
H5MM_free_t free, void* free_info ) const;
// alloc and free are set to NULL, indicating that system
// malloc and free are to be used
void setVlenMemManager() const;
// Gets the memory manager for variable-length datatype
// allocation in H5Dread and H5Tvlen_reclaim
void getVlenMemManager( H5MM_allocate_t& alloc, void** alloc_info,
H5MM_free_t& free, void** free_info ) const;
// Sets the transfer mode - parallel mode, not currently supported
//void setXfer( H5D_transfer_t data_xfer_mode = H5D_XFER_INDEPENDENT ) const;
// Gets the transfer mode - parallel mode, not currently supported
//H5D_transfer_t getXfer() const;
// Creates a copy of an existing dataset memory and transfer
// property list using the property list id
DSetMemXferPropList (const hid_t plist_id)
// Default constructor
DSetMemXferPropList();
// Copy constructor
DSetMemXferPropList( const DSetMemXferPropList& original );
// Default destructor
virtual ~DSetMemXferPropList();
// end of class DSetMemXferPropList
class EnumType : public DataType
// Creates an empty enumeration datatype based on a native signed
// integer type, whose size is given by size.
EnumType( size_t size );
// Gets the enum datatype of the specified dataset
EnumType( const DataSet& dataset ); // H5Dget_type
// Creates a new enum datatype based on an integer datatype
EnumType( const IntType& data_type ); // H5Tenum_create
// Inserts a new member to this enumeration type.
void insert( const string& name, void *value ) const;
void insert( const char* name, void *value ) const;
// Returns the symbol name corresponding to a specified member
// of this enumeration datatype.
string nameOf( void *value, size_t size ) const;
// Returns the value corresponding to a specified member of this
// enumeration datatype.
void valueOf( const string& name, void *value ) const;
void valueOf( const char* name, void *value ) const;
// Returns the value of an enumeration datatype member
void getMemberValue( int memb_no, void *value ) const;
// Default constructor
EnumType();
// Creates an enumeration datatype using an existing id
EnumType( const hid_t existing_id );
// Copy constructor
EnumType( const EnumType& original );
virtual ~EnumType();
// end of class EnumType
class Exception
// Creates an exception with a detailed message
Exception( const string& message );
Exception( const char* message);
// Returns the character string that describes an error specified by
// a major error number.
string getMajorString( H5E_major_t major_num ) const;
// Returns the character string that describes an error specified by
// a minor error number.
string getMinorString( H5E_minor_t minor_num ) const;
// Returns the detailed message set at the time the exception is thrown
string getDetailMesg() const;
// Turns on the automatic error printing.
void setAutoPrint( H5E_auto_t func,
void* client_data ) const;
// Turns off the automatic error printing.
static void dontPrint();
// Retrieves the current settings for the automatic error stack
// traversal function and its data.
void getAutoPrint( H5E_auto_t& func,
void** client_data ) const;
// Clears the error stack for the current thread.
void clearErrorStack() const;
// Walks the error stack for the current thread, calling the
// specified function.
void walkErrorStack( H5E_direction_t direction,
H5E_walk_t func, void* client_data ) const;
// Default error stack traversal callback function that prints
// error messages to the specified output stream.
void walkDefErrorStack( int n, H5E_error_t& err_desc,
void* client_data ) const;
// Prints the error stack in a default manner.
//void printError() const;
void printError( FILE* stream = NULL ) const;
// Creates an exception with no message
Exception();
// copy constructor
Exception( const Exception& original );
// end of class Exception
// Class FileIException inherits from Exception to provide exception
// handling for H5File.
class FileIException : public Exception
FileIException();
FileIException( string message );
// end of class FileIException
// Class GroupIException inherits from Exception to provide exception
// handling for Group.
class GroupIException : public Exception
GroupIException();
GroupIException( string message );
// end of class GroupIException
// Class DataSpaceIException inherits from Exception to provide exception
// handling for DataSpace.
class DataSpaceIException : public Exception
DataSpaceIException();
DataSpaceIException( string message );
// end of class DataSpaceIException
// Class DataTypeIException inherits from Exception to provide exception
// handling for DataType.
class DataTypeIException : public Exception
DataTypeIException();
DataTypeIException( string message );
// end of class DataTypeIException
// Class PropListIException inherits from Exception to provide exception
// handling for PropList.
class PropListIException : public Exception
PropListIException();
PropListIException( string message );
// end of class PropListIException
// Class DataSetIException inherits from Exception to provide exception
// handling for DataSet.
class DataSetIException : public Exception
DataSetIException();
DataSetIException( string message );
// end of class DataSetIException
// Class AttributeIException inherits from Exception to provide exception
// handling for Attribute.
class AttributeIException : public Exception
AttributeIException();
AttributeIException( string message );
// end of class AttributeIException
// Class LibraryIException inherits from Exception to provide exception
// handling for H5Library.
class LibraryIException : public Exception
LibraryIException();
LibraryIException( string message );
// end of class LibraryIException
// Class IdComponentException inherits from Exception to provide exception
// handling for IdComponent.
class IdComponentException : public Exception
IdComponentException();
IdComponentException( string message );
// end of class IdComponentException
// Class FileAccPropList provides accesses to a file access property list.
class FileAccPropList : public PropList
// Default file access property list object
static const FileAccPropList DEFAULT;
// Copies a file access property list using assignment statement.
FileAccPropList& operator=( const FileAccPropList& rhs );
// Sets alignment properties of this file access property list.
void setAlignment( hsize_t threshold = 1, hsize_t alignment = 1 ) const;
// Retrieves the current settings for alignment properties from
// this file access property list.
void getAlignment( hsize_t& threshold, hsize_t& alignment ) const;
// Sets the meta data cache and raw data chunk cache parameters.
void setCache( int mdc_nelmts, int rdcc_nelmts, size_t rdcc_nbytes, double rdcc_w0 ) const;
// Retrieves maximum sizes of data caches and the preemption
// policy value.
void getCache( int& mdc_nelmts, int& rdcc_nelmts, size_t& rdcc_nbytes, double& rdcc_w0 ) const;
// Sets garbage collecting references flag.
void setGcReferences( unsigned gc_ref = 0 ) const;
// Returns garbage collecting references setting.
unsigned getGcReferences() const;
// Creates a copy of an existing file access property list
// using the property list id.
FileAccPropList (const hid_t plist_id);
// Default constructor
FileAccPropList();
// Copy constructor
FileAccPropList( const FileAccPropList& original );
// Default destructor
virtual ~FileAccPropList();
// end of class FileAccPropList
// Class FileCreatPropList provides accesses to a file creation property list.
class FileCreatPropList : public PropList
// Default file creation property list object
static const FileCreatPropList DEFAULT;
// Copies a file creation property list using assignment statement.
FileCreatPropList& operator=( const FileCreatPropList& rhs );
// Retrieves version information for various parts of a file.
void getVersion( int& boot, int& freelist, int& stab, int& shhdr ) const;
// Sets the userblock size field of a file creation property list.
void setUserblock( hsize_t size ) const;
// Gets the size of a user block in this file creation property list.
hsize_t getUserblock() const;
// Sets file size-of addresses and sizes.
void setSizes( size_t sizeof_addr = 4, size_t sizeof_size = 4 ) const;
// Retrieves the size-of address and size quantities stored in a
// file according to this file creation property list.
void getSizes( size_t& sizeof_addr, size_t& sizeof_size ) const;
// Sets the size of parameters used to control the symbol table nodes.
void setSymk( int int_nodes_k, int leaf_nodes_k ) const;
// Retrieves the size of the symbol table B-tree 1/2 rank and the
// symbol table leaf node 1/2 size.
void getSymk( int& int_nodes_k, int& leaf_nodes_k ) const;
// Sets the size of parameter used to control the B-trees for
// indexing chunked datasets.
void setIstorek( int ik ) const;
// Returns the 1/2 rank of an indexed storage B-tree.
int getIstorek() const;
// Creates a copy of an existing file create property list
// using the property list id.
FileCreatPropList (const hid_t plist_id);
// Default constructor
FileCreatPropList();
// Copy constructor
FileCreatPropList( const FileCreatPropList& original );
// Default destructor
virtual ~FileCreatPropList();
// end of class FileCreatPropList
// Class H5File provides accesses to an HDF5 file. It uses the services
// provided by CommonFG beside inheriting the HDF5 id management from the
// IdComponent class.
class H5File : public IdComponent, public CommonFG
// Creates or opens an HDF5 file. The file creation and access
// property lists can be default.
H5File( const string& name, unsigned int flags, const FileCreatPropList& create_plist = FileCreatPropList::DEFAULT, const FileAccPropList& access_plist = FileAccPropList::DEFAULT );
H5File( const char* name, unsigned int flags, const FileCreatPropList& create_plist = FileCreatPropList::DEFAULT, const FileAccPropList& access_plist = FileAccPropList::DEFAULT );
// Throw file exception - used by CommonFG to specifically throw
// FileIException.
virtual void throwException() const;
// Determines if a file, specified by its name, is in HDF5 format.
static bool isHdf5(const string& name );
static bool isHdf5(const char* name );
// Reopens this file.
void reopen();
// Gets the creation property list of this file.
FileCreatPropList getCreatePlist() const;
// Gets the access property list of this file.
FileAccPropList getAccessPlist() const;
// Copy constructor
H5File(const H5File& original );
virtual ~H5File();
// end of class H5File
// Class FloatType inherits from AtomType and provides accesses to a
// floating-point datatype.
class FloatType : public AtomType
// Creates a floating-point type using a predefined type.
FloatType( const PredType& pred_type );
// Gets the floating-point datatype of the specified dataset.
FloatType( const DataSet& dataset );
// Retrieves floating point datatype bit field information.
void getFields( size_t& spos, size_t& epos, size_t& esize, size_t& mpos, size_t& msize ) const;
// Sets locations and sizes of floating point bit fields.
void setFields( size_t spos, size_t epos, size_t esize, size_t mpos, size_t msize ) const;
// Retrieves the exponent bias of a floating-point type.
size_t getEbias() const;
// Sets the exponent bias of a floating-point type.
void setEbias( size_t ebias ) const;
// Retrieves mantissa normalization of a floating-point datatype.
H5T_norm_t getNorm( string& norm_string ) const;
// Sets the mantissa normalization of a floating-point datatype.
void setNorm( H5T_norm_t norm ) const;
// Retrieves the internal padding type for unused bits in
// floating-point datatypes.
H5T_pad_t getInpad( string& pad_string ) const;
// Fills unused internal floating point bits.
void setInpad( H5T_pad_t inpad ) const;
// Default constructor
FloatType();
// Creates a floating-point datatype using an existing id.
FloatType( const hid_t existing_id );
// Copy constructor
FloatType( const FloatType& original );
virtual ~FloatType();
// end of class FloatType
// Class Group provides accesses to an HDF5 group. As H5File, it uses the
// services provided by CommonFG. This class also inherits from H5Object.
class Group : public H5Object, public CommonFG
public:
// Throw group exception - used by CommonFG to specifically throw
// GroupIException.
virtual void throwException() const;
// Default constructor
Group();
// Copy constructor
Group( const Group& original );
virtual ~Group();
// end of class Group
// Class IdComponent provides a mechanism to handle reference counting
// for an identifier of any HDF5 object.
class IdComponent
// Sets the identifier of this object to a new value.
void setId( hid_t new_id );
// Creates an object to hold an HDF5 identifier.
IdComponent( const hid_t h5_id );
// Gets the value of the current HDF5 object id which is held
// by this IdComponent object.
hid_t getId () const;
// Increment reference counter.
void incRefCount();
// Decrement reference counter.
void decRefCount();
// Get the reference counter to this identifier.
int getCounter();
// Decrements the reference counter then determines if there are
// no more reference to this object.
bool noReference();
// Reset this object by deleting its reference counter of the old id.
void reset();
// Copy constructor
IdComponent( const IdComponent& original );
// Destructor
virtual ~IdComponent();
}; // end class IdComponent
// Class IntType inherits from AtomType and provides accesses to
// integer datatypes.
class IntType : public AtomType
// Creates a integer type using a predefined type.
IntType( const PredType& pred_type );
// Gets the integer datatype of the specified dataset.
IntType( const DataSet& dataset );
// Retrieves the sign type for an integer type.
H5T_sign_t getSign() const;
// Sets the sign proprety for an integer type.
void setSign( H5T_sign_t sign ) const;
// Default constructor
IntType();
// Creates a integer datatype using an existing id.
IntType( const hid_t existing_id );
// Copy constructor
IntType( const IntType& original );
virtual ~IntType();
// end of class IntType
// Class H5Library provides accesses to the HDF5 library. All of its
// member functions are static.
class H5Library
// Initializes the HDF5 library.
static void open();
// Flushes all data to disk, closes files, and cleans up memory.
static void close();
// Instructs library not to install atexit cleanup routine
static void dontAtExit();
// Returns the HDF library release number.
static void getLibVersion( unsigned& majnum, unsigned& minnum, unsigned& relnum );
// Verifies that the arguments match the version numbers compiled
// into the library
static void checkVersion( unsigned majnum, unsigned minnum, unsigned relnum );
// end of class H5Library
// An HDF5 object can be a group, dataset, attribute, or named datatype.
//
// Class H5Object provides the services that are typical to an HDF5 object
// so Group, DataSet, Attribute, and DataType can use them. It also
// inherits the HDF5 id management from the class IdComponent.
class H5Object : public IdComponent
// Flushes all buffers associated with this HDF5 object to disk.
void flush( H5F_scope_t scope ) const;
// Creates an attribute for a group, dataset, or named datatype.
// PropList is currently not used, it should always be default.
Attribute createAttribute( const char* name, const DataType& type, const DataSpace& space, const PropList& create_plist = PropList::DEFAULT ) const;
Attribute createAttribute( const string& name, const DataType& type, const DataSpace& space, const PropList& create_plist = PropList::DEFAULT ) const;
// Opens an attribute that belongs to this object, given the
// attribute name.
Attribute openAttribute( const string& name ) const;
Attribute openAttribute( const char* name ) const;
// Opens an attribute that belongs to this object, given the
// attribute index.
Attribute openAttribute( const unsigned int idx ) const;
// Iterate user's function over the attributes of this HDF5 object
int iterateAttrs( attr_operator_t user_op, unsigned* idx = NULL, void* op_data = NULL );
// Determines the number of attributes attached to this HDF5 object.
int getNumAttrs() const;
// Removes an attribute from this HDF5 object, given the attribute
// name.
void removeAttr( const string& name ) const;
void removeAttr( const char* name ) const;
// Copy constructor
H5Object( const H5Object& original );
virtual ~H5Object();
// end of class H5Object
// Class PredType contains all the predefined datatype objects that are
// currently available.
class PredType : public AtomType
static const PredType STD_I8BE;
static const PredType STD_I8LE;
static const PredType STD_I16BE;
static const PredType STD_I16LE;
static const PredType STD_I32BE;
static const PredType STD_I32LE;
static const PredType STD_I64BE;
static const PredType STD_I64LE;
static const PredType STD_U8BE;
static const PredType STD_U8LE;
static const PredType STD_U16BE;
static const PredType STD_U16LE;
static const PredType STD_U32BE;
static const PredType STD_U32LE;
static const PredType STD_U64BE;
static const PredType STD_U64LE;
static const PredType STD_B8BE;
static const PredType STD_B8LE;
static const PredType STD_B16BE;
static const PredType STD_B16LE;
static const PredType STD_B32BE;
static const PredType STD_B32LE;
static const PredType STD_B64BE;
static const PredType STD_B64LE;
static const PredType STD_REF_OBJ;
static const PredType STD_REF_DSETREG;
static const PredType C_S1;
static const PredType FORTRAN_S1;
static const PredType IEEE_F32BE;
static const PredType IEEE_F32LE;
static const PredType IEEE_F64BE;
static const PredType IEEE_F64LE;
static const PredType UNIX_D32BE;
static const PredType UNIX_D32LE;
static const PredType UNIX_D64BE;
static const PredType UNIX_D64LE;
static const PredType INTEL_I8;
static const PredType INTEL_I16;
static const PredType INTEL_I32;
static const PredType INTEL_I64;
static const PredType INTEL_U8;
static const PredType INTEL_U16;
static const PredType INTEL_U32;
static const PredType INTEL_U64;
static const PredType INTEL_B8;
static const PredType INTEL_B16;
static const PredType INTEL_B32;
static const PredType INTEL_B64;
static const PredType INTEL_F32;
static const PredType INTEL_F64;
static const PredType ALPHA_I8;
static const PredType ALPHA_I16;
static const PredType ALPHA_I32;
static const PredType ALPHA_I64;
static const PredType ALPHA_U8;
static const PredType ALPHA_U16;
static const PredType ALPHA_U32;
static const PredType ALPHA_U64;
static const PredType ALPHA_B8;
static const PredType ALPHA_B16;
static const PredType ALPHA_B32;
static const PredType ALPHA_B64;
static const PredType ALPHA_F32;
static const PredType ALPHA_F64;
static const PredType MIPS_I8;
static const PredType MIPS_I16;
static const PredType MIPS_I32;
static const PredType MIPS_I64;
static const PredType MIPS_U8;
static const PredType MIPS_U16;
static const PredType MIPS_U32;
static const PredType MIPS_U64;
static const PredType MIPS_B8;
static const PredType MIPS_B16;
static const PredType MIPS_B32;
static const PredType MIPS_B64;
static const PredType MIPS_F32;
static const PredType MIPS_F64;
static const PredType NATIVE_CHAR;
static const PredType NATIVE_SCHAR;
static const PredType NATIVE_UCHAR;
static const PredType NATIVE_SHORT;
static const PredType NATIVE_USHORT;
static const PredType NATIVE_INT;
static const PredType NATIVE_UINT;
static const PredType NATIVE_LONG;
static const PredType NATIVE_ULONG;
static const PredType NATIVE_LLONG;
static const PredType NATIVE_ULLONG;
static const PredType NATIVE_FLOAT;
static const PredType NATIVE_DOUBLE;
static const PredType NATIVE_LDOUBLE;
static const PredType NATIVE_B8;
static const PredType NATIVE_B16;
static const PredType NATIVE_B32;
static const PredType NATIVE_B64;
static const PredType NATIVE_OPAQUE;
static const PredType NATIVE_HSIZE;
static const PredType NATIVE_HSSIZE;
static const PredType NATIVE_HERR;
static const PredType NATIVE_HBOOL;
static const PredType NATIVE_INT8;
static const PredType NATIVE_UINT8;
static const PredType NATIVE_INT_LEAST8;
static const PredType NATIVE_UINT_LEAST8;
static const PredType NATIVE_INT_FAST8;
static const PredType NATIVE_UINT_FAST8;
static const PredType NATIVE_INT16;
static const PredType NATIVE_UINT16;
static const PredType NATIVE_INT_LEAST16;
static const PredType NATIVE_UINT_LEAST16;
static const PredType NATIVE_INT_FAST16;
static const PredType NATIVE_UINT_FAST16;
static const PredType NATIVE_INT32;
static const PredType NATIVE_UINT32;
static const PredType NATIVE_INT_LEAST32;
static const PredType NATIVE_UINT_LEAST32;
static const PredType NATIVE_INT_FAST32;
static const PredType NATIVE_UINT_FAST32;
static const PredType NATIVE_INT64;
static const PredType NATIVE_UINT64;
static const PredType NATIVE_INT_LEAST64;
static const PredType NATIVE_UINT_LEAST64;
static const PredType NATIVE_INT_FAST64;
static const PredType NATIVE_UINT_FAST64;
// Copy constructor
PredType( const PredType& original );
// Default destructor
virtual ~PredType();
protected:
// Default constructor
PredType();
// Creates a pre-defined type using an HDF5 pre-defined constant
PredType( const hid_t predtype_id ); // used by the library only
// end of class PredType
// An HDF5 property list can be a file creation property list, a file
// access property list, a dataset creation property list, or a dataset
// memory and transfer property list.
//
// Class PropList provides accesses to an HDF5 property list. Its
// services are inherited by classes FileCreatPropList, FileAccPropList,
// DSetCreatPropList, and DSetMemXferPropList. It also inherits the HDF5
// id management from the class IdComponent.
class PropList : public IdComponent
// Default property list object
static const PropList DEFAULT;
// Creates a property list given the property list type.
PropList( H5P_class_t type );
// Makes a copy of the given property list.
void copy( const PropList& like_plist );
// Gets the class of this property list, i.e. H5P_FILE_CREATE,
// H5P_FILE_ACCESS, ...
H5P_class_t getClass() const;
// Default constructor
PropList();
// Copy constructor
PropList( const PropList& original );
// Creates a default property list or creates a copy of an
// existing property list giving the property list id
PropList( const hid_t plist_id );
virtual ~PropList();
// end of class PropList
// Class RefCounter provides a reference counting mechanism. It is used
// mainly by IdComponent to keep track of the references to an HDF5 object
// identifier.
class RefCounter
// Returns the value of the counter.
int getCounter () const;
// Increments and decrements the counter.
void increment();
void decrement();
// This bool function is used to determine whether to close an
// HDF5 object when there are no more reference to that object.
// It decrements the counter, then returns true if there are no
// other object references the associated identifier. When the
// function returns true, the associated identifier can be closed
// safely.
bool noReference();
// Default constructor
RefCounter();
~RefCounter();
// end of class RefCounter
// Class StrType inherits from AtomType and provides accesses to a
// string datatype.
class StrType : public AtomType
public:
// Creates a string type using a predefined type.
StrType( const PredType& pred_type );
// Gets the string datatype of the specified dataset.
StrType( const DataSet& dataset );
// Returns the character set type of this string datatype.
H5T_cset_t getCset() const;
// Sets character set to be used.
void setCset( H5T_cset_t cset ) const;
// Returns the string padding method for this string datatype.
H5T_str_t getStrpad() const;
// Defines the storage mechanism for character strings.
void setStrpad( H5T_str_t strpad ) const;
// Default constructor
StrType();
// Copy constructor
StrType( const StrType& original );
// Creates a string datatype using an existing id.
StrType( const hid_t existing_id );
virtual ~StrType();
// end of class StrType
// This template function, resetIdComponent, is used to reset an
// IdComponent object, which includes closing the associated HDF5
// identifier if it has no other references.
// 'Type' can be of the following classes: Attribute, DataSet, DataSpace,
// DataType, H5File, Group, and PropList.
template <class Type>
void resetIdComponent(
Type* obj ) // pointer to object to be reset
</pre>
<hr>
<pre>
Last modified: 17 December 2000
Describes HDF5 Release 1.4, February 2001
</pre>
</body>
</html>
|
