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)
 *
 */
#pragma once
 
#include <vector>
 
#include <H5Ppublic.h>
 
// Required by MPIOFileAccess
#ifdef H5_HAVE_PARALLEL
#include <H5FDmpi.h>
#endif
 
#include "H5Exception.hpp"
#include "H5Object.hpp"
 
namespace HighFive {
 
 
enum class PropertyType : int {
    FILE_CREATE,
    FILE_ACCESS,
    DATASET_CREATE,
    DATASET_ACCESS,
    DATASET_XFER,
    GROUP_CREATE,
    GROUP_ACCESS,
    DATATYPE_CREATE,
    DATATYPE_ACCESS,
    STRING_CREATE,
    ATTRIBUTE_CREATE,
    LINK_CREATE,
    LINK_ACCESS,
};
 
namespace details {
template <typename T, typename U>
T get_plist(const U& obj, hid_t (*f)(hid_t)) {
    auto hid = f(obj.getId());
    if (hid < 0) {
        HDF5ErrMapper::ToException<PropertyException>("Unable to get property list");
    }
    T t{};
    t._hid = hid;
    return t;
}
}  // namespace details
 
class PropertyListBase: public Object {
  public:
    PropertyListBase() noexcept;
 
    static const PropertyListBase& Default() noexcept {
        static const PropertyListBase plist{};
        return plist;
    }
 
  private:
    template <typename T, typename U>
    friend T details::get_plist(const U&, hid_t (*f)(hid_t));
};
 
#if HIGHFIVE_HAS_CONCEPTS && __cplusplus >= 202002L
template <typename P>
concept PropertyInterface = requires(P p, const hid_t hid) {
    {p.apply(hid)};
};
 
#else
#define PropertyInterface typename
#endif
 
template <PropertyType T>
class PropertyList: public PropertyListBase {
  public:
    constexpr PropertyType getType() const noexcept {
        return T;
    }
 
    template <PropertyInterface P>
    void add(const P& property);
 
    static const PropertyList<T>& Default() noexcept {
        return static_cast<const PropertyList<T>&>(PropertyListBase::Default());
    }
 
    static PropertyList<T> Empty() {
        auto plist = PropertyList<T>();
        plist._initializeIfNeeded();
 
        return plist;
    }
 
  protected:
    void _initializeIfNeeded();
};
 
using FileCreateProps = PropertyList<PropertyType::FILE_CREATE>;
using FileAccessProps = PropertyList<PropertyType::FILE_ACCESS>;
using DataSetCreateProps = PropertyList<PropertyType::DATASET_CREATE>;
using DataSetAccessProps = PropertyList<PropertyType::DATASET_ACCESS>;
using DataTransferProps = PropertyList<PropertyType::DATASET_XFER>;
using GroupCreateProps = PropertyList<PropertyType::GROUP_CREATE>;
using GroupAccessProps = PropertyList<PropertyType::GROUP_ACCESS>;
using DataTypeCreateProps = PropertyList<PropertyType::DATATYPE_CREATE>;
using DataTypeAccessProps = PropertyList<PropertyType::DATATYPE_ACCESS>;
using StringCreateProps = PropertyList<PropertyType::STRING_CREATE>;
using AttributeCreateProps = PropertyList<PropertyType::ATTRIBUTE_CREATE>;
using LinkCreateProps = PropertyList<PropertyType::LINK_CREATE>;
using LinkAccessProps = PropertyList<PropertyType::LINK_ACCESS>;
 
template <PropertyType T>
class RawPropertyList: public PropertyList<T> {
  public:
    template <typename F, typename... Args>
    void add(const F& funct, const Args&... args);
};
 
#ifdef H5_HAVE_PARALLEL
class MPIOFileAccess {
  public:
    MPIOFileAccess(MPI_Comm comm, MPI_Info info);
 
  private:
    friend FileAccessProps;
    void apply(const hid_t list) const;
 
    MPI_Comm _comm;
    MPI_Info _info;
};
 
 
#if H5_VERSION_GE(1, 10, 0)
class MPIOCollectiveMetadata {
  public:
    explicit MPIOCollectiveMetadata(bool collective = true);
    explicit MPIOCollectiveMetadata(const FileAccessProps& plist);
 
    bool isCollectiveRead() const;
    bool isCollectiveWrite() const;
 
 
  private:
    friend FileAccessProps;
    void apply(hid_t plist) const;
 
