Cppcheck report - MOAB: src/io/ReadHDF5.hpp

/**
 * MOAB, a Mesh-Oriented datABase, is a software component for creating,
 * storing and accessing finite element mesh data.
 *
 * Copyright 2004 Sandia Corporation.  Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
 * retains certain rights in this software.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 */

#ifndef READ_HDF5_HPP
#define READ_HDF5_HPP

#include <cstdlib>
#include <list>
#include "mhdf.h"
#include "moab/Forward.hpp"
#include "moab/ReadUtilIface.hpp"
#include "moab/Range.hpp"
#include "moab/ReaderIface.hpp"
#include "moab/RangeMap.hpp"
#include "DebugOutput.hpp"
#include "HDF5Common.hpp"

#ifdef MOAB_HAVE_MPI
#include <moab_mpi.h>
#endif

namespace moab
{

class ParallelComm;
class ReadHDF5Dataset;
class CpuTimer;

/**
 * \brief  Read mesh from MOAB HDF5 (.h5m) file.
 * \author Jason Kraftcheck
 * \date   18 April 2004
 */
class ReadHDF5 : public ReaderIface
{
  public:
#ifdef MOAB_HAVE_MPI
    typedef MPI_Comm Comm;
#else
    typedef int Comm;
#endif

    static ReaderIface* factory( Interface* );

    ReadHDF5( Interface* iface );
<--- Class 'ReadHDF5' has a constructor with 1 argument that is not explicit. [+]
Class 'ReadHDF5' has a constructor with 1 argument that is not explicit. Such constructors should in general be explicit for type safety reasons. Using the explicit keyword in the constructor means some mistakes when using the class can be avoided.

    virtual ~ReadHDF5();

    /** Export specified meshsets to file
     * \param filename     The filename to export. Must end in <em>.mhdf</em>
     * \param export_sets  Array of handles to sets to export, or NULL to export all.
     * \param export_set_count Length of <code>export_sets</code> array.
     */
    ErrorCode load_file( const char* file_name,
                         const EntityHandle* file_set,
                         const FileOptions& opts,
                         const SubsetList* subset_list = 0,
                         const Tag* file_id_tag        = 0 );

    ErrorCode read_tag_values( const char* file_name,
                               const char* tag_name,
                               const FileOptions& opts,
                               std::vector< int >& tag_values_out,
                               const SubsetList* subset_list = 0 );
    Interface* moab() const
    {
        return iFace;
    }

    //! Store old HDF5 error handling function
    struct HDF5ErrorHandler
    {
        HDF5_Error_Func_Type func;
        void* data;
    };

  protected:
    ErrorCode load_file_impl( const FileOptions& opts );

    ErrorCode load_file_partial( const ReaderIface::IDTag* subset_list,
                                 int subset_list_length,
                                 int num_parts,
                                 int part_number,
                                 const FileOptions& opts );

    ErrorCode read_tag_values_all( int tag_index, std::vector< int >& results );
    ErrorCode read_tag_values_partial( int tag_index, const Range& file_ids, std::vector< int >& results );

    enum ReadTimingValues
    {
        TOTAL_TIME = 0,
        SET_META_TIME,
        SUBSET_IDS_TIME,
        GET_PARTITION_TIME,
        GET_SET_IDS_TIME,
        GET_SET_CONTENTS_TIME,
        GET_POLYHEDRA_TIME,
        GET_ELEMENTS_TIME,
        GET_NODES_TIME,
        GET_NODEADJ_TIME,
        GET_SIDEELEM_TIME,
        UPDATECONN_TIME,
        ADJACENCY_TIME,
        DELETE_NON_SIDEELEM_TIME,
        READ_SET_IDS_RECURS_TIME,
        FIND_SETS_CONTAINING_TIME,
        READ_SETS_TIME,
        READ_TAGS_TIME,
        STORE_FILE_IDS_TIME,
        READ_QA_TIME,
        NUM_TIMES
    };

    void print_times();

  private:
    ErrorCode init();

    inline int is_error( mhdf_Status& status )
    {
        int i;
        if( ( i = mhdf_isError( &status ) ) ) MB_SET_ERR_CONT( mhdf_message( &status ) );
        return i;
    }

    //! The size of the data buffer (<code>dataBuffer</code>).
    int bufferSize;
    //! A memory buffer to use for all I/O operations.
    char* dataBuffer;

