H5Easy.hpp

/*
 *  Copyright (c), 2017, Adrien Devresse <adrien.devresse@epfl.ch>
 *
 *  Distributed under the Boost Software License, Version 1.0.
 *    (See accompanying file LICENSE_1_0.txt or copy at
 *          http://www.boost.org/LICENSE_1_0.txt)
 *
 */
#ifndef H5EASY_HPP
#define H5EASY_HPP
 
#include <string>
#include <vector>
 
// optionally enable xtensor plug-in and load the library
#ifdef XTENSOR_VERSION_MAJOR
#ifndef H5GT_USE_XTENSOR
#define H5GT_USE_XTENSOR
#endif
#endif
 
#ifdef H5GT_USE_XTENSOR
#include <xtensor/xarray.hpp>
#include <xtensor/xtensor.hpp>
#endif
 
// optionally enable Eigen plug-in and load the library
#ifdef EIGEN_WORLD_VERSION
#ifndef H5GT_USE_EIGEN
#define H5GT_USE_EIGEN
#endif
#endif
 
#ifdef H5GT_USE_EIGEN
#include <Eigen/Eigen>
#endif
 
// optionally enable OpenCV plug-in and load the library
#ifdef CV_MAJOR_VERSION
#ifndef H5GT_USE_OPENCV
#define H5GT_USE_OPENCV
#endif
#endif
 
#ifdef H5GT_USE_OPENCV
#include <opencv2/opencv.hpp>
#endif
 
#include "H5File.hpp"
 
namespace H5Easy {
 
using h5gt::Attribute;
using h5gt::AtomicType;
using h5gt::DataSet;
using h5gt::DataSetCreateProps;
using h5gt::DataSpace;
using h5gt::Exception;
using h5gt::File;
using h5gt::ObjectType;
using h5gt::LinkCreateProps;
using h5gt::LinkAccessProps;
 
enum class DumpMode {
  Create = 0, 
  Overwrite = 1 
};
 
enum class Flush
{
  False = 0, 
  True = 1 
};
 
class Compression
{
public:
 
  //
  // \brief Enable compression with the highest compression level (9).
  // or disable compression (set compression level to 0).
  explicit Compression(bool enable = true);
 
  //
  // \brief Set compression level.
  template <class T>
  Compression(T level);
 
  //
  // \brief Return compression level.
  inline unsigned get() const;
 
private:
  unsigned m_compression_level;
};
 
class DumpOptions
{
public:
  DumpOptions() = default;
 
  template <class... Args>
  DumpOptions(Args... args)
  {
    set(args...);
  }
 
  inline void set(DumpMode mode);
 
  inline void set(Flush mode);
 
  inline void set(const Compression& level);
 
  template <class T, class... Args>
  inline void set(T arg, Args... args);
 
  template <class T>
  inline void setChunkSize(const std::vector<T>& shape);
 
  inline void setChunkSize(std::initializer_list<size_t> shape);
 
  inline bool overwrite() const;
 
  inline bool flush() const;
 
  inline bool compress() const;
 
  inline unsigned getCompressionLevel() const;
 
  inline bool isChunked() const;
 
  inline std::vector<hsize_t> getChunkSize() const;
 
private:
  bool m_overwrite = false;
  bool m_flush = true;
  unsigned m_compression_level = 0;
  std::vector<hsize_t> m_chunk_size = {};
};
 
inline size_t getSize(const File& file, const std::string& path);
 
inline std::vector<size_t> getShape(const File& file, const std::string& path);
 
template <class T>
inline DataSet dump(File& file,
                    const std::string& path,
                    const T& data,
                    DumpMode mode = DumpMode::Create);
 
template <class T>
inline DataSet dump(File& file,
                    const std::string& path,
                    const T& data,
                    const DumpOptions& options);
 
template <class T>
inline DataSet dump(File& file,
                    const std::string& path,
                    const T& data,
                    const std::vector<size_t>& idx);
 
template <class T>
inline DataSet dump(File& file,
                    const std::string& path,
                    const T& data,
                    const std::initializer_list<size_t>& idx);
 
template <class T>
inline DataSet dump(File& file,
                    const std::string& path,
                    const T& data,
                    const std::vector<size_t>& idx,
                    const DumpOptions& options);
 
template <class T>
inline DataSet dump(File& file,
                    const std::string& path,
                    const T& data,
                    const std::initializer_list<size_t>& idx,
                    const DumpOptions& options);
 
template <class T>
inline T load(const File& file, const std::string& path, const std::vector<size_t>& idx);
 
template <class T>
inline T load(const File& file, const std::string& path);
 
template <class T>
inline Attribute dumpAttribute(File& file,
                               const std::string& path,
                               const std::string& key,
                               const T& data,
                               DumpMode mode = DumpMode::Create);
 
template <class T>
inline Attribute dumpAttribute(File& file,
                               const std::string& path,
                               const std::string& key,
                               const T& data,
                               const DumpOptions& options);
 
template <class T>
inline T loadAttribute(const File& file, const std::string& path, const std::string& key);
 
}  // namespace H5Easy
 
#include "h5easy_bits/H5Easy_Eigen.hpp"
#include "h5easy_bits/H5Easy_misc.hpp"
#include "h5easy_bits/H5Easy_opencv.hpp"
#include "h5easy_bits/H5Easy_public.hpp"
#include "h5easy_bits/H5Easy_scalar.hpp"
#include "h5easy_bits/H5Easy_vector.hpp"
#include "h5easy_bits/H5Easy_xtensor.hpp"
 
#endif  // H5EASY_HPP