mdal_hdf5.hpp

/*
 MDAL - Mesh Data Abstraction Library (MIT License)
 Copyright (C) 2018 Lutra Consulting Limited
*/
 
#ifndef MDAL_HDF5_HPP
#define MDAL_HDF5_HPP
 
 
// for compatibility (older hdf5 version in Travis)
#define H5Gopen_vers 1
 
#include "mdal_utils.hpp"
#include "mdal_logger.hpp"
#include "hdf5.h"
typedef unsigned char uchar;
 
#include <memory>
#include <vector>
#include <string>
#include <numeric>
 
#include <assert.h>
#include "stdlib.h"
 
#define HDF_MAX_NAME 1024
struct HdfString
{
  char data [HDF_MAX_NAME];
};
 
template <int TYPE> inline void hdfClose( hid_t id ) { MDAL_UNUSED( id ); assert( false ); }
template <> inline void hdfClose<H5I_FILE>( hid_t id ) { H5Fclose( id ); }
template <> inline void hdfClose<H5I_GROUP>( hid_t id ) { H5Gclose( id ); }
template <> inline void hdfClose<H5I_DATASET>( hid_t id ) { H5Dclose( id ); }
template <> inline void hdfClose<H5I_ATTR>( hid_t id ) { H5Aclose( id ); }
template <> inline void hdfClose<H5I_DATASPACE>( hid_t id ) { H5Sclose( id ); }
template <> inline void hdfClose<H5I_DATATYPE>( hid_t id ) { H5Tclose( id ); }
 
template <int TYPE>
class HdfH
{
  public:
    HdfH( hid_t hid ) : id( hid ) {}
    HdfH( const HdfH &other ) : id( other.id ) { }
    ~HdfH() { if ( id >= 0 ) hdfClose<TYPE>( id ); }
 
    hid_t id;
};
 
class HdfGroup;
class HdfDataset;
class HdfAttribute;
class HdfDataspace;
class HdfDataType;
 
class HdfFile
{
  public:
    enum Mode
    {
      ReadOnly,
      ReadWrite,
      Create
    };
    typedef HdfH<H5I_FILE> Handle;
 
    HdfFile( const std::string &path, HdfFile::Mode mode );
    ~HdfFile();
    bool isValid() const;
    hid_t id() const;
 
    inline std::vector<std::string> groups() const;
 
    inline HdfGroup group( const std::string &path ) const;
    inline HdfDataset dataset( const std::string &path ) const;
    inline HdfAttribute attribute( const std::string &attr_name ) const;
    inline bool pathExists( const std::string &path ) const;
    std::string filePath() const;
 
  protected:
    std::shared_ptr<Handle> d;
    std::string mPath;
};
 
class HdfDataType
{
  public:
    typedef HdfH<H5I_DATATYPE> Handle;
    HdfDataType();
    HdfDataType( hid_t type, bool isNativeType = true );
    ~HdfDataType();
 
    // Creates new string type with size, use HDF_MAX_NAME for maximum length
    static HdfDataType createString( int size = HDF_MAX_NAME );
    bool isValid() const;
    hid_t id() const;
 
 
  protected:
    std::shared_ptr<Handle> d;
    hid_t mNativeId = -1;
};
 
class HdfGroup
{
  public:
    typedef HdfH<H5I_GROUP> Handle;
 
    static HdfGroup create( hid_t file, const std::string &path );
    HdfGroup( hid_t file, const std::string &path );
    HdfGroup( std::shared_ptr<Handle> handle );
 
    bool isValid() const;
    hid_t id() const;
    hid_t file_id() const;
 
    std::string name() const;
 
    std::vector<std::string> groups() const;
    std::vector<std::string> datasets() const;
    std::vector<std::string> objects() const;
 
    std::string childPath( const std::string &childName ) const;
 
    inline HdfGroup group( const std::string &groupName ) const;
    inline HdfDataset dataset( const std::string &dsName ) const;
    inline HdfAttribute attribute( const std::string &attr_name ) const;
    inline bool pathExists( const std::string &path ) const;
  protected:
    std::vector<std::string> objects( H5G_obj_t type ) const;
 
  protected:
    std::shared_ptr<Handle> d;
};
 
class HdfAttribute
{
  public:
    typedef HdfH<H5I_ATTR> Handle;
 
    HdfAttribute( hid_t obj_id, const std::string &attr_name, HdfDataType type );
 
    HdfAttribute( hid_t obj_id, const std::string &attr_name );
    ~HdfAttribute();
    bool isValid() const;
    hid_t id() const;
 
    std::string readString() const;
    double readDouble() const;
 
    void write( const std::string &value );
    void write( int value );
 
  protected:
    std::shared_ptr<Handle> d;
    hid_t m_objId;
    std::string m_name;
    HdfDataType mType; // when in write mode
};
 
 
 
class HdfDataspace
{
  public:
    typedef HdfH<H5I_DATASPACE> Handle;
 
