vector.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_STL_VECTOR_HPP
#define LIBH5_STL_VECTOR_HPP
 
#include "./string.hpp"
#include "../complex.hpp"
#include "../format.hpp"
#include "../group.hpp"
#include "../scalar.hpp"
#include "../utils.hpp"
 
#include <string>
#include <vector>
#include <type_traits>
 
namespace h5 {
 
  namespace array_interface {
 
    template <typename T>
    array_view array_view_from_vector(std::vector<T> const &v) {
      array_view res{hdf5_type<T>(), (void *)v.data(), 1, is_complex_v<std::decay_t<T>>};
      res.slab.count[0]   = v.size();
      res.parent_shape[0] = v.size();
      return res;
    }
 
  } // namespace array_interface
 
  // Specialization of h5::hdf5_format_impl for std::vector<std::string>.
  H5_SPECIALIZE_FORMAT2(std::vector<std::string>, vector<string>);
 
  template <typename T>
  struct hdf5_format_impl<std::vector<T>> {
    static std::string invoke() { return "List"; }
  };
 
  char_buf to_char_buf(std::vector<std::string> const &v);
 
  char_buf to_char_buf(std::vector<std::vector<std::string>> const &v);
 
  void from_char_buf(char_buf const &cb, std::vector<std::string> &v);
 
  void from_char_buf(char_buf const &cb, std::vector<std::vector<std::string>> &v);
 
  template <typename T>
  void h5_write(group g, std::string const &name, std::vector<T> const &v) {
    if constexpr (std::is_arithmetic_v<T> or is_complex_v<T>) {
      // vector of arithmetic/complex types
      array_interface::write(g, name, array_interface::array_view_from_vector(v), true);
    } else if constexpr (std::is_same_v<T, std::string> or std::is_same_v<T, std::vector<std::string>>) {
      // vector (of vectors) of strings
      h5_write(g, name, to_char_buf(v));
    } else {
      // vector of generic types
      auto gr = g.create_group(name);
      write_hdf5_format(gr, v);
      for (int i = 0; i < v.size(); ++i) h5_write(gr, std::to_string(i), v[i]);
    }
  }
 
  template <typename T>
  void h5_read(group g, std::string name, std::vector<T> &v) {
    // throw exception if no link with the given name exists
    if (not g.has_key(name)) throw make_runtime_error("Error in h5_read: Dataset/Subgroup with name ", name, " does not exist");
 
    if (g.has_subgroup(name)) {
      // vector of generic type
      auto g2 = g.open_group(name);
      v.resize(g2.get_all_dataset_names().size() + g2.get_all_subgroup_names().size());
      for (int i = 0; i < v.size(); ++i) { h5_read(g2, std::to_string(i), v[i]); }
    } else {
      if constexpr (std::is_arithmetic_v<T> or is_complex_v<T>) {
        // vector of arithmetic/complex types
        auto ds_info = array_interface::get_dataset_info(g, name);
        if (ds_info.rank() != 1 + is_complex_v<T>)
          throw make_runtime_error("Error in h5_read: Reading a vector from an array of rank ", ds_info.rank(), " is not allowed");
        v.resize(ds_info.lengths[0]);
        array_interface::read(g, name, array_interface::array_view_from_vector(v));
      } else if constexpr (std::is_same_v<T, std::string> or std::is_same_v<T, std::vector<std::string>>) {
        // vector of strings or vector of vector of strings
        char_buf cb;
        h5_read(g, name, cb);
        from_char_buf(cb, v);
      } else {
        // unsupported type
        throw make_runtime_error("Error in h5_read: HDF5 datatype not supported for reading into a std::vector");
      }
    }
  }
 
  void h5_write_attribute(object obj, std::string const &name, std::vector<std::vector<std::string>> const &v);
 
  void h5_read_attribute(object obj, std::string const &name, std::vector<std::vector<std::string>> &v);
 
  void h5_write_attribute(object obj, std::string const &name, std::vector<std::string> const &v);
 
  void h5_read_attribute(object obj, std::string const &name, std::vector<std::string> &v);
 
} // namespace h5
 
#endif // LIBH5_STL_VECTOR_HPP