    //! Interface pointer passed to constructor
    Interface* iFace;

    //! The file handle from the mhdf library
    mhdf_FileHandle filePtr;

    //! File summary
    mhdf_FileDesc* fileInfo;

    //! Map from File ID to MOAB handle
    typedef RangeMap< long, EntityHandle > IDMap;
    IDMap idMap;

    //! Cache pointer to read util
    ReadUtilIface* readUtil;

    //! The type of an EntityHandle
    hid_t handleType;

    //! List of connectivity arrays for which conversion from file ID
    //! to handle was deferred until later.
    struct IDConnectivity
    {
        EntityHandle handle;  // Start_handle
        size_t count;         // Num entities
        int nodes_per_elem;   // Per-element connectivity length
        EntityHandle* array;  // Connectivity array
    };
    //! List of connectivity arrays for which conversion from file ID
    //! to handle was deferred until later.
    std::vector< IDConnectivity > idConnectivityList;

    //! Read/write property handle
    //! indepIO -> independent IO during true parallel read
    //! collIO  -> collective IO during true parallel read
    //! Both are H5P_DEFAULT for serial IO and collective
    //! when reading the entire file on all processors.
    hid_t indepIO, collIO;

    ParallelComm* myPcomm;

    //! Use IODebugTrack instances to verify reads.
    //! Enable with the DEBUG_OVERLAPS option.
    bool debugTrack;
    //! Debug output. Verbosity controlled with DEBUG_FORMAT option.
    DebugOutput dbgOut;
    //! Doing true parallel read (PARALLEL=READ_PART)
    bool nativeParallel;
    //! MPI_Comm value (unused if \c !nativeParallel)
    Comm* mpiComm;

    //! Flags for some behavior that can be changed through
    //! reader options
    bool blockedCoordinateIO;
    bool bcastSummary;
    bool bcastDuplicateReads;

    //! Store old HDF5 error handling function
    HDF5ErrorHandler errorHandler;

    long ( *setMeta )[4];

    double _times[NUM_TIMES];
    CpuTimer* timer;
    bool cputime;
    ErrorCode read_all_set_meta();

    ErrorCode set_up_read( const char* file_name, const FileOptions& opts );
    ErrorCode clean_up_read( const FileOptions& opts );

    //! Given a list of tags and values, get the file ids for the
    //! corresponding entities in the file.
    ErrorCode get_subset_ids( const ReaderIface::IDTag* subset_list, int subset_list_length, Range& file_ids_out );

    /**\brief Remove all but the specified fraction of sets from the passed range
     *
     * Select a subset of the gathered set of file ids to read in based on
     * communicator size and rank.
     *\param tmp_file_ids As input: sets to be read on all procs.
     *                    As output: sets to read on this proc.
     *\param num_parts    communicator size
     *\param part_number  communicator rank
     */
    ErrorCode get_partition( Range& tmp_file_ids, int num_parts, int part_number );

    ErrorCode read_nodes( const Range& node_file_ids );

    // Read elements in fileInfo->elems[index]
    ErrorCode read_elems( int index );

    // Read subset of elements in fileInfo->elems[index]
    ErrorCode read_elems( int index, const Range& file_ids, Range* node_ids = 0 );

    //! Read element connectivity.
    //!
    //!\param node_ids  If this is non-null, the union of the connectivity list
    //!                 for all elements is passed back as FILE IDS in this
    //!                 range AND the connectivity list is left in the form
    //!                 of file IDs (NOT NODE HANDLES).
    ErrorCode read_elems( const mhdf_ElemDesc& elems, const Range& file_ids, Range* node_ids = 0 );

    //! Update connectivity data for all element groups for which read_elems
    //! was called with a non-null \c node_ids argument.
    ErrorCode update_connectivity();

    // Read connectivity data for a list of element file ids.
    // passing back the file IDs for the element connectivity
    // w/out actually creating any elements in MOAB.
    ErrorCode read_elems( int index, const Range& element_file_ids, Range& node_file_ids );

    // Scan all elements in group. For each element for which all vertices
    // are contained in idMap (class member), read the element. All new
    // elements are added to idMap.
    //
    // NOTE: Collective IO calls in parallel.
    ErrorCode read_node_adj_elems( const mhdf_ElemDesc& group, Range* read_entities = 0 );

