H5Slice_traits.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 <cstdlib>
#include <vector>
 
#include "H5_definitions.hpp"
#include "H5Utils.hpp"
#include "convert_size_vector.hpp"
 
#include "../H5PropertyList.hpp"
#include "h5s_wrapper.hpp"
 
namespace HighFive {
 
class ElementSet {
  public:
    ElementSet(std::initializer_list<std::size_t> list);
    ElementSet(std::initializer_list<std::vector<std::size_t>> list);
    explicit ElementSet(const std::vector<std::size_t>& element_ids);
    explicit ElementSet(const std::vector<std::vector<std::size_t>>& element_ids);
 
  private:
    std::vector<std::size_t> _ids;
 
    template <typename Derivate>
    friend class SliceTraits;
};
 
inline std::vector<hsize_t> toHDF5SizeVector(const std::vector<size_t>& from) {
    return detail::convertSizeVector<hsize_t>(from);
}
 
inline std::vector<size_t> toSTLSizeVector(const std::vector<hsize_t>& from) {
    return detail::convertSizeVector<size_t>(from);
}
 
template <typename Impl>
class HyperSlabInterface {
  public:
    DataSpace apply(const DataSpace& space) const {
        return static_cast<const Impl&>(*this).apply(space);
    }
};
 
struct RegularHyperSlab {
    RegularHyperSlab() = default;
 
    explicit RegularHyperSlab(const std::vector<size_t>& offset_,
                              const std::vector<size_t>& count_ = {},
                              const std::vector<size_t>& stride_ = {},
                              const std::vector<size_t>& block_ = {})
        : offset(toHDF5SizeVector(offset_))
        , count(toHDF5SizeVector(count_))
        , stride(toHDF5SizeVector(stride_))
        , block(toHDF5SizeVector(block_)) {}
 
    static RegularHyperSlab fromHDF5Sizes(std::vector<hsize_t> offset_,
                                          std::vector<hsize_t> count_ = {},
                                          std::vector<hsize_t> stride_ = {},
                                          std::vector<hsize_t> block_ = {}) {
        RegularHyperSlab slab;
        slab.offset = std::move(offset_);
        slab.count = std::move(count_);
        slab.stride = std::move(stride_);
        slab.block = std::move(block_);
 
        return slab;
    }
 
    size_t rank() const {
        return std::max(std::max(offset.size(), count.size()),
                        std::max(stride.size(), block.size()));
    }
 
    std::vector<size_t> packedDims() const {
        auto n_dims = rank();
        auto dims = std::vector<size_t>(n_dims, 0);
 
        for (size_t i = 0; i < n_dims; ++i) {
            dims[i] = count[i] * (block.empty() ? 1 : block[i]);
        }
 
        return dims;
    }
 
    std::vector<hsize_t> offset;
    std::vector<hsize_t> count;
    std::vector<hsize_t> stride;
    std::vector<hsize_t> block;
};
 
class HyperSlab: public HyperSlabInterface<HyperSlab> {
  public:
    HyperSlab() {
        selects.emplace_back(RegularHyperSlab{}, Op::None);
    };
 
    explicit HyperSlab(const RegularHyperSlab& sel) {
        selects.emplace_back(sel, Op::Set);
    }
 
    HyperSlab operator|(const RegularHyperSlab& sel) const {
        auto ret = *this;
        ret |= sel;
        return ret;
    }
 
    HyperSlab& operator|=(const RegularHyperSlab& sel) {
        selects.emplace_back(sel, Op::Or);
        return *this;
    }
 
    HyperSlab operator&(const RegularHyperSlab& sel) const {
        auto ret = *this;
        ret &= sel;
        return ret;
    }
 
    HyperSlab& operator&=(const RegularHyperSlab& sel) {
        selects.emplace_back(sel, Op::And);
        return *this;
    }
 
    HyperSlab operator^(const RegularHyperSlab& sel) const {
        auto ret = *this;
        ret ^= sel;
        return ret;
    }
 
    HyperSlab& operator^=(const RegularHyperSlab& sel) {
        selects.emplace_back(sel, Op::Xor);
        return *this;
    }
 
    HyperSlab& notA(const RegularHyperSlab& sel) {
        selects.emplace_back(sel, Op::NotA);
        return *this;
    }
 
    HyperSlab& notB(const RegularHyperSlab& sel) {
        selects.emplace_back(sel, Op::NotB);
        return *this;
    }
 
    DataSpace apply(const DataSpace& space_) const {
        return apply_impl(space_);
    }
 
  private:
    enum class Op {
        Noop,
        Set,
        Or,
        And,
        Xor,
        NotB,
        NotA,
        Append,
        Prepend,
        Invalid,
        None,
    };
 
    H5S_seloper_t convert(Op op) const {
        switch (op) {
        case Op::Noop:
            return H5S_SELECT_NOOP;
        case Op::Set:
            return H5S_SELECT_SET;
        case Op::Or:
            return H5S_SELECT_OR;
        case Op::And:
            return H5S_SELECT_AND;
        case Op::Xor:
            return H5S_SELECT_XOR;
        case Op::NotB:
            return H5S_SELECT_NOTB;
        case Op::NotA:
            return H5S_SELECT_NOTA;
        case Op::Append:
            return H5S_SELECT_APPEND;
        case Op::Prepend:
            return H5S_SELECT_PREPEND;
        case Op::Invalid:
            return H5S_SELECT_INVALID;
        default:
            throw DataSpaceException("Invalid HyperSlab operation.");
        }
    }
 
    struct Select_: public RegularHyperSlab {
        Select_(const RegularHyperSlab& sel, Op op_)
            : RegularHyperSlab(sel)
            , op(op_) {}
 
