ReadHDF5VarLen.hpp

Go to the documentation of this file.

/** \file   ReadHDF5VarLen.hpp
 *  \author Jason Kraftcheck
 *  \date   2010-09-04
 */

#ifndef moab_READ_HDF5_VAR_LEN_HPP
#define moab_READ_HDF5_VAR_LEN_HPP

#include "moab/MOABConfig.h"
#ifdef MOAB_HAVE_MPI
#include "moab_mpi.h"
#endif
#include "DebugOutput.hpp"
#include "moab/Range.hpp"
#include "H5Ipublic.h"

namespace moab
{

class ReadHDF5Dataset;

/**\brief Read variable-length data from 1-D array dataset
 *
 * Utility class for reading variable-length data from an HDF5 dataset.
 * Used for reading set contents, set parents, set children,
 * polygon and polyhedron connectivity, and variable-length tag
 * data.
 *
 * This is an abstract class.  The pure virtual \c store_data method
 * must be implemented to create a concrete instance.
 */
class ReadHDF5VarLen
{
  protected:
    DebugOutput& dbgOut;

  private:
    void* const dataBuffer;
    const size_t bufferSize;

    /**\brief Test if passed file_id is value pointed to by ranged_iter,
     *        and if so, incremenet ranged_iter
     */
    static bool is_ranged( EntityHandle file_id, Range::const_iterator& ranged_iter, Range::const_iterator ranged_end );

  protected:
    /**\brief Store data list for a single entity
     *
     * The is the pure virtual method that must be provided.
     * It is responsible for storing the data read for a single
     * entity.
     *
     * This function will always be called in the order of the
     * file_ids in the range passed to the \c read method.
     *
     *\param file_id  The file ID for the entity
     *\param data     A pointer to the data for the entity
     *\param num_data Number of values for the entity
     *\param ranged   For set contents, true if in ranged format.
     */
    virtual ErrorCode store_data( EntityHandle file_id, void* data, long num_data, bool ranged ) = 0;

  public:
    /**\brief Constructor
     *\param buffer      A temporary buffer to use during read
     *\param buffer_size Size of \c buffer, in bytes.
     */
    ReadHDF5VarLen( DebugOutput& debug_output, void* buffer, size_t buffer_size )
        : dbgOut( debug_output ), dataBuffer( buffer ), bufferSize( buffer_size )
    {
    }

    virtual ~ReadHDF5VarLen() {}

    /**\brief Do actual read of data set
     *\param data_set         The data set to read.
     *\param file_ids         The file ids of the entities to read.
     *\param start_file_id    The file id corresponding to the first row of the dataset
     *\param data_type        The desired, in-memory data type for values
     *\param vals_per_ent     The number of values for each entity
     *\param ranged_file_ids  Those file ids for which the 'ranged'
     *                        argument to \c storedata should be passed
     *                        as \c true.
     */
    ErrorCode read_data( ReadHDF5Dataset& data_set,
                         const Range& offsets,
                         EntityHandle start_offset,
                         hid_t data_type,
                         const Range& file_ids,
                         const std::vector< unsigned >& vals_per_ent,
                         const Range& ranged_file_ids );

    /**\brief Read set description table or offset vector for
     *        var-len tags or old-format poly(gon|hedra) connectivity.
     *\param data_set         The data set to read.
     *\param file_ids         The file ids of the entities to read.
     *\param start_file_id    The file id corresponding to the first row of the dataset
     *\param num_columns      The number of columns of offsets in the dataset
     *\param indices          Array of length \c num_columns contaning the
     *                        indices of the columns to read.
     *\param nudge            Amount by which to offset values in
     *                        \c offset_out to avoid putting zeros in
     *                        Range.  Must be greater than 0.  Probably 1.
     *\param offsets_out      An array of length \c num_columns which will
     *                        be populated with the resulting list of offsets
     *                        into the contents list calculated from reading
     *                        the offsets from the passed data set.
     *\param counts_out       An array of length \c num_columns of std::vectors,
     *                        where each vector will be filled with one value
     *                        per file ID indicating the length of the data for
     *                        the corresponding file ID.
     *\param ranged_file_ids  If non-null, the last column of the table will
     *                        be read and tested for the ranged bit.  For
     *                        all file_ids for which the range bit is set,
     *                        the file ID will be added to this list.
     */
    /*
       ErrorCode read_offsets( ReadHDF5Dataset& data_set,
                               const Range& file_ids,
                               EntityHandle start_file_id,
                               unsigned num_columns,
                               const unsigned indices[],
                               EntityHandle nudge,
                               Range offsets_out[],
                               std::vector counts_out[],
                               Range* ranged_file_ids = 0 );
   */
    ErrorCode read_offsets( ReadHDF5Dataset& data_set,
                            const Range& file_ids,
                            EntityHandle start_file_id,
                            EntityHandle nudge,
                            Range& offsets_out,
                            std::vector< unsigned >& counts_out );

    ErrorCode read( ReadHDF5Dataset& offset_data,
                    ReadHDF5Dataset& value_data,
                    const Range& file_ids,
                    EntityHandle start_file_id,
                    hid_t data_type,
                    const Range* ranged = 0 )
    {
        ErrorCode rval;
        const EntityHandle nudge = 1;
        Range offsets;
        std::vector< unsigned > counts;
        rval = read_offsets( offset_data, file_ids, start_file_id, nudge, offsets, counts );
        if( MB_SUCCESS != rval ) return rval;
        Range empty;
        rval = read_data( value_data, offsets, nudge, data_type, file_ids, counts, ranged ? *ranged : empty );
        return rval;
    }
};

}  // namespace moab

#endif  // moab_READ_HDF5_VAR_LEN_HPP