    // Scan all elements in specified file table. For each element for
    // which all vertices are contained in idMap (class member), read the
    // element. All new elements are added to idMap.
    //
    // NOTE: Collective IO calls in parallel.
    ErrorCode read_node_adj_elems( const mhdf_ElemDesc& group, hid_t connectivity_handle, Range* read_entities = 0 );

    //! Read poly(gons|hedra)
    ErrorCode read_poly( const mhdf_ElemDesc& elems, const Range& file_ids );

    //! Clean up elements that were a) read because we had read all of the
    //! nodes and b) weren't actually sides of the top-dimension elements
    //! we were trying to read.
    ErrorCode delete_non_side_elements( const Range& side_ents );

    //! Read sets
    ErrorCode read_sets( const Range& set_file_ids );

    ErrorCode read_adjacencies( hid_t adjacency_table, long table_length );

    //! Create tag and read all data.
    ErrorCode read_tag( int index );

    //! Create new tag or verify type matches existing tag
    ErrorCode create_tag( const mhdf_TagDesc& info, Tag& handle, hid_t& type );

    //! Read dense tag for all entities
    ErrorCode read_dense_tag( Tag tag_handle,
                              const char* ent_name,
                              hid_t hdf_read_type,
                              hid_t data_table,
                              long start_id,
                              long count );

    //! Read sparse tag for all entities.
    ErrorCode read_sparse_tag( Tag tag_handle,
                               hid_t hdf_read_type,
                               hid_t ent_table,
                               hid_t val_table,
                               long num_entities );

    //! Read variable-length tag for all entities.
    ErrorCode read_var_len_tag( Tag tag_handle,
                                hid_t hdf_read_type,
                                hid_t ent_table,
                                hid_t val_table,
                                hid_t off_table,
                                long num_entities,
                                long num_values );

    /**\brief Read index table for sparse tag.
     *
     * Read ID table for a sparse or variable-length tag, returning
     * the handles and offsets within the table for each file ID
     * that corresponds to an entity we've read from the file (an
     * entity that is in \c idMap).
     *
     * \param id_table     The MOAB handle for the tag
     * \param start_offset Some non-zero value because ranges (in this case
     *                     the offset_range) cannot contain zeros.
     * \param offset_range Output: The offsets in the id table for which IDs
     *                     that occur in \c idMap were found. All values
     *                     are increased by \c start_offset to avoid
     *                     putting zeros in the range.
     * \param handle_range Output: For each valid ID read from the table,
     *                     the corresponding entity handle. Note: if
     *                     the IDs did not occur in handle order, then
     *                     this will be empty. Use \c handle_vect instead.
     * \param handle_vect  Output: For each valid ID read from the table,
     *                     the corresponding entity handle. Note: if
     *                     the IDs occurred in handle order, then
     *                     this will be empty. Use \c handle_range instead.
     */
    ErrorCode read_sparse_tag_indices( const char* name,
                                       hid_t id_table,
                                       EntityHandle start_offset,
                                       Range& offset_range,
                                       Range& handle_range,
                                       std::vector< EntityHandle >& handle_vect );

    ErrorCode read_qa( EntityHandle file_set );

  public:
    ErrorCode convert_id_to_handle( EntityHandle* in_out_array, size_t array_length );

    void convert_id_to_handle( EntityHandle* in_out_array, size_t array_length, size_t& array_length_out ) const
    {
        return convert_id_to_handle( in_out_array, array_length, array_length_out, idMap );
    }

    ErrorCode convert_range_to_handle( const EntityHandle* ranges, size_t num_ranges, Range& merge );

    static void convert_id_to_handle( EntityHandle* in_out_array,
                                      size_t array_length,
                                      const RangeMap< long, EntityHandle >& id_map );

    static void convert_id_to_handle( EntityHandle* in_out_array,
                                      size_t array_length,
                                      size_t& array_length_out,
                                      const RangeMap< long, EntityHandle >& id_map );

    static void convert_range_to_handle( const EntityHandle* ranges,
                                         size_t num_ranges,
                                         const RangeMap< long, EntityHandle >& id_map,
                                         Range& merge );

    ErrorCode insert_in_id_map( const Range& file_ids, EntityHandle start_id );

    ErrorCode insert_in_id_map( long file_id, EntityHandle handle );

