H5PropertyList.hpp

Go to the documentation of this file.

/*
 *  Copyright (c), 2017-2018, Adrien Devresse <adrien.devresse@epfl.ch>
 *                            Juan Hernando <juan.hernando@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 H5PROPERTY_LIST_HPP
#define H5PROPERTY_LIST_HPP
 
#include <vector>
 
#include <H5Ppublic.h>
 
#include "H5Exception.hpp"
#include "H5Object.hpp"
 
namespace HighFive {
 
enum class PropertyType : int {
    OBJECT_CREATE,
    FILE_CREATE,
    FILE_ACCESS,
    DATASET_CREATE,
    DATASET_ACCESS,
    DATASET_XFER,
    GROUP_CREATE,
    GROUP_ACCESS,
    DATATYPE_CREATE,
    DATATYPE_ACCESS,
    STRING_CREATE,
    ATTRIBUTE_CREATE,
    OBJECT_COPY,
    LINK_CREATE,
    LINK_ACCESS,
};
 
template <PropertyType T>
class PropertyList {
  public:
    ~PropertyList();
 
    PropertyList(const PropertyList<T>&) = delete;
    PropertyList& operator=(const PropertyList<T>&) = delete;
    PropertyList(PropertyList&& other) noexcept;
    PropertyList& operator=(PropertyList&& other) noexcept;
    constexpr PropertyType getType() const { return T; }
 
    hid_t getId() const { return _hid; }
 
    PropertyList() noexcept;
 
    template <typename P>
    PropertyList(const std::initializer_list<P>&);
 
    template <typename P>
    void add(const P& property);
 
  protected:
    void _initializeIfNeeded();
 
    hid_t _hid;
};
 
typedef PropertyList<PropertyType::FILE_CREATE> FileCreateProps;
typedef PropertyList<PropertyType::FILE_ACCESS> FileAccessProps ;
typedef PropertyList<PropertyType::DATASET_CREATE> DataSetCreateProps;
typedef PropertyList<PropertyType::DATASET_ACCESS> DataSetAccessProps;
typedef PropertyList<PropertyType::DATASET_XFER> DataTransferProps;
 
template <PropertyType T>
class RawPropertyList : public PropertyList<T> {
  public:
    template <typename F, typename... Args>
    void add(const F& funct, const Args&... args);
};
 
 
class Chunking {
  public:
    explicit Chunking(const std::vector<hsize_t>& dims)
        : _dims(dims) {}
 
    Chunking(const std::initializer_list<hsize_t>& items)
        : Chunking(std::vector<hsize_t>{items}) {}
 
    template <typename... Args>
    explicit Chunking(hsize_t item, Args... args)
        : Chunking(std::vector<hsize_t>{item, static_cast<hsize_t>(args)...}) {}
 
    const std::vector<hsize_t>& getDimensions() const noexcept {
        return _dims;
    }
 
  private:
    friend DataSetCreateProps;
    void apply(hid_t hid) const;
    const std::vector<hsize_t> _dims;
};
 
class Deflate {
  public:
    explicit Deflate(unsigned level)
        : _level(level) {}
 
  private:
    friend DataSetCreateProps;
    void apply(hid_t hid) const;
    const unsigned _level;
};
 
class Shuffle {
  public:
    Shuffle() = default;
 
  private:
    friend DataSetCreateProps;
    void apply(hid_t hid) const;
};
 
class Caching {
  public:
    Caching(const size_t numSlots,
            const size_t cacheSize,
            const double w0 = static_cast<double>(H5D_CHUNK_CACHE_W0_DEFAULT))
        : _numSlots(numSlots)
        , _cacheSize(cacheSize)
        , _w0(w0) {}
 
  private:
    friend DataSetAccessProps;
    void apply(hid_t hid) const;
    const size_t _numSlots;
    const size_t _cacheSize;
    const double _w0;
};
 
}  // namespace HighFive
 
#include "bits/H5PropertyList_misc.hpp"
 
#endif  // H5PROPERTY_LIST_HPP