    HdfDataspace( const std::vector<hsize_t> &dims );
    HdfDataspace( hid_t dataset = -1 );
    ~HdfDataspace( );
    void selectHyperslab( hsize_t start, hsize_t count );
    void selectHyperslab( const std::vector<hsize_t> offsets,
                          const std::vector<hsize_t> counts );
 
    bool isValid() const;
    hid_t id() const;
 
  protected:
    std::shared_ptr<Handle> d;
};
 
class HdfDataset
{
  public:
    typedef HdfH<H5I_DATASET> Handle;
 
    HdfDataset() = default;
 
    HdfDataset( hid_t file, const std::string &path, HdfDataType dtype, size_t nItems = 1 );
    HdfDataset( hid_t file, const std::string &path, HdfDataType dtype, HdfDataspace dataspace );
    HdfDataset( hid_t file, const std::string &path );
    ~HdfDataset();
    bool isValid() const;
    hid_t id() const;
 
    std::vector<hsize_t> dims() const;
 
    hsize_t elementCount() const;
 
    H5T_class_t type() const;
 
    std::vector<uchar> readArrayUint8() const;
    std::vector<float> readArray() const;
    std::vector<double> readArrayDouble() const;
    std::vector<int> readArrayInt() const;
    std::vector<std::string> readArrayString() const;
 
    std::vector<uchar> readArrayUint8( const std::vector<hsize_t> offsets, const std::vector<hsize_t> counts ) const;
    std::vector<float> readArray( const std::vector<hsize_t> offsets, const std::vector<hsize_t> counts ) const;
    std::vector<double> readArrayDouble( const std::vector<hsize_t> offsets, const std::vector<hsize_t> counts ) const;
    std::vector<int> readArrayInt( const std::vector<hsize_t> offsets, const std::vector<hsize_t> counts ) const;
 
    inline bool hasAttribute( const std::string &attr_name ) const;
    inline HdfAttribute attribute( const std::string &attr_name ) const;
 
    template <typename T> std::vector<T> readArray( hid_t mem_type_id ) const
    {
      hsize_t cnt = elementCount();
      std::vector<T> data( cnt );
      herr_t status = H5Dread( d->id, mem_type_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, data.data() );
      if ( status < 0 )
      {
        MDAL::Log::debug( "Failed to read data!" );
        return std::vector<T>();
      }
      return data;
    }
 
    template <typename T> std::vector<T> readArray( hid_t mem_type_id,
        const std::vector<hsize_t> offsets,
        const std::vector<hsize_t> counts ) const
    {
      HdfDataspace dataspace( d->id );
      dataspace.selectHyperslab( offsets, counts );
 
      hsize_t totalItems = 1;
      for ( auto it = counts.begin(); it != counts.end(); ++it )
        totalItems *= *it;
 
      std::vector<hsize_t> dims = {totalItems};
      HdfDataspace memspace( dims );
      memspace.selectHyperslab( 0, totalItems );
 
      std::vector<T> data( totalItems );
      herr_t status = H5Dread( d->id, mem_type_id, memspace.id(), dataspace.id(), H5P_DEFAULT, data.data() );
      if ( status < 0 )
      {
        MDAL::Log::debug( "Failed to read data!" );
        return std::vector<T>();
      }
      return data;
    }
 
    float readFloat() const;
 
    std::string readString() const;
 
    void write( const std::string &value );
 
    void write( std::vector<float> &value );
    void write( float value );
 
    void write( std::vector<double> &value );
 
  protected:
    std::shared_ptr<Handle> d;
    HdfDataType mType; // when in write mode
};
 
inline std::vector<std::string> HdfFile::groups() const { return group( "/" ).groups(); }
 
inline HdfGroup HdfFile::group( const std::string &path ) const { return HdfGroup( d->id, path ); }
 
inline HdfDataset HdfFile::dataset( const std::string &path ) const { return HdfDataset( d->id, path ); }
 
inline HdfGroup HdfGroup::group( const std::string &groupName ) const { return HdfGroup( file_id(), childPath( groupName ) ); }
 
inline HdfDataset HdfGroup::dataset( const std::string &dsName ) const { return HdfDataset( file_id(), childPath( dsName ) ); }
 
inline bool HdfDataset::hasAttribute( const std::string &attr_name ) const
{
  htri_t res = H5Aexists( d->id, attr_name.c_str() );
  return  res > 0 ;
}
 
inline HdfAttribute HdfFile::attribute( const std::string &attr_name ) const { return HdfAttribute( d->id, attr_name ); }
 
inline HdfAttribute HdfGroup::attribute( const std::string &attr_name ) const { return HdfAttribute( d->id, attr_name ); }
 
inline HdfAttribute HdfDataset::attribute( const std::string &attr_name ) const { return HdfAttribute( d->id, attr_name ); }
 
inline bool HdfFile::pathExists( const std::string &path ) const { return H5Lexists( d->id, path.c_str(), H5P_DEFAULT ) > 0; }
 
inline bool HdfGroup::pathExists( const std::string &path ) const { return H5Lexists( d->id, path.c_str(), H5P_DEFAULT ) > 0; }
 
#endif // MDAL_HDF5_HPP