 |
Mesh Oriented datABase
(version 5.5.1)
An array-based unstructured mesh library
|
|
Mesh Oriented datABase
(version 5.5.1)
An array-based unstructured mesh library
|
1 /**
2 * MOAB, a Mesh-Oriented datABase, is a software component for creating,
3 * storing and accessing finite element mesh data.
4 *
5 * Copyright 2004 Sandia Corporation. Under the terms of Contract
6 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
7 * retains certain rights in this software.
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 */
15
16 #include <H5Tpublic.h>
17 #include <H5Dpublic.h>
18 #include <H5Gpublic.h>
19 #include <H5Spublic.h>
20 #include <H5Ppublic.h>
21 #include "mhdf.h"
22 #include "util.h"
23 #include "file-handle.h"
24 #include "status.h"
25 #include "names-and-paths.h"
26
27 int mhdf_haveSets( mhdf_FileHandle file, int* have_data, int* have_child, int* have_parent, mhdf_Status* status )
28 {
29 FileHandle* file_ptr = (FileHandle*)file;
30 hid_t root_id, set_id;
31 int result;
32 API_BEGIN;
33
34 if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
35
36 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
37 root_id = H5Gopen2( file_ptr->hdf_handle, ROOT_GROUP, H5P_DEFAULT );
38 #else
39 root_id = H5Gopen( file_ptr->hdf_handle, ROOT_GROUP );
40 #endif
41 if( root_id < 0 )
42 {
43 mhdf_setFail( status, "H5Gopen( \"%s\" ) failed.", ROOT_GROUP );
44 return -1;
45 }
46
47 result = mhdf_is_in_group( root_id, SET_GROUP_NAME, status );
48 if( result < 1 )
49 {
50 H5Gclose( root_id );
51 return result;
52 }
53
54 #if defined( H5Gopen_vers ) && H5Gopen_vers > 1
55 set_id = H5Gopen2( root_id, SET_GROUP_NAME, H5P_DEFAULT );
56 #else
57 set_id = H5Gopen( root_id, SET_GROUP_NAME );
58 #endif
59 H5Gclose( root_id );
60 if( set_id < 0 )
61 {
62 mhdf_setFail( status, "H5Gopen( \"%s\" ) failed.", SET_GROUP );
63 return -1;
64 }
65
66 result = mhdf_is_in_group( set_id, SET_META_NAME, status );
67 if( result < 0 )
68 {
69 H5Gclose( set_id );
70 return result;
71 }
72
73 if( have_data )
74 {
75 *have_data = mhdf_is_in_group( set_id, SET_DATA_NAME, status );
76 if( *have_data < 0 )
77 {
78 H5Gclose( set_id );
79 return *have_data;
80 }
81 }
82
83 if( have_child )
84 {
85 *have_child = mhdf_is_in_group( set_id, SET_CHILD_NAME, status );
86 if( *have_child < 0 )
87 {
88 H5Gclose( set_id );
89 return *have_child;
90 }
91 }
92
93 if( have_parent )
94 {
95 *have_parent = mhdf_is_in_group( set_id, SET_PARENT_NAME, status );
96 if( *have_parent < 0 )
97 {
98 H5Gclose( set_id );
99 return *have_parent;
100 }
101 }
102
103 mhdf_setOkay( status );
104 H5Gclose( set_id );
105 API_END;
106 return result;
107 }
108
109 hid_t mhdf_createSetMeta( mhdf_FileHandle file, long num_sets, long* first_id_out, mhdf_Status* status )
110 {
111 FileHandle* file_ptr = (FileHandle*)file;
112 hid_t table_id;
113 hsize_t dims[2];
114 long first_id;
115 API_BEGIN;
116
117 if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
118
119 dims[0] = (hsize_t)num_sets;
120 dims[1] = (hsize_t)4;
121 table_id = mhdf_create_table( file_ptr->hdf_handle, SET_META_PATH, MHDF_INDEX_TYPE, 2, dims, status );
122 if( table_id < 0 ) return -1;
123
124 first_id = file_ptr->max_id + 1;
125 if( !mhdf_create_scalar_attrib( table_id, START_ID_ATTRIB, H5T_NATIVE_LONG, &first_id, status ) )
126 {
127 H5Dclose( table_id );
128 return -1;
129 }
130
131 *first_id_out = first_id;
132 file_ptr->max_id += num_sets;
133 if( !mhdf_write_max_id( file_ptr, status ) )
134 {
135 H5Dclose( table_id );
136 return -1;
137 }
138 file_ptr->open_handle_count++;
139 mhdf_setOkay( status );
140
141 API_END_H( 1 );
142 return table_id;
143 }
144
145 hid_t mhdf_openSetMeta( mhdf_FileHandle file, long* num_sets, long* first_id_out, mhdf_Status* status )
146 {
147 FileHandle* file_ptr = (FileHandle*)file;
148 hid_t table_id;
149 hsize_t dims[2];
150 API_BEGIN;
151
152 if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
153
154 table_id = mhdf_open_table2( file_ptr->hdf_handle, SET_META_PATH, 2, dims, first_id_out, status );
155 if( table_id < 0 ) return -1;
156
157 /* If dims[1] == 3, then old format of table.
158 * Deal with it in mhdf_readSetMeta and mhdf_writeSetMeta
159 */
160 if( dims[1] != 4 && dims[1] != 3 )
161 {
162 mhdf_setFail( status, "Invalid format for meshset table.\n" );
163 H5Dclose( table_id );
164 return -1;
165 }
166
167 *num_sets = dims[0];
168 file_ptr->open_handle_count++;
169 mhdf_setOkay( status );
170 API_END_H( 1 );
171 return table_id;
172 }
173
174 hid_t mhdf_openSetMetaSimple( mhdf_FileHandle file, mhdf_Status* status )
175 {
176 FileHandle* file_ptr = (FileHandle*)file;
177 hid_t table_id;
178 API_BEGIN;
179
180 if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
181
182 table_id = mhdf_open_table_simple( file_ptr->hdf_handle, SET_META_PATH, status );
183 if( table_id < 0 ) return -1;
184
185 file_ptr->open_handle_count++;
186 mhdf_setOkay( status );
187 API_END_H( 1 );
188 return table_id;
189 }
190
191 static int mhdf_readwriteSetMeta( hid_t table_id,
192 int read,
193 long offset,
194 long count,
195 hid_t type,
196 void* data,
197 hid_t prop,
198 mhdf_Status* status )
199 {
200 hid_t slab_id, sslab_id, smem_id, mem_id;
201 hsize_t offsets[2], counts[2], mcounts[2], moffsets[2] = { 0, 0 };
202 herr_t rval = 0;
203 int dims, i;
204 const int fill_val = -1;
205 const hsize_t one = 1;
206
207 mcounts[0] = count;
208 mcounts[1] = 4;
209 if( offset < 0 || count < 0 )
210 {
211 mhdf_setFail( status,
212 "Invalid input for %s: "
213 "offset = %ld, count = %ld\n",
214 read ? "read" : "write", offset, count );
215 return 0;
216 }
217
218 slab_id = H5Dget_space( table_id );
219 if( slab_id < 0 )
220 {
221 mhdf_setFail( status, "Internal error calling H5Dget_space." );
222 return 0;
223 }
224
225 dims = H5Sget_simple_extent_ndims( slab_id );
226 if( dims != 2 )
227 {
228 H5Sclose( slab_id );
229 mhdf_setFail( status, "Internal error: unexpected dataset rank: %d.", dims );
230 return 0;
231 }
232
233 dims = H5Sget_simple_extent_dims( slab_id, counts, NULL );
234 if( dims < 0 )
235 {
236 H5Sclose( slab_id );
237 mhdf_setFail( status, "Internal error calling H5Sget_simple_extend_dims." );
238 return 0;
239 }
240
241 if( (unsigned long)( offset + count ) > counts[0] )
242 {
243 H5Sclose( slab_id );
244 mhdf_setFail( status, "Requested %s of rows %ld to %ld of a %ld row table.\n", read ? "read" : "write", offset,
245 offset + count - 1, (long)counts[dims - 1] );
246 return 0;
247 }
248 counts[0] = (hsize_t)count;
249 offsets[0] = (hsize_t)offset;
250
251 if( count )
252 mem_id = H5Screate_simple( dims, mcounts, NULL );
253 else
254 { /* special case for 'NULL' read during collective parallel IO */
255 mem_id = H5Screate_simple( 1, &one, NULL );
256 if( mem_id && 0 > H5Sselect_none( mem_id ) )
257 {
258 H5Sclose( mem_id );
259 mem_id = -1;
260 }
261 }
262 if( mem_id < 0 )
263 {
264 mhdf_setFail( status, "Internal error calling H5Screate_simple." );
265 return 0;
266 }
267
268 /* Normal table: 4 columns */
269 if( counts[1] == 4 )
270 {
271 offsets[1] = 0;
272 if( count )
273 rval = H5Sselect_hyperslab( slab_id, H5S_SELECT_SET, offsets, NULL, counts, NULL );
274 else /* special case for 'NULL' read during collective parallel IO */
275 rval = H5Sselect_none( slab_id );
276 if( rval < 0 )
277 {
278 H5Sclose( mem_id );
279 H5Sclose( slab_id );
280 mhdf_setFail( status, "Internal error calling H5Sselect_hyperslab." );
281 return 0;
282 }
283
284 if( read )
285 rval = H5Dread( table_id, type, mem_id, slab_id, prop, data );
286 else
287 rval = H5Dwrite( table_id, type, mem_id, slab_id, prop, data );
288 }
289 /* Old table: 3 columns, no parent link counts */
290 else if( counts[1] == 3 )
291 {
292 rval = 0;
293 for( i = 0; i < 3 && rval >= 0; ++i )
294 {
295 smem_id = H5Scopy( mem_id );
296 sslab_id = H5Scopy( slab_id );
297 if( smem_id < 0 || sslab_id < 0 )
298 {
299 if( smem_id >= 0 ) H5Sclose( smem_id );
300 mhdf_setFail( status, "Internal error calling H5Scopy." );
301 return 0;
302 }
303
304 counts[1] = 1;
305 offsets[1] = i;
306 if( count )
307 rval = H5Sselect_hyperslab( sslab_id, H5S_SELECT_SET, offsets, NULL, counts, NULL );
308 else
309 rval = H5Sselect_none( sslab_id );
310 if( rval < 0 )
311 {
312 H5Sclose( slab_id );
313 H5Sclose( mem_id );
314 mhdf_setFail( status, "Internal error calling H5Sselect_hyperslab." );
315 return 0;
316 }
317
318 mcounts[1] = 1;
319 moffsets[1] = ( i == 2 ) ? 3 : i;
320 rval = H5Sselect_hyperslab( smem_id, H5S_SELECT_SET, moffsets, NULL, mcounts, NULL );
321 if( rval < 0 )
322 {
323 H5Sclose( sslab_id );
324 H5Sclose( slab_id );
325 H5Sclose( mem_id );
326 mhdf_setFail( status, "Internal error calling H5Sselect_hyperslab." );
327 return 0;
328 }
329
330 if( read )
331 rval = H5Dread( table_id, type, smem_id, sslab_id, prop, data );
332 else
333 rval = H5Dwrite( table_id, type, smem_id, sslab_id, prop, data );
334
335 H5Sclose( sslab_id );
336 H5Sclose( smem_id );
337 }
338
339 if( read && rval >= 0 )
340 {
341 mcounts[1] = 1;
342 moffsets[1] = 2;
343 H5Sselect_hyperslab( mem_id, H5S_SELECT_SET, moffsets, NULL, mcounts, NULL );
344 rval = H5Dfill( &fill_val, H5T_NATIVE_INT, data, type, mem_id );
345 }
346 }
347 else
348 {
349 H5Sclose( mem_id );
350 H5Sclose( slab_id );
351 mhdf_setFail( status, "Invalid dimension for meshset metadata table." );
352 return 0;
353 }
354
355 H5Sclose( slab_id );
356 H5Sclose( mem_id );
357 if( rval < 0 )
358 {
359 mhdf_setFail( status, "Internal error calling H5D%s.", read ? "read" : "write" );
360 return 0;
361 }
362
363 mhdf_setOkay( status );
364 return 1;
365 }
366
367 void mhdf_readSetMeta( hid_t table_id, long offset, long count, hid_t type, void* data, mhdf_Status* status )
368 {
369 API_BEGIN;
370 mhdf_readwriteSetMeta( table_id, 1, offset, count, type, data, H5P_DEFAULT, status );
371 API_END;
372 }
373 void mhdf_readSetMetaWithOpt( hid_t table_id,
374 long offset,
375 long count,
376 hid_t type,
377 void* data,
378 hid_t prop,
379 mhdf_Status* status )
380 {
381 API_BEGIN;
382 mhdf_readwriteSetMeta( table_id, 1, offset, count, type, data, prop, status );
383 API_END;
384 }
385
386 void mhdf_writeSetMeta( hid_t table_id, long offset, long count, hid_t type, const void* data, mhdf_Status* status )
387 {
388 API_BEGIN;
389 mhdf_readwriteSetMeta( table_id, 0, offset, count, type, (void*)data, H5P_DEFAULT, status );
390 API_END;
391 }
392 void mhdf_writeSetMetaWithOpt( hid_t table_id,
393 long offset,
394 long count,
395 hid_t type,
396 const void* data,
397 hid_t prop,
398 mhdf_Status* status )
399 {
400 API_BEGIN;
401 mhdf_readwriteSetMeta( table_id, 0, offset, count, type, (void*)data, prop, status );
402 API_END;
403 }
404
405 enum SetMetaCol
406 {
407 CONTENT = 0,
408 CHILDREN = 1,
409 PARENTS = 2,
410 FLAGS = 3
411 };
412
413 static int mhdf_readSetMetaColumn( hid_t table_id,
414 enum SetMetaCol column,
415 long offset,
416 long count,
417 hid_t type,
418 void* data,
419 hid_t prop,
420 mhdf_Status* status )
421 {
422 hid_t slab_id, mem_id;
423 hsize_t offsets[2], counts[2], mcount = count;
424 herr_t rval = 0;
425 int dims;
426 const int fill_val = -1;
427
428 if( offset < 0 || count < 0 )
429 {
430 mhdf_setFail( status,
431 "Invalid input for reading set description column: "
432 "offset = %ld, count = %ld\n",
433 offset, count );
434 return 0;
435 }
436
437 /* Get dimensions of table, and check against requested count and offset */
438
439 slab_id = H5Dget_space( table_id );
440 if( slab_id < 0 )
441 {
442 mhdf_setFail( status, "Internal error calling H5Dget_space." );
443 return 0;
444 }
445
446 dims = H5Sget_simple_extent_ndims( slab_id );
447 if( dims != 2 )
448 {
449 H5Sclose( slab_id );
450 mhdf_setFail( status, "Internal error: unexpected dataset rank: %d.", dims );
451 return 0;
452 }
453
454 dims = H5Sget_simple_extent_dims( slab_id, counts, NULL );
455 if( dims < 0 )
456 {
457 H5Sclose( slab_id );
458 mhdf_setFail( status, "Internal error calling H5Sget_simple_extend_dims." );
459 return 0;
460 }
461
462 if( (unsigned long)( offset + count ) > counts[0] )
463 {
464 H5Sclose( slab_id );
465 mhdf_setFail( status, "Requested read of rows %ld to %ld of a %ld row table.\n", offset, offset + count - 1,
466 (long)counts[0] );
467 return 0;
468 }
469
470 /* Create a slab definition for the block of memory we're reading into */
471
472 mem_id = H5Screate_simple( 1, &mcount, NULL );
473 if( mem_id < 0 )
474 {
475 H5Sclose( slab_id );
476 mhdf_setFail( status, "Internal error calling H5Screate_simple." );
477 return 0;
478 }
479
480 /* Old, 3-column table.
481 * New table is {contents, children, parents, flags}
482 * Old table is {contents, children, flags}
483 * If asking for parents, just return zeros.
484 * If asking for flags, fix column value.
485 */
486 offsets[1] = column;
487 if( counts[1] == 3 )
488 {
489 if( column == PARENTS )
490 {
491 rval = H5Dfill( &fill_val, H5T_NATIVE_INT, data, type, mem_id );
492 H5Sclose( mem_id );
493 H5Sclose( slab_id );
494 if( rval < 0 )
495 {
496 mhdf_setFail( status, "Internal error calling H5Dfill" );
497 return 0;
498 }
499 else
500 {
501 mhdf_setOkay( status );
502 return 1;
503 }
504 }
505 else if( column == FLAGS )
506 --offsets[1];
507 }
508 else if( counts[1] != 4 )
509 {
510 H5Sclose( mem_id );
511 H5Sclose( slab_id );
512 mhdf_setFail( status, "Invalid dimension for meshset metadata table." );
513 return 0;
514 }
515
516 /* Create a slab defintion for the portion of the table we want to read. */
517
518 /* offsets[1] was initialized in the above block of code. */
519 offsets[0] = (hsize_t)offset;
520 counts[0] = (hsize_t)count;
521 counts[1] = 1; /* one column */
522 if( count )
523 rval = H5Sselect_hyperslab( slab_id, H5S_SELECT_SET, offsets, NULL, counts, NULL );
524 else
525 rval = H5Sselect_none( slab_id );
526 if( rval < 0 )
527 {
528 H5Sclose( mem_id );
529 H5Sclose( slab_id );
530 mhdf_setFail( status, "Internal error calling H5Sselect_hyperslab." );
531 return 0;
532 }
533
534 /* Read the data */
535
536 rval = H5Dread( table_id, type, mem_id, slab_id, prop, data );
537 H5Sclose( mem_id );
538 H5Sclose( slab_id );
539 if( rval < 0 )
540 {
541 mhdf_setFail( status, "Internal error calling H5Dread." );
542 return 0;
543 }
544
545 mhdf_setOkay( status );
546 return 1;
547 }
548
549 void mhdf_readSetFlags( hid_t table_id, long offset, long count, hid_t type, void* data, mhdf_Status* status )
550 {
551 API_BEGIN;
552 mhdf_readSetMetaColumn( table_id, FLAGS, offset, count, type, data, H5P_DEFAULT, status );
553 API_END;
554 }
555 void mhdf_readSetFlagsWithOpt( hid_t table_id,
556 long offset,
557 long count,
558 hid_t type,
559 void* data,
560 hid_t prop,
561 mhdf_Status* status )
562 {
563 API_BEGIN;
564 mhdf_readSetMetaColumn( table_id, FLAGS, offset, count, type, data, prop, status );
565 API_END;
566 }
567
568 void mhdf_readSetContentEndIndices( hid_t table_id,
569 long offset,
570 long count,
571 hid_t type,
572 void* data,
573 mhdf_Status* status )
574 {
575 API_BEGIN;
576 mhdf_readSetMetaColumn( table_id, CONTENT, offset, count, type, data, H5P_DEFAULT, status );
577 API_END;
578 }
579 void mhdf_readSetContentEndIndicesWithOpt( hid_t table_id,
580 long offset,
581 long count,
582 hid_t type,
583 void* data,
584 hid_t prop,
585 mhdf_Status* status )
586 {
587 API_BEGIN;
588 mhdf_readSetMetaColumn( table_id, CONTENT, offset, count, type, data, prop, status );
589 API_END;
590 }
591
592 void mhdf_readSetChildEndIndices( hid_t table_id, long offset, long count, hid_t type, void* data, mhdf_Status* status )
593 {
594 API_BEGIN;
595 mhdf_readSetMetaColumn( table_id, CHILDREN, offset, count, type, data, H5P_DEFAULT, status );
596 API_END;
597 }
598 void mhdf_readSetChildEndIndicesWithOpt( hid_t table_id,
599 long offset,
600 long count,
601 hid_t type,
602 void* data,
603 hid_t prop,
604 mhdf_Status* status )
605 {
606 API_BEGIN;
607 mhdf_readSetMetaColumn( table_id, CHILDREN, offset, count, type, data, prop, status );
608 API_END;
609 }
610
611 void mhdf_readSetParentEndIndices( hid_t table_id,
612 long offset,
613 long count,
614 hid_t type,
615 void* data,
616 mhdf_Status* status )
617 {
618 API_BEGIN;
619 mhdf_readSetMetaColumn( table_id, PARENTS, offset, count, type, data, H5P_DEFAULT, status );
620 API_END;
621 }
622 void mhdf_readSetParentEndIndicesWithOpt( hid_t table_id,
623 long offset,
624 long count,
625 hid_t type,
626 void* data,
627 hid_t prop,
628 mhdf_Status* status )
629 {
630 API_BEGIN;
631 mhdf_readSetMetaColumn( table_id, PARENTS, offset, count, type, data, prop, status );
632 API_END;
633 }
634
635 hid_t mhdf_createSetData( mhdf_FileHandle file_handle, long data_list_size, mhdf_Status* status )
636 {
637 FileHandle* file_ptr;
638 hid_t table_id;
639 hsize_t dim = (hsize_t)data_list_size;
640 API_BEGIN;
641
642 file_ptr = (FileHandle*)( file_handle );
643 if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
644
645 if( data_list_size < 1 )
646 {
647 mhdf_setFail( status, "Invalid argument.\n" );
648 return -1;
649 }
650
651 table_id = mhdf_create_table( file_ptr->hdf_handle, SET_DATA_PATH, file_ptr->id_type, 1, &dim, status );
652
653 API_END_H( 1 );
654 return table_id;
655 }
656
657 hid_t mhdf_openSetData( mhdf_FileHandle file_handle, long* data_list_size_out, mhdf_Status* status )
658 {
659 FileHandle* file_ptr;
660 hid_t table_id;
661 hsize_t dim;
662 API_BEGIN;
663
664 file_ptr = (FileHandle*)( file_handle );
665 if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
666
667 if( !data_list_size_out )
668 {
669 mhdf_setFail( status, "Invalid argument.\n" );
670 return -1;
671 }
672
673 table_id = mhdf_open_table( file_ptr->hdf_handle, SET_DATA_PATH, 1, &dim, status );
674
675 *data_list_size_out = (long)dim;
676 API_END_H( 1 );
677 return table_id;
678 }
679
680 void mhdf_writeSetData( hid_t table_id, long offset, long count, hid_t type, const void* data, mhdf_Status* status )
681 {
682 API_BEGIN;
683 mhdf_write_data( table_id, offset, count, type, data, H5P_DEFAULT, status );
684 API_END;
685 }
686 void mhdf_writeSetDataWithOpt( hid_t table_id,
687 long offset,
688 long count,
689 hid_t type,
690 const void* data,
691 hid_t prop,
692 mhdf_Status* status )
693 {
694 API_BEGIN;
695 mhdf_write_data( table_id, offset, count, type, data, prop, status );
696 API_END;
697 }
698
699 void mhdf_readSetData( hid_t table_id, long offset, long count, hid_t type, void* data, mhdf_Status* status )
700 {
701 API_BEGIN;
702 mhdf_read_data( table_id, offset, count, type, data, H5P_DEFAULT, status );
703 API_END;
704 }
705 void mhdf_readSetDataWithOpt( hid_t table_id,
706 long offset,
707 long count,
708 hid_t type,
709 void* data,
710 hid_t prop,
711 mhdf_Status* status )
712 {
713 API_BEGIN;
714 mhdf_read_data( table_id, offset, count, type, data, prop, status );
715 API_END;
716 }
717
718 hid_t mhdf_createSetChildren( mhdf_FileHandle file_handle, long child_list_size, mhdf_Status* status )
719 {
720 FileHandle* file_ptr;
721 hid_t table_id;
722 hsize_t dim = (hsize_t)child_list_size;
723 API_BEGIN;
724
725 file_ptr = (FileHandle*)( file_handle );
726 if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
727
728 if( child_list_size < 1 )
729 {
730 mhdf_setFail( status, "Invalid argument.\n" );
731 return -1;
732 }
733
734 table_id = mhdf_create_table( file_ptr->hdf_handle, SET_CHILD_PATH, file_ptr->id_type, 1, &dim, status );
735
736 API_END_H( 1 );
737 return table_id;
738 }
739
740 hid_t mhdf_openSetChildren( mhdf_FileHandle file_handle, long* child_list_size, mhdf_Status* status )
741 {
742 FileHandle* file_ptr;
743 hid_t table_id;
744 hsize_t dim;
745 API_BEGIN;
746
747 file_ptr = (FileHandle*)( file_handle );
748 if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
749
750 if( !child_list_size )
751 {
752 mhdf_setFail( status, "Invalid argument.\n" );
753 return -1;
754 }
755
756 table_id = mhdf_open_table( file_ptr->hdf_handle, SET_CHILD_PATH, 1, &dim, status );
757
758 *child_list_size = (long)dim;
759 API_END_H( 1 );
760 return table_id;
761 }
762
763 hid_t mhdf_createSetParents( mhdf_FileHandle file_handle, long parent_list_size, mhdf_Status* status )
764 {
765 FileHandle* file_ptr;
766 hid_t table_id;
767 hsize_t dim = (hsize_t)parent_list_size;
768 API_BEGIN;
769
770 file_ptr = (FileHandle*)( file_handle );
771 if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
772
773 if( parent_list_size < 1 )
774 {
775 mhdf_setFail( status, "Invalid argument.\n" );
776 return -1;
777 }
778
779 table_id = mhdf_create_table( file_ptr->hdf_handle, SET_PARENT_PATH, file_ptr->id_type, 1, &dim, status );
780
781 API_END_H( 1 );
782 return table_id;
783 }
784
785 hid_t mhdf_openSetParents( mhdf_FileHandle file_handle, long* parent_list_size, mhdf_Status* status )
786 {
787 FileHandle* file_ptr;
788 hid_t table_id;
789 hsize_t dim;
790 API_BEGIN;
791
792 file_ptr = (FileHandle*)( file_handle );
793 if( !mhdf_check_valid_file( file_ptr, status ) ) return -1;
794
795 if( !parent_list_size )
796 {
797 mhdf_setFail( status, "Invalid argument.\n" );
798 return -1;
799 }
800
801 table_id = mhdf_open_table( file_ptr->hdf_handle, SET_PARENT_PATH, 1, &dim, status );
802
803 *parent_list_size = (long)dim;
804 API_END_H( 1 );
805 return table_id;
806 }
807
808 void mhdf_writeSetParentsChildren( hid_t table_id,
809 long offset,
810 long count,
811 hid_t type,
812 const void* data,
813 mhdf_Status* status )
814 {
815 API_BEGIN;
816 mhdf_write_data( table_id, offset, count, type, data, H5P_DEFAULT, status );
817 API_END;
818 }
819 void mhdf_writeSetParentsChildrenWithOpt( hid_t table_id,
820 long offset,
821 long count,
822 hid_t type,
823 const void* data,
824 hid_t prop,
825 mhdf_Status* status )
826 {
827 API_BEGIN;
828 mhdf_write_data( table_id, offset, count, type, data, prop, status );
829 API_END;
830 }
831
832 void mhdf_readSetParentsChildren( hid_t table_id, long offset, long count, hid_t type, void* data, mhdf_Status* status )
833 {
834 API_BEGIN;
835 mhdf_read_data( table_id, offset, count, type, data, H5P_DEFAULT, status );
836 API_END;
837 }
838 void mhdf_readSetParentsChildrenWithOpt( hid_t table_id,
839 long offset,
840 long count,
841 hid_t type,
842 void* data,
843 hid_t prop,
844 mhdf_Status* status )
845 {
846 API_BEGIN;
847 mhdf_read_data( table_id, offset, count, type, data, prop, status );
848 API_END;
849 }
1.9.1.