RestartableData.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
 
// MOOSE includes
#include "DataIO.h"
#include "MooseUtils.h"
 
// C++ includes
#include <memory>
#include <vector>
#include <unordered_set>
#include <unordered_map>
 
#include "nlohmann/json.h"
 
class RestartableDataReader;
class RestartableDataWriter;
class MooseApp;
 
class RestartableDataValue
{
public:
  RestartableDataValue(const std::string & name, void * const context);
 
  virtual ~RestartableDataValue() = default;
 
  virtual std::string type() const = 0;
 
  virtual const std::type_info & typeId() const = 0;
 
  const std::string & name() const { return _name; }
 
  void * context() { return _context; }
 
  bool hasContext() const { return _context != nullptr; }
 
  class SetDeclaredKey
  {
    friend class MooseApp;
    SetDeclaredKey() {}
    SetDeclaredKey(const SetDeclaredKey &) {}
  };
 
  bool declared() const { return _declared; }
 
  void setDeclared(const SetDeclaredKey);
 
  bool loaded() const { return _loaded; }
 
  class SetNotLoadedKey
  {
    friend class RestartableDataReader;
    SetNotLoadedKey() {}
    SetNotLoadedKey(const SetNotLoadedKey &) {}
  };
 
  void setNotLoaded(const SetNotLoadedKey) { _loaded = false; }
 
  bool stored() const { return _stored; }
 
  class SetNotStoredKey
  {
    friend class RestartableDataWriter;
    SetNotStoredKey() {}
    SetNotStoredKey(const SetNotStoredKey &) {}
  };
 
  void setNotStored(const SetNotStoredKey) { _stored = false; }
 
  void store(std::ostream & stream);
  void load(std::istream & stream);
 
  virtual void storeInternal(std::ostream & stream) = 0;
  virtual void loadInternal(std::istream & stream) = 0;
 
  virtual bool hasStoreJSON() const = 0;
 
  struct StoreJSONParams
  {
    StoreJSONParams() {} // fixes a compiler bug with default constructors
    bool value = true;
    bool type = true;
    bool name = false;
    bool declared = false;
    bool loaded = false;
    bool stored = false;
    bool has_context = false;
  };
 
  void store(nlohmann::json & json, const StoreJSONParams & params = StoreJSONParams{}) const;
 
protected:
  virtual void storeJSONValue(nlohmann::json & json) const = 0;
 
  const std::string _name;
 
  void * const _context;
 
private:
  bool _declared;
 
  bool _loaded;
 
  bool _stored;
};
 
template <typename T>
class RestartableData : public RestartableDataValue
{
public:
  static constexpr bool has_store_json = std::is_constructible_v<nlohmann::json, T>;
 
  template <typename... Params>
  RestartableData(const std::string & name, void * const context, Params &&... args)
    : RestartableDataValue(name, context),
      _value(std::make_unique<T>(std::forward<Params>(args)...))
  {
  }
 
  const T & get() const;
 
  T & set();
 
  void reset();
 
  virtual std::string type() const override final;
 
  virtual const std::type_info & typeId() const override final { return typeid(T); }
 
  virtual bool hasStoreJSON() const override final { return has_store_json; }
 
protected:
  virtual void storeInternal(std::ostream & stream) override;
 
  virtual void loadInternal(std::istream & stream) override;
 
  virtual void storeJSONValue(nlohmann::json & json) const override final;
 
private:
  std::unique_ptr<T> _value;
};
 
// ------------------------------------------------------------
// RestartableData<> class inline methods
template <typename T>
inline const T &
RestartableData<T>::get() const
{
  mooseAssert(_value, "Not valid");
  return *_value;
}
 
template <typename T>
inline T &
RestartableData<T>::set()
{
  mooseAssert(_value, "Not valid");
  return *_value;
}
 
template <typename T>
inline void
RestartableData<T>::reset()
{
  mooseAssert(_value, "Not valid"); // shouldn't really call this twice
  _value.reset();
}
 
template <typename T>
inline std::string
RestartableData<T>::type() const
{
  return MooseUtils::prettyCppType<T>();
}
 
template <typename T>
inline void
RestartableData<T>::storeInternal(std::ostream & stream)
{
  storeHelper(stream, set(), _context);
}
 
template <typename T>
inline void
RestartableData<T>::loadInternal(std::istream & stream)
{
  loadHelper(stream, set(), _context);
}
 
template <typename T>
inline void
RestartableData<T>::storeJSONValue(nlohmann::json & json) const
{
  if constexpr (RestartableData<T>::has_store_json)
    nlohmann::to_json(json, get());
  else
    mooseAssert(false, "Should not be called");
}
 
using DataNames = std::unordered_set<std::string>;