array_interface.hpp

Go to the documentation of this file.

// Copyright (c) 2019-2024 Simons Foundation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0.txt
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Authors: Thomas Hahn, Olivier Parcollet, Nils Wentzell
 
#ifndef LIBH5_ARRAY_INTERFACE_HPP
#define LIBH5_ARRAY_INTERFACE_HPP
 
#include "./group.hpp"
#include "./object.hpp"
 
#include <algorithm>
#include <numeric>
#include <string>
#include <utility>
 
namespace h5::array_interface {
 
  struct dataset_info {
    v_t lengths;
 
    datatype ty;
 
    bool has_complex_attribute;
 
    [[nodiscard]] int rank() const { return static_cast<int>(lengths.size()); }
  };
 
  struct hyperslab {
    v_t offset;
 
    v_t stride;
 
    v_t count;
 
    v_t block;
 
    hyperslab(int rank, bool is_complex)
       : offset(rank + is_complex, 0), stride(rank + is_complex, 1), count(rank + is_complex, 0), block(rank + is_complex, 1) {
      if (is_complex) {
        stride[rank] = 1;
        count[rank]  = 2;
      }
    }
 
    hyperslab() = default;
 
    [[nodiscard]] int rank() const { return static_cast<int>(count.size()); }
 
    [[nodiscard]] bool empty() const { return count.empty(); }
 
    [[nodiscard]] v_t shape() const {
      v_t shape(rank());
      std::transform(count.begin(), count.end(), block.begin(), shape.begin(), std::multiplies<>());
      return shape;
    }
 
    [[nodiscard]] auto size() const {
      auto sh = shape();
      return std::accumulate(sh.begin(), sh.end(), (hsize_t)1, std::multiplies<>());
    }
  };
 
  struct array_view {
    datatype ty;
 
    void *start;
 
    v_t parent_shape;
 
    hyperslab slab;
 
    bool is_complex;
 
    array_view(datatype ty, void *start, int rank, bool is_complex)
       : ty(std::move(ty)), start(start), parent_shape(rank + is_complex), slab(rank, is_complex), is_complex(is_complex) {
      if (is_complex) parent_shape[rank] = 2;
    }
 
    [[nodiscard]] int rank() const { return slab.rank(); }
  };
 
  std::pair<v_t, v_t> get_parent_shape_and_h5_strides(long const *np_strides, int rank, long view_size);
 
  dataset_info get_dataset_info(dataset ds);
 
  dataset_info get_dataset_info(group g, std::string const &name);
 
  void write(group g, std::string const &name, array_view const &v, bool compress);
 
  void write_slice(group g, std::string const &name, array_view const &v, hyperslab sl);
 
  void write_attribute(object obj, std::string const &name, array_view v);
 
  void read(group g, std::string const &name, array_view v, hyperslab sl = {});
 
  void read_attribute(object obj, std::string const &name, array_view v);
 
} // namespace h5::array_interface
 
#endif // LIBH5_ARRAY_INTERFACE_HPP