    bool collective_read_;
    bool collective_write_;
};
 
class MPIOCollectiveMetadataRead {
  public:
    explicit MPIOCollectiveMetadataRead(bool collective = true);
    explicit MPIOCollectiveMetadataRead(const FileAccessProps& plist);
 
    bool isCollective() const;
 
  private:
    friend FileAccessProps;
    friend MPIOCollectiveMetadata;
 
    void apply(hid_t plist) const;
 
    bool collective_;
};
 
class MPIOCollectiveMetadataWrite {
  public:
    explicit MPIOCollectiveMetadataWrite(bool collective = true);
    explicit MPIOCollectiveMetadataWrite(const FileAccessProps& plist);
 
    bool isCollective() const;
 
  private:
    friend FileAccessProps;
    friend MPIOCollectiveMetadata;
 
    void apply(hid_t plist) const;
 
    bool collective_;
};
 
#endif
#endif
 
class FileVersionBounds {
  public:
    FileVersionBounds(H5F_libver_t low, H5F_libver_t high);
    explicit FileVersionBounds(const FileAccessProps& fapl);
 
    std::pair<H5F_libver_t, H5F_libver_t> getVersion() const;
 
  private:
    friend FileAccessProps;
    void apply(const hid_t list) const;
 
    H5F_libver_t _low;
    H5F_libver_t _high;
};
 
class MetadataBlockSize {
  public:
    explicit MetadataBlockSize(hsize_t size);
    explicit MetadataBlockSize(const FileAccessProps& fapl);
 
    hsize_t getSize() const;
 
  private:
    friend FileAccessProps;
    void apply(const hid_t list) const;
    hsize_t _size;
};
 
#if H5_VERSION_GE(1, 10, 1)
class FileSpaceStrategy {
  public:
    FileSpaceStrategy(H5F_fspace_strategy_t strategy, hbool_t persist, hsize_t threshold);
    explicit FileSpaceStrategy(const FileCreateProps& fcpl);
 
    H5F_fspace_strategy_t getStrategy() const;
    hbool_t getPersist() const;
    hsize_t getThreshold() const;
 
  private:
    friend FileCreateProps;
 
    void apply(const hid_t list) const;
 
    H5F_fspace_strategy_t _strategy;
    hbool_t _persist;
    hsize_t _threshold;
};
 
class FileSpacePageSize {
  public:
    explicit FileSpacePageSize(hsize_t page_size);
    explicit FileSpacePageSize(const FileCreateProps& fcpl);
 
    hsize_t getPageSize() const;
 
  private:
    friend FileCreateProps;
    void apply(const hid_t list) const;
 
    hsize_t _page_size;
};
 
#ifndef H5_HAVE_PARALLEL
class PageBufferSize {
  public:
    explicit PageBufferSize(size_t page_buffer_size,
                            unsigned min_meta_percent = 0,
                            unsigned min_raw_percent = 0);
 
    explicit PageBufferSize(const FileAccessProps& fapl);
 
    size_t getPageBufferSize() const;
    unsigned getMinMetaPercent() const;
    unsigned getMinRawPercent() const;
 
  private:
    friend FileAccessProps;
 
    void apply(hid_t list) const;
 
    size_t _page_buffer_size;
    unsigned _min_meta;
    unsigned _min_raw;
};
#endif
#endif
 
class EstimatedLinkInfo {
  public:
    explicit EstimatedLinkInfo(unsigned entries, unsigned length);
 
    explicit EstimatedLinkInfo(const GroupCreateProps& gcpl);
 
    unsigned getEntries() const;
 
    unsigned getNameLength() const;
 
  private:
    friend GroupCreateProps;
    void apply(hid_t hid) const;
    unsigned _entries;
    unsigned _length;
};
 
 
class Chunking {
  public:
    explicit Chunking(const std::vector<hsize_t>& dims);
    Chunking(const std::initializer_list<hsize_t>& items);
 
    template <typename... Args>
    explicit Chunking(hsize_t item, Args... args);
 
    explicit Chunking(DataSetCreateProps& plist, size_t max_dims = 32);
 
    const std::vector<hsize_t>& getDimensions() const noexcept;
 
