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 "../H5PropertyList.hpp"
#include "h5s_wrapper.hpp"
 
namespace HighFive {
 
class ElementSet {
  public:
    explicit ElementSet(std::initializer_list<std::size_t> list);
    explicit 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;
};
 
namespace detail {
 
template <class To, class From>
inline std::vector<To> convertSizeVector(const std::vector<From>& from) {
    std::vector<To> to(from.size());
    std::copy(from.cbegin(), from.cend(), to.begin());
 
    return to;
}
}  // namespace detail
 
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);
}
 
struct RegularHyperSlab {
    RegularHyperSlab() = default;
 
    RegularHyperSlab(std::vector<size_t> offset_,
                     std::vector<size_t> count_ = {},
                     std::vector<size_t> stride_ = {},
                     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 = offset_;
        slab.count = count_;
        slab.stride = stride_;
        slab.block = 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:
    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 {
        auto space = space_.clone();
        for (const auto& sel: selects) {
            if (sel.op == Op::None) {
                detail::h5s_select_none(space.getId());
            } else {
                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());
            }
        }
        return 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;
};
 
template <typename Derivate>
class SliceTraits {
  public:
    Selection select(const HyperSlab& hyperslab) const;
 
    Selection select(const HyperSlab& hyperslab, 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;
 
    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(T* array,
              const DataType& dtype,
              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& dtype,
                  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());
};
 
}  // namespace HighFive