diff options
Diffstat (limited to 'src/H5Ofphdf5.c')
| -rw-r--r-- | src/H5Ofphdf5.c | 519 |
1 files changed, 519 insertions, 0 deletions
diff --git a/src/H5Ofphdf5.c b/src/H5Ofphdf5.c new file mode 100644 index 0000000..a93611b --- /dev/null +++ b/src/H5Ofphdf5.c @@ -0,0 +1,519 @@ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * Copyright by the Board of Trustees of the University of Illinois. * + * All rights reserved. * + * * + * This file is part of HDF5. The full HDF5 copyright notice, including * + * terms governing use, modification, and redistribution, is contained in * + * the files COPYING and Copyright.html. COPYING can be found at the root * + * of the source code distribution tree; Copyright.html can be found at the * + * root level of an installed copy of the electronic HDF5 document set and * + * is linked from the top-level documents page. It can also be found at * + * http://hdf.ncsa.uiuc.edu/HDF5/doc/Copyright.html. If you do not have * + * access to either file, you may request a copy from hdfhelp@ncsa.uiuc.edu. * + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + +/* $Id$ */ + +#define H5P_PACKAGE /* prevent warning from including H5Ppkg.h */ +#define H5S_PACKAGE /* prevent warning from including H5Spkg.h */ + +#include "H5private.h" /* Generic functions */ +#include "H5Eprivate.h" /* Error handling */ +#include "H5FLprivate.h" /* Free lists */ +#include "H5MMprivate.h" /* Memory management */ +#include "H5Oprivate.h" /* Object headers */ +#include "H5Rprivate.h" +#include "H5Ppkg.h" +#include "H5Spkg.h" + +#if defined (WIN32) && !defined (__MWERKS__) +#include <sys/types.h> +#include <sys/timeb.h> +#endif + +#ifdef H5_HAVE_FPHDF5 + +#define PABLO_MASK H5O_fphdf5_mask + +/* local prototypes */ +static void *H5O_fphdf5_decode(H5F_t *f, const uint8_t *p, H5O_shared_t *sh); +static herr_t H5O_fphdf5_encode(H5F_t *f, uint8_t *p, const void *_mesg); +static size_t H5O_fphdf5_size(H5F_t *f, const void *_mesg); +static herr_t H5O_fphdf5_reset(void *_mesg); +static herr_t H5O_fphdf5_free(void *_mesg); +static herr_t H5O_fphdf5_debug(H5F_t *f, const void *_mesg, + FILE *stream, int indent, int fwidth); + +/* This message derives from H5O */ +const H5O_class_t H5O_FPHDF5[1] = {{ + H5O_FPHDF5_ID, /* message id number */ + "fphdf5", /* message name for debugging */ + sizeof(H5O_fphdf5_t), /* native message size */ + H5O_fphdf5_decode, /* decode message */ + H5O_fphdf5_encode, /* encode message */ + NULL, /* copy the native value */ + H5O_fphdf5_size, /* size of symbol table entry */ + H5O_fphdf5_reset, /* default reset method */ + H5O_fphdf5_free, /* free method */ + NULL, /* get share method */ + NULL, /* set share method */ + H5O_fphdf5_debug, /* debug the message */ +}}; + +#define H5O_FPHDF5_VERSION 1 + +/* Is the interface initialized? */ +static int interface_initialize_g = 0; + +#define INTERFACE_INIT NULL + +/* Define the free list for H5O_fphdf5_t's */ +H5FL_DEFINE_STATIC(H5O_fphdf5_t); + +/* Declare external the free list for hsize_t arrays */ +H5FL_ARR_EXTERN(hsize_t); + +/* + * Function: H5O_fphdf5_decode + * Purpose: Decode a metadata message from the SAP and return a pointer to + * a memory struct with the decoded information. + * + * This function decodes the "raw" form of a metadata message + * sent from the SAP into a struct in memory native format. The + * struct is allocated within this function using malloc() and is + * returned to the caller. + * + * H5F_t *f IN: pointer to the HDF5 file struct + * uint8 *p OUT: the raw information buffer + * H5O_shared_t *sh IN: not used; must be NULL + * + * Return: Success: Pointer to the new message in native order + * Failure: NULL + * Programmer: Bill Wendling, 20. August 2002 + * Modifications: + */ +static void * +H5O_fphdf5_decode(H5F_t *f, const uint8_t *p, H5O_shared_t UNUSED *sh) +{ + H5O_fphdf5_t *fmeta = NULL; /* New FPHDF5 metadata structure */ + void *ret_value; + unsigned int i; + + FUNC_ENTER_NOAPI(H5O_fphdf5_decode, NULL); + + /* check args */ + assert(f); + assert(p); + assert(!sh); + + /* decode */ + fmeta = H5FL_ALLOC(H5O_fphdf5_t, 1); + + /* decode the OID first */ + for (i = 0; i < sizeof(fmeta->oid); ++i) + fmeta->oid[i] = p[i]; + + /* jump past the OID part */ + p += sizeof(fmeta->oid); + + /* decode the dataspace dimensions next */ + fmeta->sdim = H5O_SDSPACE[0].decode(f, p, NULL); + + if (!fmeta->sdim) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); + + /* jump past the dataspace dimensions part */ + p += H5O_SDSPACE[0].raw_size(f, fmeta->sdim); + + /* decode the datatype next */ + fmeta->dtype = H5O_DTYPE[0].decode(f, p, NULL); + + if (!fmeta->dtype) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); + + /* jump past the datatype part */ + p += H5O_DTYPE[0].raw_size(f, fmeta->dtype); + + /* decode the modification time next */ + fmeta->mtime = H5O_DTYPE[0].decode(f, p, NULL); + + if (!fmeta->dtype) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); + + /* jump past the modification time part */ + p += H5O_MTIME[0].raw_size(f, fmeta->mtime); + + /* decode the group the modification took place in */ + fmeta->group = H5O_NAME[0].decode(f, p, NULL); + + if (!fmeta->group) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); + + /* jump past the group name part */ + p += H5O_NAME[0].raw_size(f, fmeta->group); + + /* decode the dataset the modification took place in */ + fmeta->dset = H5O_NAME[0].decode(f, p, NULL); + + if (!fmeta->dset) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); + + /* jump past the dataset name part */ + p += H5O_NAME[0].raw_size(f, fmeta->dset); + + /* decode the property list last */ + fmeta->plist = H5O_PLIST[0].decode(f, p, NULL); + + if (!fmeta->plist) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); + + /* Set return value */ + ret_value = (void *)fmeta; /*success*/ + +done: + if (!ret_value && fmeta) { + /* free up fmeta */ + if (H5O_SDSPACE[0].free) + H5O_SDSPACE[0].free(fmeta->sdim); + + if (H5O_DTYPE[0].free) + H5O_DTYPE[0].free(fmeta->dtype); + + if (H5O_MTIME[0].free) + H5O_MTIME[0].free(fmeta->mtime); + + if (H5O_PLIST[0].free) + H5O_PLIST[0].free(fmeta->plist); + + H5FL_FREE(H5O_fphdf5_t, fmeta); + } + + FUNC_LEAVE(ret_value); +} + +/* + * Function: H5O_fphdf5_encode + * Purpose: Encode a metadata message for the SAP and return a pointer to + * a memory struct with the encoded information. + * + * This function encodes the "raw" form of a metadata message + * sent from the SAP into a struct in memory native format. + * + * H5F_t *f IN: pointer to the HDF5 file struct + * uint8 *p OUT: the raw information buffer + * const void *mesg IN: pointer to the metadata to encode + * + * Return: Success: Non-negative + * Failure: Negative + * Programmer: Bill Wendling, 21. August 2002 + * Modifications: + */ +static herr_t +H5O_fphdf5_encode(H5F_t *f, uint8_t *p, const void *mesg) +{ + const H5O_fphdf5_t *fmeta = (const H5O_fphdf5_t *)mesg; + herr_t ret_value = SUCCEED; + unsigned int i; + + FUNC_ENTER_NOAPI(H5O_fphdf5_encode, FAIL); + + /* check args */ + assert(f); + assert(p); + assert(fmeta); + + /* encode the OID first */ + for (i = 0; i < sizeof(fmeta->oid); ++i) + p[i] = fmeta->oid[i]; + + /* jump past the OID part */ + p += sizeof(fmeta->oid); + + /* encode the dataspace dimensions next */ + ret_value = H5O_SDSPACE[0].encode(f, p, fmeta->sdim); + + if (ret_value < 0) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed"); + + /* jump past the dataspace dimensions part */ + p += H5O_SDSPACE[0].raw_size(f, fmeta->sdim); + + /* encode the datatype next */ + ret_value = H5O_DTYPE[0].encode(f, p, fmeta->dtype); + + if (ret_value < 0) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed"); + + /* jump past the datatype part */ + p += H5O_DTYPE[0].raw_size(f, fmeta->dtype); + + /* encode the modification time next */ + ret_value = H5O_DTYPE[0].encode(f, p, fmeta->mtime); + + if (ret_value < 0) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed"); + + /* jump past the modification time part */ + p += H5O_MTIME[0].raw_size(f, fmeta->mtime); + + /* encode the group name next */ + ret_value = H5O_NAME[0].encode(f, p, fmeta->group); + + if (ret_value < 0) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed"); + + /* jump past the group name part */ + p += H5O_NAME[0].raw_size(f, fmeta->group); + + /* encode the dataset name next */ + ret_value = H5O_NAME[0].encode(f, p, fmeta->dset); + + if (ret_value < 0) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed"); + + /* jump past the dataset name part */ + p += H5O_NAME[0].raw_size(f, fmeta->dset); + + /* decode the property list last */ + ret_value = H5O_PLIST[0].encode(f, p, fmeta->plist); + + if (ret_value < 0) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed"); + +done: + FUNC_LEAVE(ret_value); +} + +/* + * Function: H5O_fphdf5_copy + * Purpose: Copies a metadata object from MESG to DEST allocating DEST if + * necessary. + * + * const void *mesg IN: pointer to the metadata to copy + * const void *dest OUT: pointer to the destination metadata struct + * + * Return: Success: Pointer to DEST + * Failure: NULL + * Programmer: Bill Wendling, 21. August 2002 + * Modifications: + */ +static void * +H5O_fphdf5_copy(const void *mesg, void *dest) +{ + const H5O_fphdf5_t *src = (const H5O_fphdf5_t *)mesg; + H5O_fphdf5_t *dst = (H5O_fphdf5_t *)dest; + void *ret_value; + unsigned int i; + + FUNC_ENTER_NOAPI(H5O_fphdf5_copy, NULL); + + /* check args */ + assert(src); + + if (!dst && NULL == (dst = H5FL_ALLOC(H5O_fphdf5_t, 0))) + HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed"); + + /* copy the individual metadata*/ + for (i = 0; i < sizeof(src->oid); ++i) + dst->oid[i] = src->oid[i]; + + H5O_SDSPACE[0].copy(src->sdim, dst->sdim); + H5O_DTYPE[0].copy(src->dtype, dst->dtype); + H5O_MTIME[0].copy(src->mtime, dst->mtime); + H5O_NAME[0].copy(src->group, dst->group); + H5O_NAME[0].copy(src->dset, dst->dset); + + if (H5O_PLIST[0].copy) + H5O_PLIST[0].copy(src->plist, dst->plist); + + /* Set return value */ + ret_value = dst; + +done: + FUNC_LEAVE(ret_value); +} + +/* + * Function: H5O_fphdf5_size + * Purpose: Return the raw message size in bytes. + * + * This function returns the size of hte raw simple + * dimensionality, datatype, and object path message on succes. + * (Not counting the message type or size fields, only the data + * portion of the message). It doesn't take into account + * alignment. + * + * H5F_t *f IN: pointer to the HDF5 file struct + * const void *mesg IN: pointer to the metadata structure + * + * Return: Success: Size of message + * Failure: 0 + * Programmer: Bill Wendling, 21. August 2002 + * Modifications: + */ +static size_t +H5O_fphdf5_size(H5F_t *f, const void *mesg) +{ + const H5O_fphdf5_t *fmeta = (const H5O_fphdf5_t *)mesg; + size_t ret_value; + + FUNC_ENTER_NOAPI(H5O_fphdf5_size, 0); + + /* add in the metadata sizes */ + ret_value = sizeof(fmeta->oid); + ret_value += H5O_SDSPACE[0].raw_size(f, fmeta->sdim); + ret_value += H5O_DTYPE[0].raw_size(f, fmeta->dtype); + ret_value += H5O_MTIME[0].raw_size(f, fmeta->mtime); + ret_value += H5O_NAME[0].raw_size(f, fmeta->group); + ret_value += H5O_NAME[0].raw_size(f, fmeta->dset); + ret_value += H5O_PLIST[0].raw_size(f, fmeta->plist); + +done: + FUNC_LEAVE(ret_value); +} + +/* + * Function: H5O_fphdf5_reset + * Purpose: Frees the inside of a metadata message and resets it to some + * initial value. + * + * const void *mesg IN: pointer to the metadata to reset + * + * Return: Success: Non-negative + * Failure: Negative + * Programmer: Bill Wendling, 21. August 2002 + * Modifications: + */ +static herr_t +H5O_fphdf5_reset(void *mesg) +{ + H5O_fphdf5_t *fmeta = (H5O_fphdf5_t *)mesg; + herr_t ret_value = SUCCEED; + unsigned int i; + + FUNC_ENTER_NOAPI(H5O_fphdf5_reset, FAIL); + + /* reset the metadata */ + for (i = 0; i < sizeof(fmeta->oid); ++i) + fmeta->oid[i] = '\0'; + + if (H5O_SDSPACE[0].reset) + ret_value = H5O_SDSPACE[0].reset(fmeta->sdim); + + if (H5O_DTYPE[0].reset) + ret_value = H5O_DTYPE[0].reset(fmeta->dtype); + + if (H5O_MTIME[0].reset) + ret_value = H5O_MTIME[0].reset(fmeta->mtime); + + if (H5O_NAME[0].reset) + ret_value = H5O_NAME[0].reset(fmeta->group); + + if (H5O_NAME[0].reset) + ret_value = H5O_NAME[0].reset(fmeta->dset); + + if (H5O_PLIST[0].reset) + ret_value = H5O_PLIST[0].reset(fmeta->plist); + +done: + FUNC_LEAVE(ret_value); +} + +/* + * Function: H5O_fphdf5_free + * Purpose: Free's the message + * + * const void *mesg IN: pointer to the metadata to free + * + * Return: Success: Non-negative + * Failure: Negative + * Programmer: Bill Wendling, 21. August 2002 + * Modifications: + */ +static herr_t +H5O_fphdf5_free(void *mesg) +{ + H5O_fphdf5_t *fmeta = (H5O_fphdf5_t *)mesg; + herr_t ret_value = SUCCEED; + + FUNC_ENTER_NOAPI(H5O_fphdf5_free, FAIL); + assert(fmeta); + + /* reset the metadata */ + if (H5O_SDSPACE[0].free) + ret_value = H5O_SDSPACE[0].free(fmeta->sdim); + + if (H5O_DTYPE[0].free) + ret_value = H5O_DTYPE[0].free(fmeta->dtype); + + if (H5O_MTIME[0].free) + ret_value = H5O_MTIME[0].free(fmeta->mtime); + + if (H5O_NAME[0].free) + ret_value = H5O_NAME[0].free(fmeta->group); + + if (H5O_NAME[0].free) + ret_value = H5O_NAME[0].free(fmeta->dset); + + if (H5O_PLIST[0].free) + ret_value = H5O_PLIST[0].free(fmeta->plist); + + H5FL_FREE(H5O_fphdf5_t, fmeta); + +done: + FUNC_LEAVE(ret_value); +} + +/* + * Function: H5O_fphdf5_debug + * Purpose: Prints debugging information for the metadata message. + * + * H5F_t *f IN: pointer to the HDF5 file struct + * const void *mesg IN: Pointer to the source metadata struct + * FILE *stream IN: Pointer to the stream for output data + * int indent IN: Amount to indent information by + * int fwidth IN: Field width (?) + * + * Return: Success: Non-negative + * Failure: Negative + * Programmer: Bill Wendling, 22. August 2002 + * Modifications: + */ +static herr_t +H5O_fphdf5_debug(H5F_t UNUSED *f, const void *mesg, + FILE * stream, int indent, int fwidth) +{ + const H5O_fphdf5_t *fmeta = (const H5O_fphdf5_t *) mesg; + herr_t ret_value = SUCCEED; + unsigned int i; + + FUNC_ENTER_NOAPI(H5O_fphdf5_debug, FAIL); + + /* check args */ + assert(f); + assert(fmeta); + assert(stream); + assert(indent >= 0); + assert(fwidth >= 0); + + HDfprintf(stream, "%*s%-*s\n", indent, "", fwidth, "Metadata:"); + HDfprintf(stream, "%*sOID: 0x", indent + 1, ""); + + for (i = 0; i < sizeof(fmeta->oid); ++i) + HDfprintf(stream, "%02x", fmeta->oid[i]); + + HDfprintf(stream, "\n"); + ret_value = H5O_SDSPACE[0].debug(f, fmeta->sdim, stream, indent + 1, fwidth); + ret_value = H5O_DTYPE[0].debug(f, fmeta->dtype, stream, indent + 1, fwidth); + ret_value = H5O_MTIME[0].debug(f, fmeta->mtime, stream, indent + 1, fwidth); + ret_value = H5O_NAME[0].debug(f, fmeta->group, stream, indent + 1, fwidth); + ret_value = H5O_NAME[0].debug(f, fmeta->dset, stream, indent + 1, fwidth); + ret_value = H5O_PLIST[0].debug(f, fmeta->plist, stream, indent + 1, fwidth); + + HDfprintf(stream, "}\n"); + +done: + FUNC_LEAVE(ret_value); +} + +#endif /* H5_HAVE_FPHDF5 */ |