  private:
    friend DataSetCreateProps;
    void apply(hid_t hid) const;
    std::vector<hsize_t> _dims;
};
 
class Deflate {
  public:
    explicit Deflate(unsigned level);
 
  private:
    friend DataSetCreateProps;
    friend GroupCreateProps;
    void apply(hid_t hid) const;
    const unsigned _level;
};
 
class Szip {
  public:
    explicit Szip(unsigned options_mask = H5_SZIP_EC_OPTION_MASK,
                  unsigned pixels_per_block = H5_SZIP_MAX_PIXELS_PER_BLOCK);
 
    unsigned getOptionsMask() const;
    unsigned getPixelsPerBlock() const;
 
  private:
    friend DataSetCreateProps;
    void apply(hid_t hid) const;
    const unsigned _options_mask;
    const unsigned _pixels_per_block;
};
 
class Shuffle {
  public:
    Shuffle() = default;
 
  private:
    friend DataSetCreateProps;
    void apply(hid_t hid) const;
};
 
class AllocationTime {
  public:
    explicit AllocationTime(H5D_alloc_time_t alloc_time);
    explicit AllocationTime(const DataSetCreateProps& dcpl);
 
    H5D_alloc_time_t getAllocationTime();
 
  private:
    friend DataSetCreateProps;
    void apply(hid_t dcpl) const;
 
    H5D_alloc_time_t _alloc_time;
};
 
class Caching {
  public:
    Caching(const size_t numSlots,
            const size_t cacheSize,
            const double w0 = static_cast<double>(H5D_CHUNK_CACHE_W0_DEFAULT));
 
    explicit Caching(const DataSetCreateProps& dcpl);
 
    size_t getNumSlots() const;
    size_t getCacheSize() const;
    double getW0() const;
 
  private:
    friend DataSetAccessProps;
    void apply(hid_t hid) const;
    size_t _numSlots;
    size_t _cacheSize;
    double _w0;
};
 
class CreateIntermediateGroup {
  public:
    explicit CreateIntermediateGroup(bool create = true);
 
    explicit CreateIntermediateGroup(const LinkCreateProps& lcpl);
 
    bool isSet() const;
 
  protected:
    void fromPropertyList(hid_t hid);
 
  private:
    friend LinkCreateProps;
    void apply(hid_t hid) const;
    bool _create;
};
 
#ifdef H5_HAVE_PARALLEL
class UseCollectiveIO {
  public:
    explicit UseCollectiveIO(bool enable = true);
 
    explicit UseCollectiveIO(const DataTransferProps& dxpl);
 
    bool isCollective() const;
 
  private:
    friend DataTransferProps;
    void apply(hid_t hid) const;
    bool _enable;
};
 
 
class MpioNoCollectiveCause {
  public:
    explicit MpioNoCollectiveCause(const DataTransferProps& dxpl);
 
    bool wasCollective() const;
 
    uint32_t getLocalCause() const;
 
    uint32_t getGlobalCause() const;
 
    std::pair<uint32_t, uint32_t> getCause() const;
 
  private:
    friend DataTransferProps;
    uint32_t _local_cause;
    uint32_t _global_cause;
};
#endif
 
struct CreationOrder {
    enum _CreationOrder {
        Tracked = H5P_CRT_ORDER_TRACKED,
        Indexed = H5P_CRT_ORDER_INDEXED,
    };
};
 
class LinkCreationOrder {
  public:
    explicit LinkCreationOrder(unsigned flags)
        : _flags(flags) {}
 
    explicit LinkCreationOrder(const FileCreateProps& fcpl);
    explicit LinkCreationOrder(const GroupCreateProps& gcpl);
 
    unsigned getFlags() const;
 
  protected:
    void fromPropertyList(hid_t hid);
 
  private:
    friend FileCreateProps;
    friend GroupCreateProps;
    void apply(hid_t hid) const;
    unsigned _flags;
};
 
 
class AttributePhaseChange {
  public:
    AttributePhaseChange(unsigned max_compact, unsigned min_dense);
 
    explicit AttributePhaseChange(const GroupCreateProps& gcpl);
 
    unsigned max_compact() const;
    unsigned min_dense() const;
 
  private:
    friend GroupCreateProps;
    void apply(hid_t hid) const;
 
    unsigned _max_compact;
    unsigned _min_dense;
};
 
 
}  // namespace HighFive
 
#include "bits/H5PropertyList_misc.hpp"