H5Easy.hpp

Go to the documentation of this file.

/*
 *  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)
 *
 */
 
 
#pragma once
 
#include <string>
#include <vector>
 
// optionally enable xtensor plug-in and load the library
#ifdef XTENSOR_VERSION_MAJOR
#ifndef H5_USE_XTENSOR
#define H5_USE_XTENSOR
#endif
#endif
 
#ifdef H5_USE_XTENSOR
#include "xtensor.hpp"
#endif
 
// optionally enable Eigen plug-in and load the library
#ifdef EIGEN_WORLD_VERSION
#ifndef H5_USE_EIGEN
#define H5_USE_EIGEN
#endif
#endif
 
#ifdef H5_USE_EIGEN
#include <Eigen/Eigen>
#include "eigen.hpp"
#endif
 
// optionally enable OpenCV plug-in and load the library
#ifdef CV_MAJOR_VERSION
#ifndef H5_USE_OPENCV
#define H5_USE_OPENCV
#endif
#endif
 
#ifdef H5_USE_OPENCV
#include <opencv2/opencv.hpp>
#include "experimental/opencv.hpp"
#endif
 
#include "H5File.hpp"
 
namespace H5Easy {
 
using HighFive::AtomicType;
using HighFive::Attribute;
using HighFive::Chunking;
using HighFive::DataSet;
using HighFive::DataSetCreateProps;
using HighFive::DataSpace;
using HighFive::Deflate;
using HighFive::Exception;
using HighFive::File;
using HighFive::ObjectType;
using HighFive::Shuffle;
 
enum class DumpMode {
    Create = 0,   
    Overwrite = 1 
};
 
enum class Flush {
    False = 0, 
    True = 1   
};
 
class Compression {
  public:
    explicit Compression(bool enable = true);
 
    template <class T>
    Compression(T 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_public.hpp"
#include "h5easy_bits/H5Easy_scalar.hpp"