        Op op;
    };
 
    std::vector<Select_> selects;
 
  protected:
    DataSpace select_none(const DataSpace& outer_space) const {
        auto space = outer_space.clone();
        detail::h5s_select_none(space.getId());
        return space;
    }
 
    void select_hyperslab(DataSpace& space, const Select_& sel) const {
        detail::h5s_select_hyperslab(space.getId(),
                                     convert(sel.op),
                                     sel.offset.empty() ? nullptr : sel.offset.data(),
                                     sel.stride.empty() ? nullptr : sel.stride.data(),
                                     sel.count.empty() ? nullptr : sel.count.data(),
                                     sel.block.empty() ? nullptr : sel.block.data());
    }
 
#if H5_VERSION_GE(1, 10, 6)
    size_t detect_streak(Select_ const* begin, Select_ const* end, Op op) const {
        assert(op == Op::Or);
        auto const* it =
            std::find_if(begin, end, [op](const Select_& sel) { return sel.op != op; });
        return static_cast<size_t>(it - begin);
    }
 
    DataSpace combine_selections(const DataSpace& left_space,
                                 Op op,
                                 const DataSpace& right_space) const {
        assert(op == Op::Or);
 
        auto left_type = detail::h5s_get_select_type(left_space.getId());
        auto right_type = detail::h5s_get_select_type(right_space.getId());
 
        // Since HDF5 doesn't allow `combine_selections` with a None
        // selection, we need to avoid the issue:
        if (left_type == H5S_SEL_NONE) {
            return right_space;
        } else if (right_type == H5S_SEL_NONE) {
            return left_space;
        } else if (left_type == H5S_SEL_ALL) {
            return left_space;
        } else if (right_type == H5S_SEL_ALL) {
            return right_space;
        } else {
            return detail::make_data_space(
                detail::h5s_combine_select(left_space.getId(), convert(op), right_space.getId()));
        }
    }
 
    DataSpace reduce_streak(const DataSpace& outer_space,
                            Select_ const* begin,
                            Select_ const* end,
                            Op op) const {
        assert(op == Op::Or);
 
        if (begin == end) {
            throw std::runtime_error("Broken logic in 'DataSpace::reduce_streak'.");
        }
 
        std::ptrdiff_t distance = end - begin;
        if (distance == 1) {
            auto space = select_none(outer_space);
            select_hyperslab(space, *begin);
            return space;
        }
 
        Select_ const* mid = begin + distance / 2;
        auto right_space = reduce_streak(outer_space, begin, mid, op);
        auto left_space = reduce_streak(outer_space, mid, end, op);
 
        return combine_selections(left_space, op, right_space);
    }
 
    DataSpace apply_impl(const DataSpace& space_) const {
        auto space = space_.clone();
        auto n_selects = selects.size();
        for (size_t i = 0; i < n_selects; ++i) {
            auto const* const begin = selects.data() + i;
            auto const* const end = selects.data() + n_selects;
 
            auto n_ors = detect_streak(begin, end, Op::Or);
 
            if (n_ors > 1) {
                auto right_space = reduce_streak(space_, begin, begin + n_ors, Op::Or);
                space = combine_selections(space, Op::Or, right_space);
                i += n_ors - 1;
            } else if (selects[i].op == Op::None) {
                detail::h5s_select_none(space.getId());
            } else {
                select_hyperslab(space, selects[i]);
            }
        }
        return space;
    }
#else
    DataSpace apply_impl(const DataSpace& space_) const {
        auto space = space_.clone();
        for (const auto& sel: selects) {
            if (sel.op == Op::None) {
                detail::h5s_select_none(space.getId());
            } else {
                select_hyperslab(space, sel);
            }
        }
        return space;
    }
#endif
};
 
class ProductSet {
  public:
    template <class... Slices>
    explicit ProductSet(const Slices&... slices);
 
  private:
    HyperSlab slab;
    std::vector<size_t> shape;
 
    template <typename Derivate>
    friend class SliceTraits;
};
 
template <typename Derivate>
class SliceTraits {
  public:
    template <class Impl>
    Selection select(const HyperSlabInterface<Impl>& hyper_slab) const;
 
    Selection select(const HyperSlab& hyper_slab, const DataSpace& memspace) const;
 
    Selection select(const std::vector<size_t>& offset,
                     const std::vector<size_t>& count,
                     const std::vector<size_t>& stride = {},
                     const std::vector<size_t>& block = {}) const;
 
    Selection select(const std::vector<size_t>& columns) const;
 
    Selection select(const ElementSet& elements) const;
 
    Selection select(const ProductSet& product_set) const;
 
    template <typename T>
    T read(const DataTransferProps& xfer_props = DataTransferProps()) const;
 
    template <typename T>
    void read(T& array, const DataTransferProps& xfer_props = DataTransferProps()) const;
 
    template <typename T>
    void read_raw(T* array,
                  const DataType& mem_datatype,
                  const DataTransferProps& xfer_props = DataTransferProps()) const;
 
    template <typename T>
    void read_raw(T* array, const DataTransferProps& xfer_props = DataTransferProps()) const;
 
 
    template <typename T>
    void write(const T& buffer, const DataTransferProps& xfer_props = DataTransferProps());
 
    template <typename T>
    void write_raw(const T* buffer,
                   const DataType& mem_datatype,
                   const DataTransferProps& xfer_props = DataTransferProps());
 
    template <typename T>
    void write_raw(const T* buffer, const DataTransferProps& xfer_props = DataTransferProps());
 
    Selection squeezeMemSpace(const std::vector<size_t>& axes) const;
 
    Selection reshapeMemSpace(const std::vector<size_t>& dims) const;
};
 
}  // namespace HighFive