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::ranges::transform(count, block, 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 const *view_shape);

  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