  private:
    /**\brief Search for entities with specified tag values
     *
     *\NOTE For parallel reads, this function does collective IO.
     *
     *\param tag_index  Index into info->tags specifying which tag to search.
     *\param sorted_values  List of tag values to check for, in ascending sorted
     *                  order.
     *\param file_ids_out  File IDs for entities with specified tag values.
     */
    ErrorCode search_tag_values( int tag_index,
                                 const std::vector< int >& sorted_values,
                                 Range& file_ids_out,
                                 bool sets_only = false );

    /**\brief Search for entities with specified tag
     *
     *\NOTE For parallel reads, this function does collective IO.
     *
     *\param tag_index  Index into info->tags specifying which tag to search.
     *\param file_ids_out  File IDs for entities with specified tag values.
     */
    ErrorCode get_tagged_entities( int tag_index, Range& file_ids_out );

    /**\brief Search a table of tag data for a specified set of values.
     *
     * Search a table of tag values, returning the indices into the table
     * at which matches were found.
     *\NOTE For parallel reads, this function does collective IO.
     *
     *\param info       Summary of data contained in file.
     *\param tag_table     HDF5/mhdf handle for tag values
     *\param table_size    Number of values in table
     *\param sorted_values Sorted list of values to search for.
     *\param value_indices Output: Offsets into the table of data at which
     *                       matching values were found.
     */
    ErrorCode search_tag_values( hid_t tag_table,
                                 unsigned long table_size,
                                 const std::vector< int >& sorted_values,
                                 std::vector< EntityHandle >& value_indices );

    /**\brief Get the file IDs for nodes and elements contained in sets.
     *
     * Read the contents for the specified sets and return the file IDs
     * of all nodes and elements contained within those sets.
     *\param sets       Container of file IDs designating entity sets.
     *\param file_ids   Output: File IDs of entities contained in sets.
     */
    ErrorCode get_set_contents( const Range& sets, Range& file_ids );

    /** Given a list of file IDs for entity sets, find all contained
     *  or child sets (at any depth) and append them to the Range
     *  of file IDs.
     */
    ErrorCode read_set_ids_recursive( Range& sets_in_out, bool containted_sets, bool child_sets );

    /** Find all sets containing one or more entities read from the file
     *  and added to idMap
     */
    ErrorCode find_sets_containing( Range& sets_out, bool read_set_containing_parents );

    /**\brief Read sets from file into MOAB for partial read of file.
     *
     * Given the file IDs for entity sets (sets_in) and elements and
     * nodes (id_map), read in all sets containing any of the elements
     * or nodes and all sets that are (recursively) children of any
     * other set to be read (those in sets_in or those containing any
     * already-read element or node.)
     *\param sets_in    File IDs for sets to read (unconditionally)
     */
    ErrorCode read_sets_partial( const Range& sets_in );

    /** Find file IDs of sets containing any entities in the passed id_map */
    ErrorCode find_sets_containing( hid_t content_handle,
                                    hid_t content_type,
                                    long content_len,
                                    bool read_set_containing_parents,
                                    Range& file_ids );

  public:
    enum SetMode
    {
        CONTENT = 0,
        CHILD   = 1,
        PARENT  = 2
    };

  private:
    // Read the set data specified by by which_data.
    // Update set data in MOAB according to which_data,
    // unless file_ids_out is non-null. If file_ids_out is
    // non-null, then return the file IDs in the passed
    // range and do not make any changes to MOAB data
    // structures. If file_ids_out is NULL, then set_start_handle
    // is ignored.
    ErrorCode read_set_data( const Range& set_file_ids,
                             EntityHandle set_start_handle,
                             ReadHDF5Dataset& set_data_set,
                             SetMode which_data,
                             Range* file_ids_out = 0 );

    /**\brief Store file IDS in tag values
     *
     * Copy file ID from IDMap for each entity read from file
     * into a tag value on the entity.
     */
    ErrorCode store_file_ids( Tag tag );

    /**\brief Store sets file IDS in a custom tag
     *
     * Copy sets file ID from IDMap for each set read from file
     *  into a custom tag on the sets
     *  needed now for the VisIt plugin, to identify sets read
     */
    ErrorCode store_sets_file_ids();

    /**\brief Find index in mhdf_FileDesc* fileInfo for specified tag name
     *
     * Given a tag name, find its index in fileInfo and verify that
     * each tag value is a single integer.
     */
    ErrorCode find_int_tag( const char* name, int& index_out );

    void debug_barrier_line( int lineno );
};

}  // namespace moab

#endif