RestartableDataReader.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

#include "RestartableDataIO.h"

#include "RestartableData.h"
#include "InputStream.h"

#include <sstream>
#include <utility>

class RestartableDataReader : public RestartableDataIO
{
public:
  RestartableDataReader(MooseApp & app, RestartableDataMap & data, const bool force = false);
  RestartableDataReader(MooseApp & app,
                        std::vector<RestartableDataMap> & data,
                        const bool force = false);

  struct InputStreams
  {
    std::unique_ptr<InputStream> header;
    std::unique_ptr<InputStream> data;
  };

  void setInput(std::unique_ptr<std::stringstream> header_stream,
                std::unique_ptr<std::stringstream> data_stream);
  void setInput(const std::filesystem::path & folder_base);

  bool isRestoring() const { return _streams.data != nullptr; }

  InputStreams clear();

  void restore(const DataNames & filter_names = {});

  template <typename T, typename... Args>
  T & restoreData(const std::string & data_name,
                  const THREAD_ID tid = 0,
                  void * const context = nullptr,
                  Args &&... args);

  /*
   * Enable/Disable errors to allow meta data to be created/loaded on different number or
   * processors
   *
   * See LoadSurrogateModelAction for use case
   */
  void setErrorOnLoadWithDifferentNumberOfProcessors(bool value)
  {
    _error_on_different_number_of_processors = value;
  }

  static bool isAvailable(const std::filesystem::path & folder_base);

  template <typename T>
  bool hasData(const std::string & data_name, const THREAD_ID tid = 0) const
  {
    return hasData(data_name, typeid(T), tid);
  }

private:
  struct HeaderEntry
  {
    std::streampos position;
    std::size_t size;
    std::size_t type_hash_code;
    std::string type;
    bool has_context;
  };

  bool
  hasData(const std::string & data_name, const std::type_info & type, const THREAD_ID tid) const;

  std::vector<std::unordered_map<std::string, HeaderEntry>>
  readHeader(InputStream & header_input) const;

  void deserializeValue(InputStream & data_input,
                        RestartableDataValue & value,
                        const HeaderEntry & header_entry) const;

  void requireRestoring() const;

  const HeaderEntry * queryHeader(const std::string & data_name, const THREAD_ID tid) const;
  const HeaderEntry & getHeader(const std::string & data_name, const THREAD_ID tid) const;

  bool isSameType(const HeaderEntry & header_entry, const std::type_info & type) const;

  RestartableDataValue & restoreData(const std::string & data_name,
                                     std::unique_ptr<RestartableDataValue> value,
                                     const THREAD_ID tid);
  InputStreams _streams;

  std::vector<std::unordered_map<std::string, HeaderEntry>> _header;

  bool _is_restoring;

  bool _error_on_different_number_of_processors;

  const bool _force;
};

template <typename T, typename... Args>
T &
RestartableDataReader::restoreData(const std::string & data_name,
                                   const THREAD_ID tid /* = 0 */,
                                   void * const context /* = nullptr */,
                                   Args &&... args)
{
  std::unique_ptr<RestartableDataValue> T_data =
      std::make_unique<RestartableData<T>>(data_name, context, std::forward<Args>(args)...);
  auto & value = restoreData(data_name, std::move(T_data), tid);
  auto T_value = dynamic_cast<RestartableData<T> *>(&value);
  mooseAssert(T_value, "Bad cast");
  return T_value->set();
}