DistrArrayFile.h

#ifndef LINEARALGEBRA_SRC_MOLPRO_LINALG_ARRAY_DISTRARRAYFILE_H
#define LINEARALGEBRA_SRC_MOLPRO_LINALG_ARRAY_DISTRARRAYFILE_H
 
#include "util/fs.h"
#include <molpro/linalg/array/DistrArrayDisk.h>
#include <molpro/mpi.h>
#include <fstream>
#include <memory>
 
namespace molpro::linalg::array {
class DistrArrayFile : public DistrArrayDisk {
 
private:
  fs::path m_directory;
  fs::path m_filename;
  mutable std::unique_ptr<std::fstream>
      m_stream; // use a pointer just in case the implementation of std::fstream is not movable
  mutable std::mutex m_mutex;
  [[nodiscard]] std::tuple<index_type, index_type, index_type>
  local_bounds() const; 
public:
  DistrArrayFile() = delete;
  DistrArrayFile(const DistrArrayFile& source);
  DistrArrayFile(DistrArrayFile&& source);
  explicit DistrArrayFile(size_t dimension, MPI_Comm comm = molpro::mpi::comm_global(),
                          const std::string& directory = ".");
  explicit DistrArrayFile(std::unique_ptr<Distribution> distribution,
                          MPI_Comm comm = molpro::mpi::comm_global(),
                          const std::string& directory = ".");
  explicit DistrArrayFile(const DistrArray& source);
 
  DistrArrayFile& operator=(const DistrArrayFile& source) = delete;
  DistrArrayFile& operator=(DistrArrayFile&& source) noexcept;
 
  static DistrArrayFile CreateTempCopy(const DistrArray& source, const std::string& directory = "");
  static DistrArrayFile CreateTempCopy(Span<const value_type> source, MPI_Comm comm,
                                       const std::string& directory = ".");
 
  friend void swap(DistrArrayFile& x, DistrArrayFile& y) noexcept;
 
  ~DistrArrayFile() override;
 
  [[nodiscard]] std::string file_directory() const override { return m_directory.string(); }
 
  bool compatible(const DistrArrayFile& source) const;
 
  void erase() override {}
  value_type at(index_type ind) const override;
  void set(index_type ind, value_type val) override;
  void get(index_type lo, index_type hi, value_type* buf) const override;
  std::vector<value_type> get(index_type lo, index_type hi) const override;
  void put(index_type lo, index_type hi, const value_type* data) override;
  void acc(index_type lo, index_type hi, const value_type* data) override;
  std::vector<value_type> gather(const std::vector<index_type>& indices) const override;
  void scatter(const std::vector<index_type>& indices, const std::vector<value_type>& data) override;
  void scatter_acc(std::vector<index_type>& indices, const std::vector<value_type>& data) override;
  std::vector<value_type> vec() const override;
};
 
} // namespace molpro::linalg::array
 
#endif // LINEARALGEBRA_SRC_MOLPRO_LINALG_ARRAY_DISTRARRAYFILE_H