DataIO.h File Reference

Go to the source code of this file.

Classes
class	libMesh::DenseMatrix< T >
class	libMesh::DenseVector< T >
class	libMesh::VectorValue< T >
class	libMesh::TensorValue< T >
class	libMesh::Parallel::Packing< std::basic_string< T > >

Namespaces
	libMesh
	The following methods are specializations for using the libMesh::Parallel::packed_range_* routines for std::strings.
	libMesh::Parallel

Functions
template<typename P >
void	storeHelper (std::ostream &stream, P &data, void *context)
	Scalar helper routine. More...
template<typename P >
void	storeHelper (std::ostream &stream, std::vector< P > &data, void *context)
	Vector helper routine. More...
template<typename P >
void	storeHelper (std::ostream &stream, std::shared_ptr< P > &data, void *context)
	Shared pointer helper routine. More...
template<typename P >
void	storeHelper (std::ostream &stream, std::unique_ptr< P > &data, void *context)
	Unique pointer helper routine. More...
template<typename P >
void	storeHelper (std::ostream &stream, std::set< P > &data, void *context)
	Set helper routine. More...
template<typename P , typename Q >
void	storeHelper (std::ostream &stream, std::map< P, Q > &data, void *context)
	Map helper routine. More...
template<typename P , typename Q >
void	storeHelper (std::ostream &stream, std::unordered_map< P, Q > &data, void *context)
	Unordered_map helper routine. More...
template<typename P >
void	storeHelper (std::ostream &stream, std::optional< P > &data, void *context)
	Optional helper routine. More...
template<typename P , typename Q >
void	storeHelper (std::ostream &stream, HashMap< P, Q > &data, void *context)
	HashMap helper routine. More...
template<typename T >
void	storeHelper (std::ostream &stream, UniqueStorage< T > &data, void *context)
	UniqueStorage helper routine. More...
template<typename P >
void	loadHelper (std::istream &stream, P &data, void *context)
	Scalar helper routine. More...
template<typename P >
void	loadHelper (std::istream &stream, std::vector< P > &data, void *context)
	Vector helper routine. More...
template<typename P >
void	loadHelper (std::istream &stream, std::shared_ptr< P > &data, void *context)
	Shared Pointer helper routine. More...
template<typename P >
void	loadHelper (std::istream &stream, std::unique_ptr< P > &data, void *context)
	Unique Pointer helper routine. More...
template<typename P >
void	loadHelper (std::istream &stream, std::set< P > &data, void *context)
	Set helper routine. More...
template<typename P , typename Q >
void	loadHelper (std::istream &stream, std::map< P, Q > &data, void *context)
	Map helper routine. More...
template<typename P , typename Q >
void	loadHelper (std::istream &stream, std::unordered_map< P, Q > &data, void *context)
	Unordered_map helper routine. More...
template<typename P >
void	loadHelper (std::istream &stream, std::optional< P > &data, void *context)
	Optional helper routine. More...
template<typename P , typename Q >
void	loadHelper (std::istream &stream, HashMap< P, Q > &data, void *context)
	Hashmap helper routine. More...
template<typename T >
void	loadHelper (std::istream &stream, UniqueStorage< T > &data, void *context)
	UniqueStorage helper routine. More...
template<typename T >
void	dataStore (std::ostream &stream, T &v, void *)
template<typename T >
void	dataStore (std::ostream &, T *&, void *)
void	dataStore (std::ostream &stream, Point &p, void *context)
template<typename T , typename U >
void	dataStore (std::ostream &stream, std::pair< T, U > &p, void *context)
template<typename T >
void	dataStore (std::ostream &stream, std::vector< T > &v, void *context)
template<typename T >
void	dataStore (std::ostream &stream, std::shared_ptr< T > &v, void *context)
template<typename T >
void	dataStore (std::ostream &stream, std::unique_ptr< T > &v, void *context)
template<typename T >
void	dataStore (std::ostream &stream, std::set< T > &s, void *context)
template<typename T >
void	dataStore (std::ostream &stream, std::list< T > &l, void *context)
template<typename T >
void	dataStore (std::ostream &stream, std::deque< T > &l, void *context)
template<typename T , typename U >
void	dataStore (std::ostream &stream, std::map< T, U > &m, void *context)
template<typename T , typename U >
void	dataStore (std::ostream &stream, std::unordered_map< T, U > &m, void *context)
template<typename T >
void	dataStore (std::ostream &stream, std::unordered_set< T > &s, void *context)
template<typename T >
void	dataStore (std::ostream &stream, std::optional< T > &m, void *context)
template<typename T , typename U >
void	dataStore (std::ostream &stream, HashMap< T, U > &m, void *context)
template<typename T , int Rows, int Cols>
void	dataStore (std::ostream &stream, Eigen::Matrix< T, Rows, Cols > &v, void *context)
template<>
void	dataStore (std::ostream &stream, Real &v, void *context)
template<>
void	dataStore (std::ostream &stream, std::string &v, void *context)
template<>
void	dataStore (std::ostream &stream, VariableName &v, void *context)
template<>
void	dataStore (std::ostream &stream, UserObjectName &v, void *context)
template<>
void	dataStore (std::ostream &stream, bool &v, void *context)
template<>
void	dataStore (std::ostream &stream, std::vector< bool > &v, void *context)
template<>
void	dataStore (std::ostream &stream, const Elem *&e, void *context)
template<>
void	dataStore (std::ostream &stream, const Node *&n, void *context)
template<>
void	dataStore (std::ostream &stream, Elem *&e, void *context)
template<>
void	dataStore (std::ostream &stream, Node *&n, void *context)
template<>
void	dataStore (std::ostream &stream, std::stringstream &s, void *context)
template<>
void	dataStore (std::ostream &stream, ADReal &dn, void *context)
template<>
void	dataStore (std::ostream &stream, libMesh::Parameters &p, void *context)
template<>
void	dataStore (std::ostream &stream, std::unique_ptr< libMesh::NumericVector< libMesh::Number >> &v, void *context)
	Stores an owned numeric vector. More...
template<std::size_t N>
void	dataStore (std::ostream &stream, std::array< ADReal, N > &dn, void *context)
template<std::size_t N>
void	dataStore (std::ostream &stream, ADReal(&dn)[N], void *context)
template<typename T >
void	dataStore (std::ostream &stream, libMesh::NumericVector< T > &v, void *context)
template<>
void	dataStore (std::ostream &stream, Vec &v, void *context)
template<typename T >
void	dataStore (std::ostream &stream, DenseVector< T > &v, void *context)
template<typename T >
void	dataStore (std::ostream &stream, libMesh::TensorValue< T > &v, void *context)
template<typename T >
void	dataStore (std::ostream &stream, libMesh::DenseMatrix< T > &v, void *context)
template<typename T >
void	dataStore (std::ostream &stream, libMesh::VectorValue< T > &v, void *context)
template<typename T >
void	dataStore (std::ostream &stream, RankTwoTensorTempl< T > &rtt, void *context)
template<typename T >
void	dataStore (std::ostream &stream, RankThreeTensorTempl< T > &rtt, void *context)
template<typename T >
void	dataStore (std::ostream &stream, RankFourTensorTempl< T > &rft, void *context)
template<typename T >
void	dataStore (std::ostream &stream, SymmetricRankTwoTensorTempl< T > &srtt, void *context)
template<typename T >
void	dataStore (std::ostream &stream, SymmetricRankFourTensorTempl< T > &srft, void *context)
template<typename T >
void	dataStore (std::ostream &stream, ColumnMajorMatrixTempl< T > &cmm, void *context)
template<typename T >
void	dataLoad (std::istream &stream, T &v, void *)
template<typename T >
void	dataLoad (std::istream &, T *&, void *)
template<typename T , typename U >
void	dataLoad (std::istream &stream, std::pair< T, U > &p, void *context)
template<typename T >
void	dataLoad (std::istream &stream, std::vector< T > &v, void *context)
template<typename T >
void	dataLoad (std::istream &stream, std::shared_ptr< T > &v, void *context)
template<typename T >
void	dataLoad (std::istream &stream, std::unique_ptr< T > &v, void *context)
template<typename T >
void	dataLoad (std::istream &stream, std::set< T > &s, void *context)
template<typename T >
void	dataLoad (std::istream &stream, std::list< T > &l, void *context)
template<typename T >
void	dataLoad (std::istream &stream, std::deque< T > &l, void *context)
template<typename T , typename U >
void	dataLoad (std::istream &stream, std::map< T, U > &m, void *context)
template<typename T , typename U >
void	dataLoad (std::istream &stream, std::unordered_map< T, U > &m, void *context)
template<typename T >
void	dataLoad (std::istream &stream, std::unordered_set< T > &s, void *context)
template<typename T >
void	dataLoad (std::istream &stream, std::optional< T > &m, void *context)
template<typename T , typename U >
void	dataLoad (std::istream &stream, HashMap< T, U > &m, void *context)
template<typename T , int Rows, int Cols>
void	dataLoad (std::istream &stream, Eigen::Matrix< T, Rows, Cols > &v, void *context)
template<>
void	dataLoad (std::istream &stream, Real &v, void *)
template<>
void	dataLoad (std::istream &stream, std::string &v, void *)
template<>
void	dataLoad (std::istream &stream, VariableName &v, void *)
template<>
void	dataLoad (std::istream &stream, UserObjectName &v, void *)
template<>
void	dataLoad (std::istream &stream, bool &v, void *)
template<>
void	dataLoad (std::istream &stream, std::vector< bool > &v, void *)
template<>
void	dataLoad (std::istream &stream, const Elem *&e, void *context)
template<>
void	dataLoad (std::istream &stream, const Node *&e, void *context)
template<>
void	dataLoad (std::istream &stream, Elem *&e, void *context)
template<>
void	dataLoad (std::istream &stream, Node *&e, void *context)
template<>
void	dataLoad (std::istream &stream, std::stringstream &s, void *context)
template<>
void	dataLoad (std::istream &stream, ADReal &dn, void *context)
template<>
void	dataLoad (std::istream &stream, libMesh::Parameters &p, void *context)
template<>
void	dataLoad (std::istream &stream, std::unique_ptr< libMesh::NumericVector< libMesh::Number >> &v, void *context)
	Loads an owned numeric vector. More...
template<std::size_t N>
void	dataLoad (std::istream &stream, std::array< ADReal, N > &dn, void *context)
template<std::size_t N>
void	dataLoad (std::istream &stream, ADReal(&dn)[N], void *context)
template<typename T >
void	dataLoad (std::istream &stream, libMesh::NumericVector< T > &v, void *context)
template<>
void	dataLoad (std::istream &stream, Vec &v, void *context)
template<typename T >
void	dataLoad (std::istream &stream, DenseVector< T > &v, void *context)
template<typename T >
void	dataLoad (std::istream &stream, libMesh::TensorValue< T > &v, void *context)
template<typename T >
void	dataLoad (std::istream &stream, libMesh::DenseMatrix< T > &v, void *context)
template<typename T >
void	dataLoad (std::istream &stream, libMesh::VectorValue< T > &v, void *context)
template<typename T >
void	dataLoad (std::istream &stream, RankTwoTensorTempl< T > &rtt, void *context)
template<typename T >
void	dataLoad (std::istream &stream, RankThreeTensorTempl< T > &rtt, void *context)
template<typename T >
void	dataLoad (std::istream &stream, RankFourTensorTempl< T > &rft, void *context)
template<typename T >
void	dataLoad (std::istream &stream, SymmetricRankTwoTensorTempl< T > &rtt, void *context)
template<typename T >
void	dataLoad (std::istream &stream, SymmetricRankFourTensorTempl< T > &rft, void *context)
template<typename T >
void	dataLoad (std::istream &stream, ColumnMajorMatrixTempl< T > &cmm, void *context)
void	dataLoad (std::istream &stream, Point &p, void *context)

Function Documentation

dataLoad() [1/44]

template<typename T >

void dataLoad ( std::istream &  stream, T &  v, void *    )

inline

Definition at line 551 of file DataIO.h.

Referenced by dataLoad(), and loadHelper().

{
  stream.read((char *)&v, sizeof(v));
  mooseAssert(!stream.bad(), "Failed to load");
}

dataLoad() [2/44]

template<typename T >

void dataLoad	(	std::istream &	,
		T *&	,
		void *
	)

Definition at line 559 of file DataIO.h.

{
  mooseError("Attempting to load a raw pointer type: \"",
             libMesh::demangle(typeid(T).name()),
             " *\" as restartable data!\nWrite a custom dataLoad() template specialization!\n\n");
}

dataLoad() [3/44]

template<typename T , typename U >

void dataLoad ( std::istream &  stream, std::pair< T, U > &  p, void *  context  )

inline

Definition at line 568 of file DataIO.h.

{
  loadHelper(stream, p.first, context);
  loadHelper(stream, p.second, context);
}

dataLoad() [4/44]

template<typename T >

void dataLoad ( std::istream &  stream, std::vector< T > &  v, void *  context  )

inline

Definition at line 576 of file DataIO.h.

{
  // First read the size of the vector
  unsigned int size = 0;
  dataLoad(stream, size, nullptr);

  v.resize(size);

  for (unsigned int i = 0; i < size; i++)
    loadHelper(stream, v[i], context);
}

dataLoad() [5/44]

template<typename T >

void dataLoad ( std::istream &  stream, std::shared_ptr< T > &  v, void *  context  )

inline

Definition at line 590 of file DataIO.h.

{
  T * tmp = v.get();

  loadHelper(stream, tmp, context);
}

dataLoad() [6/44]

template<typename T >

void dataLoad ( std::istream &  stream, std::unique_ptr< T > &  v, void *  context  )

inline

Definition at line 599 of file DataIO.h.

{
  T * tmp = v.get();

  loadHelper(stream, tmp, context);
}

dataLoad() [7/44]

template<typename T >

void dataLoad ( std::istream &  stream, std::set< T > &  s, void *  context  )

inline

Definition at line 608 of file DataIO.h.

{
  // First read the size of the set
  unsigned int size = 0;
  dataLoad(stream, size, nullptr);

  for (unsigned int i = 0; i < size; i++)
  {
    T data;
    loadHelper(stream, data, context);
    s.insert(std::move(data));
  }
}

dataLoad() [8/44]

template<typename T >

void dataLoad ( std::istream &  stream, std::list< T > &  l, void *  context  )

inline

Definition at line 624 of file DataIO.h.

{
  // First read the size of the set
  unsigned int size = 0;
  dataLoad(stream, size, nullptr);

  for (unsigned int i = 0; i < size; i++)
  {
    T data;
    loadHelper(stream, data, context);
    l.push_back(std::move(data));
  }
}

dataLoad() [9/44]

template<typename T >

void dataLoad ( std::istream &  stream, std::deque< T > &  l, void *  context  )

inline

Definition at line 640 of file DataIO.h.

{
  // First read the size of the container
  unsigned int size = 0;
  dataLoad(stream, size, nullptr);

  for (unsigned int i = 0; i < size; i++)
  {
    T data;
    loadHelper(stream, data, context);
    l.push_back(std::move(data));
  }
}

dataLoad() [10/44]

template<typename T , typename U >

void dataLoad ( std::istream &  stream, std::map< T, U > &  m, void *  context  )

inline

Definition at line 656 of file DataIO.h.

{
  m.clear();

  // First read the size of the map
  unsigned int size = 0;
  dataLoad(stream, size, nullptr);

  for (unsigned int i = 0; i < size; i++)
  {
    T key;
    loadHelper(stream, key, context);

    U & value = m[key];
    loadHelper(stream, value, context);
  }
}

dataLoad() [11/44]

template<typename T , typename U >

void dataLoad ( std::istream &  stream, std::unordered_map< T, U > &  m, void *  context  )

inline

Definition at line 676 of file DataIO.h.

{
  m.clear();

  // First read the size of the map
  unsigned int size = 0;
  dataLoad(stream, size, nullptr);

  for (unsigned int i = 0; i < size; i++)
  {
    T key;
    loadHelper(stream, key, context);

    U & value = m[key];
    loadHelper(stream, value, context);
  }
}

dataLoad() [12/44]

template<typename T >

void dataLoad ( std::istream &  stream, std::unordered_set< T > &  s, void *  context  )

inline

Definition at line 696 of file DataIO.h.

{
  s.clear();

  // First read the size of the set
  std::size_t size = 0;
  dataLoad(stream, size, nullptr);
  s.reserve(size);

  for (std::size_t i = 0; i < size; i++)
  {
    T element;
    dataLoad(stream, element, context);
    s.insert(element);
  }
}

dataLoad() [13/44]

template<typename T >

void dataLoad ( std::istream &  stream, std::optional< T > &  m, void *  context  )

inline

Definition at line 715 of file DataIO.h.

{
  bool has_value;
  dataLoad(stream, has_value, nullptr);

  if (has_value)
  {
    m = T{};
    loadHelper(stream, *m, context);
  }
  else
    m.reset();
}

dataLoad() [14/44]

template<typename T , typename U >

void dataLoad ( std::istream &  stream, HashMap< T, U > &  m, void *  context  )

inline

Definition at line 731 of file DataIO.h.

{
  // First read the size of the map
  unsigned int size = 0;
  dataLoad(stream, size, nullptr);

  for (unsigned int i = 0; i < size; i++)
  {
    T key;
    loadHelper(stream, key, context);

    U & value = m[key];
    loadHelper(stream, value, context);
  }
}

dataLoad() [15/44]

template<typename T , int Rows, int Cols>

void dataLoad	(	std::istream &	stream,
		Eigen::Matrix< T, Rows, Cols > &	v,
		void *	context
	)

Definition at line 749 of file DataIO.h.

{
  unsigned int m = 0;
  dataLoad(stream, m, context);
  unsigned int n = 0;
  dataLoad(stream, n, context);
  v.resize(m, n);
  for (const auto i : make_range(m))
    for (const auto j : make_range(n))
    {
      T r{};
      dataLoad(stream, r, context);
      v(i, j) = r;
    }
}

dataLoad() [16/44]

template<>

void dataLoad	(	std::istream &	stream,
		Real &	v,
		void *
	)

Definition at line 343 of file DataIO.C.

Referenced by dataLoad().

{
  stream.read((char *)&v, sizeof(v));
}

dataLoad() [17/44]

template<>

void dataLoad	(	std::istream &	stream,
		std::string &	v,
		void *
	)

Definition at line 350 of file DataIO.C.

{
  // Read the size of the string
  unsigned int size = 0;
  stream.read((char *)&size, sizeof(size));

  // Resize the string data
  v.resize(size);

  // Read the string
  stream.read(&v[0], sizeof(char) * size);
}

dataLoad() [18/44]

template<>

void dataLoad	(	std::istream &	stream,
		VariableName &	v,
		void *
	)

Definition at line 365 of file DataIO.C.

{
  auto & name = static_cast<std::string &>(v);
  dataLoad(stream, name, context);
}

dataLoad() [19/44]

template<>

void dataLoad	(	std::istream &	stream,
		UserObjectName &	v,
		void *
	)

Definition at line 373 of file DataIO.C.

{
  auto & name = static_cast<std::string &>(v);
  dataLoad(stream, name, context);
}

dataLoad() [20/44]

template<>

void dataLoad	(	std::istream &	stream,
		bool &	v,
		void *
	)

Definition at line 381 of file DataIO.C.

{
  stream.read((char *)&v, sizeof(v));
}

dataLoad() [21/44]

template<>

void dataLoad	(	std::istream &	stream,
		std::vector< bool > &	v,
		void *
	)

Definition at line 388 of file DataIO.C.

{
  for (bool b : v)
    dataLoad(stream, b, context);
}

dataLoad() [22/44]

template<>

void dataLoad	(	std::istream &	stream,
		const Elem *&	e,
		void *	context
	)

dataLoad() [23/44]

template<>

void dataLoad	(	std::istream &	stream,
		const Node *&	e,
		void *	context
	)

dataLoad() [24/44]

template<>

void dataLoad	(	std::istream &	stream,
		Elem *&	e,
		void *	context
	)

dataLoad() [25/44]

template<>

void dataLoad	(	std::istream &	stream,
		Node *&	e,
		void *	context
	)

dataLoad() [26/44]

template<>

void dataLoad	(	std::istream &	stream,
		std::stringstream &	s,
		void *	context
	)

Definition at line 497 of file DataIO.C.

{
  size_t s_size = 0;
  stream.read((char *)&s_size, sizeof(s_size));

  std::unique_ptr<char[]> s_s = std::make_unique<char[]>(s_size);
  stream.read(s_s.get(), s_size);

  // Clear the stringstream before loading new data into it.
  s.str(std::string());
  s.write(s_s.get(), s_size);
}

dataLoad() [27/44]

template<>

void dataLoad	(	std::istream &	stream,
		ADReal &	dn,
		void *	context
	)

Definition at line 396 of file DataIO.C.

{
  dataLoad(stream, dn.value(), context);

  if (ADReal::do_derivatives)
  {
    auto & derivatives = dn.derivatives();
    std::size_t size = 0;
    stream.read((char *)&size, sizeof(size));
    derivatives.resize(size);

    for (MooseIndex(derivatives) i = 0; i < derivatives.size(); ++i)
    {
      dataLoad(stream, derivatives.raw_index(i), context);
      dataLoad(stream, derivatives.raw_at(i), context);
    }
  }
}

dataLoad() [28/44]

template<>

void dataLoad	(	std::istream &	stream,
		libMesh::Parameters &	p,
		void *	context
	)

Definition at line 578 of file DataIO.C.

{
  p.clear();

  // First read the size of the map
  unsigned int size = 0;
  stream.read((char *)&size, sizeof(size));

  for (unsigned int i = 0; i < size; i++)
  {
    std::string key, type;
    loadHelper(stream, key, context);
    loadHelper(stream, type, context);

#define loadscalar(ptype)                                                                          \
  else if (type == demangle(typeid(ptype).name())) do                                              \
  {                                                                                                \
    ptype & value = p.set<ptype>(key);                                                             \
    loadHelper(stream, value, context);                                                            \
  }                                                                                                \
  while (0)

    if (false)
      ;
    loadscalar(Real);
    loadscalar(short);
    loadscalar(int);
    loadscalar(long);
    loadscalar(unsigned short);
    loadscalar(unsigned int);
    loadscalar(unsigned long);

#undef loadscalar
  }
}

dataLoad() [29/44]

template<>

void dataLoad	(	std::istream &	stream,
		std::unique_ptr< libMesh::NumericVector< libMesh::Number >> &	v,
		void *	context
	)

Loads an owned numeric vector.

This is used in lieu of the NumericVector<double> & implementation when the vector may not necessarily be initialized yet on the loading of the data.

If is not null, it must have the same global and local sizes that it was stored with. In this case, the data is simply filled into the vector.

If is null, it will be constructed with the type (currently just a PetscVector) stored and initialized with the global and local sizes stored. The data will then be filled after initialization.

Requirements: the vector cannot be ghosted, the provided context must be the Communicator, and if v is initialized, it must have the same global and local sizes that the vector was stored with.

dataLoad() [30/44]

template<std::size_t N>

void dataLoad ( std::istream &  stream, std::array< ADReal, N > &  dn, void *  context  )

inline

Definition at line 818 of file DataIO.h.

{
  for (std::size_t i = 0; i < N; ++i)
    dataLoad(stream, dn[i], context);
}

dataLoad() [31/44]

template<std::size_t N>

void dataLoad ( std::istream &  stream, ADReal(&)  dn[N], void *  context  )

inline

Definition at line 826 of file DataIO.h.

{
  for (std::size_t i = 0; i < N; ++i)
    dataLoad(stream, dn[i], context);
}

dataLoad() [32/44]

template<typename T >

void dataLoad	(	std::istream &	stream,
		libMesh::NumericVector< T > &	v,
		void *	context
	)

Definition at line 834 of file DataIO.h.

{
  numeric_index_type size = v.local_size();
  for (numeric_index_type i = v.first_local_index(); i < v.first_local_index() + size; i++)
  {
    T r = 0;
    dataLoad(stream, r, context);
    v.set(i, r);
  }
  v.close();
}

dataLoad() [33/44]

template<>

void dataLoad	(	std::istream &	stream,
		Vec &	v,
		void *	context
	)

Definition at line 665 of file DataIO.C.

{
  PetscInt local_size;
  LibmeshPetscCallA(PETSC_COMM_WORLD, VecGetLocalSize(v, &local_size));
  PetscScalar * array;
  LibmeshPetscCallA(PETSC_COMM_WORLD, VecGetArray(v, &array));
  for (PetscInt i = 0; i < local_size; i++)
    dataLoad(stream, array[i], context);

  LibmeshPetscCallA(PETSC_COMM_WORLD, VecRestoreArray(v, &array));
}

dataLoad() [34/44]

template<typename T >

void dataLoad	(	std::istream &	stream,
		DenseVector< T > &	v,
		void *	context
	)

Definition at line 851 of file DataIO.h.

{
  unsigned int n = 0;
  dataLoad(stream, n, nullptr);
  v.resize(n);
  for (unsigned int i = 0; i < n; i++)
  {
    T r = 0;
    dataLoad(stream, r, context);
    v(i) = r;
  }
}

dataLoad() [35/44]

template<typename T >

void dataLoad	(	std::istream &	stream,
		libMesh::TensorValue< T > &	v,
		void *	context
	)

Definition at line 512 of file DataIO.C.

{
  // Obviously if someone loads data with different LIBMESH_DIM than was used for saving them, it
  // won't work.
  for (const auto i : make_range(Moose::dim))
    for (const auto j : make_range(Moose::dim))
    {
      T r = 0;
      dataLoad(stream, r, context);
      v(i, j) = r;
    }
}

dataLoad() [36/44]

template<typename T >

void dataLoad	(	std::istream &	stream,
		libMesh::DenseMatrix< T > &	v,
		void *	context
	)

Definition at line 530 of file DataIO.C.

{
  unsigned int m = 0, n = 0;
  stream.read((char *)&m, sizeof(m));
  stream.read((char *)&n, sizeof(n));
  v.resize(m, n);
  for (unsigned int i = 0; i < m; i++)
    for (unsigned int j = 0; j < n; j++)
    {
      T r = 0;
      dataLoad(stream, r, context);
      v(i, j) = r;
    }
}

dataLoad() [37/44]

template<typename T >

void dataLoad	(	std::istream &	stream,
		libMesh::VectorValue< T > &	v,
		void *	context
	)

Definition at line 550 of file DataIO.C.

{
  // Obviously if someone loads data with different LIBMESH_DIM than was used for saving them, it
  // won't work.
  for (const auto i : make_range(Moose::dim))
  {
    T r = 0;
    dataLoad(stream, r, context);
    v(i) = r;
  }
}

dataLoad() [38/44]

template<typename T >

void dataLoad	(	std::istream &	stream,
		RankTwoTensorTempl< T > &	rtt,
		void *	context
	)

Definition at line 875 of file DataIO.h.

{
  dataLoad(stream, rtt._coords, context);
}

dataLoad() [39/44]

template<typename T >

void dataLoad	(	std::istream &	stream,
		RankThreeTensorTempl< T > &	rtt,
		void *	context
	)

Definition at line 882 of file DataIO.h.

{
  dataLoad(stream, rtt._vals, context);
}

dataLoad() [40/44]

template<typename T >

void dataLoad	(	std::istream &	stream,
		RankFourTensorTempl< T > &	rft,
		void *	context
	)

Definition at line 889 of file DataIO.h.

{
  dataLoad(stream, rft._vals, context);
}

dataLoad() [41/44]

template<typename T >

void dataLoad	(	std::istream &	stream,
		SymmetricRankTwoTensorTempl< T > &	rtt,
		void *	context
	)

Definition at line 896 of file DataIO.h.

{
  dataLoad(stream, rtt._vals, context);
}

dataLoad() [42/44]

template<typename T >

void dataLoad	(	std::istream &	stream,
		SymmetricRankFourTensorTempl< T > &	rft,
		void *	context
	)

Definition at line 903 of file DataIO.h.

{
  dataLoad(stream, rft._vals, context);
}

dataLoad() [43/44]

template<typename T >

void dataLoad	(	std::istream &	stream,
		ColumnMajorMatrixTempl< T > &	cmm,
		void *	context
	)

Definition at line 910 of file DataIO.h.

{
  dataLoad(stream, cmm._values, context);
}

dataLoad() [44/44]

void dataLoad	(	std::istream &	stream,
		Point &	p,
		void *	context
	)

dataStore() [1/44]

template<typename T >

void dataStore ( std::ostream &  stream, T &  v, void *    )

inline

Definition at line 183 of file DataIO.h.

Referenced by dataStore(), and storeHelper().

{
#ifdef LIBMESH_HAVE_CXX11_TYPE_TRAITS
  static_assert(std::is_polymorphic<T>::value == false,
                "Cannot serialize a class that has virtual "
                "members!\nWrite a custom dataStore() "
                "template specialization!\n\n");
  static_assert(std::is_trivially_copyable<T>::value,
                "Cannot serialize a class that is not trivially copyable!\nWrite a custom "
                "dataStore() template specialization!\n\n");
#endif

  stream.write((char *)&v, sizeof(v));
  mooseAssert(!stream.bad(), "Failed to store");
}

dataStore() [2/44]

template<typename T >

void dataStore ( std::ostream &  , T *&  , void *    )

inline

Definition at line 201 of file DataIO.h.

{
  mooseError("Attempting to store a raw pointer type: \"",
             libMesh::demangle(typeid(T).name()),
             " *\" as restartable data!\nWrite a custom dataStore() template specialization!\n\n");
}

dataStore() [3/44]

void dataStore	(	std::ostream &	stream,
		Point &	p,
		void *	context
	)

dataStore() [4/44]

template<typename T , typename U >

void dataStore ( std::ostream &  stream, std::pair< T, U > &  p, void *  context  )

inline

Definition at line 212 of file DataIO.h.

{
  storeHelper(stream, p.first, context);
  storeHelper(stream, p.second, context);
}

dataStore() [5/44]

template<typename T >

void dataStore ( std::ostream &  stream, std::vector< T > &  v, void *  context  )

inline

Definition at line 220 of file DataIO.h.

{
  // First store the size of the vector
  unsigned int size = v.size();
  dataStore(stream, size, nullptr);

  for (unsigned int i = 0; i < size; i++)
    storeHelper(stream, v[i], context);
}

dataStore() [6/44]

template<typename T >

void dataStore ( std::ostream &  stream, std::shared_ptr< T > &  v, void *  context  )

inline

Definition at line 232 of file DataIO.h.

{
  T * tmp = v.get();

  storeHelper(stream, tmp, context);
}

dataStore() [7/44]

template<typename T >

void dataStore ( std::ostream &  stream, std::unique_ptr< T > &  v, void *  context  )

inline

Definition at line 241 of file DataIO.h.

{
  T * tmp = v.get();

  storeHelper(stream, tmp, context);
}

dataStore() [8/44]

template<typename T >

void dataStore ( std::ostream &  stream, std::set< T > &  s, void *  context  )

inline

Definition at line 250 of file DataIO.h.

{
  // First store the size of the set
  unsigned int size = s.size();
  dataStore(stream, size, nullptr);

  typename std::set<T>::iterator it = s.begin();
  typename std::set<T>::iterator end = s.end();

  for (; it != end; ++it)
  {
    T & x = const_cast<T &>(*it);
    storeHelper(stream, x, context);
  }
}

dataStore() [9/44]

template<typename T >

void dataStore ( std::ostream &  stream, std::list< T > &  l, void *  context  )

inline

Definition at line 268 of file DataIO.h.

{
  // First store the size of the set
  unsigned int size = l.size();
  dataStore(stream, size, nullptr);

  typename std::list<T>::iterator it = l.begin();
  typename std::list<T>::iterator end = l.end();

  for (; it != end; ++it)
  {
    T & x = const_cast<T &>(*it);
    storeHelper(stream, x, context);
  }
}

dataStore() [10/44]

template<typename T >

void dataStore ( std::ostream &  stream, std::deque< T > &  l, void *  context  )

inline

Definition at line 286 of file DataIO.h.

{
  // First store the size of the container
  unsigned int size = l.size();
  dataStore(stream, size, nullptr);

  typename std::deque<T>::iterator it = l.begin();
  typename std::deque<T>::iterator end = l.end();

  for (; it != end; ++it)
  {
    T & x = const_cast<T &>(*it);
    storeHelper(stream, x, context);
  }
}

dataStore() [11/44]

template<typename T , typename U >

void dataStore ( std::ostream &  stream, std::map< T, U > &  m, void *  context  )

inline

Definition at line 304 of file DataIO.h.

{
  // First store the size of the map
  unsigned int size = m.size();
  dataStore(stream, size, nullptr);

  typename std::map<T, U>::iterator it = m.begin();
  typename std::map<T, U>::iterator end = m.end();

  for (; it != end; ++it)
  {
    T & key = const_cast<T &>(it->first);

    storeHelper(stream, key, context);

    storeHelper(stream, it->second, context);
  }
}

dataStore() [12/44]

template<typename T , typename U >

void dataStore ( std::ostream &  stream, std::unordered_map< T, U > &  m, void *  context  )

inline

Definition at line 325 of file DataIO.h.

{
  // First store the size of the map
  unsigned int size = m.size();
  dataStore(stream, size, nullptr);

  typename std::unordered_map<T, U>::iterator it = m.begin();
  typename std::unordered_map<T, U>::iterator end = m.end();

  for (; it != end; ++it)
  {
    T & key = const_cast<T &>(it->first);

    storeHelper(stream, key, context);

    storeHelper(stream, it->second, context);
  }
}

dataStore() [13/44]

template<typename T >

void dataStore ( std::ostream &  stream, std::unordered_set< T > &  s, void *  context  )

inline

Definition at line 346 of file DataIO.h.

{
  // First store the size of the set
  std::size_t size = s.size();
  dataStore(stream, size, nullptr);

  for (auto & element : s)
    dataStore(stream, element, context);
}

dataStore() [14/44]

template<typename T >

void dataStore ( std::ostream &  stream, std::optional< T > &  m, void *  context  )

inline

Definition at line 358 of file DataIO.h.

{
  bool has_value = m.has_value();
  dataStore(stream, has_value, nullptr);

  if (has_value)
    storeHelper(stream, *m, context);
}

dataStore() [15/44]

template<typename T , typename U >

void dataStore ( std::ostream &  stream, HashMap< T, U > &  m, void *  context  )

inline

Definition at line 369 of file DataIO.h.

{
  // First store the size of the map
  unsigned int size = m.size();
  dataStore(stream, size, nullptr);

  typename HashMap<T, U>::iterator it = m.begin();
  typename HashMap<T, U>::iterator end = m.end();

  for (; it != end; ++it)
  {
    T & key = const_cast<T &>(it->first);

    storeHelper(stream, key, context);

    storeHelper(stream, it->second, context);
  }
}

dataStore() [16/44]

template<typename T , int Rows, int Cols>

void dataStore	(	std::ostream &	stream,
		Eigen::Matrix< T, Rows, Cols > &	v,
		void *	context
	)

Definition at line 390 of file DataIO.h.

{
  auto m = cast_int<unsigned int>(v.rows());
  dataStore(stream, m, context);
  auto n = cast_int<unsigned int>(v.cols());
  dataStore(stream, n, context);
  for (const auto i : make_range(m))
    for (const auto j : make_range(n))
    {
      auto & r = v(i, j);
      dataStore(stream, r, context);
    }
}

dataStore() [17/44]

template<>

void dataStore	(	std::ostream &	stream,
		Real &	v,
		void *	context
	)

Definition at line 28 of file DataIO.C.

Referenced by dataStore().

{
  stream.write((char *)&v, sizeof(v));
}

dataStore() [18/44]

template<>

void dataStore	(	std::ostream &	stream,
		std::string &	v,
		void *	context
	)

Definition at line 35 of file DataIO.C.

{
  // Write the size of the string
  unsigned int size = v.size();
  stream.write((char *)&size, sizeof(size));

  // Write the string (Do not store the null byte)
  stream.write(v.c_str(), sizeof(char) * size);
}

dataStore() [19/44]

template<>

void dataStore	(	std::ostream &	stream,
		VariableName &	v,
		void *	context
	)

Definition at line 47 of file DataIO.C.

{
  auto & name = static_cast<std::string &>(v);
  dataStore(stream, name, context);
}

dataStore() [20/44]

template<>

void dataStore	(	std::ostream &	stream,
		UserObjectName &	v,
		void *	context
	)

Definition at line 55 of file DataIO.C.

{
  auto & name = static_cast<std::string &>(v);
  dataStore(stream, name, context);
}

dataStore() [21/44]

template<>

void dataStore	(	std::ostream &	stream,
		bool &	v,
		void *	context
	)

Definition at line 63 of file DataIO.C.

{
  stream.write((char *)&v, sizeof(v));
}

dataStore() [22/44]

template<>

void dataStore	(	std::ostream &	stream,
		std::vector< bool > &	v,
		void *	context
	)

Definition at line 70 of file DataIO.C.

{
  for (bool b : v)
    dataStore(stream, b, context);
}

dataStore() [23/44]

template<>

void dataStore	(	std::ostream &	stream,
		const Elem *&	e,
		void *	context
	)

dataStore() [24/44]

template<>

void dataStore	(	std::ostream &	stream,
		const Node *&	n,
		void *	context
	)

dataStore() [25/44]

template<>

void dataStore	(	std::ostream &	stream,
		Elem *&	e,
		void *	context
	)

dataStore() [26/44]

template<>

void dataStore	(	std::ostream &	stream,
		Node *&	n,
		void *	context
	)

dataStore() [27/44]

template<>

void dataStore	(	std::ostream &	stream,
		std::stringstream &	s,
		void *	context
	)

Definition at line 186 of file DataIO.C.

{
  const std::string & s_str = s.str();

  size_t s_size = s_str.size();
  stream.write((char *)&s_size, sizeof(s_size));

  stream.write(s_str.c_str(), sizeof(char) * (s_str.size()));
}

dataStore() [28/44]

template<>

void dataStore	(	std::ostream &	stream,
		ADReal &	dn,
		void *	context
	)

Definition at line 99 of file DataIO.C.

{
  dataStore(stream, dn.value(), context);

  if (ADReal::do_derivatives)
  {
    auto & derivatives = dn.derivatives();
    std::size_t size = derivatives.size();
    dataStore(stream, size, context);
    for (MooseIndex(size) i = 0; i < size; ++i)
    {
      dataStore(stream, derivatives.raw_index(i), context);
      dataStore(stream, derivatives.raw_at(i), context);
    }
  }
}

dataStore() [29/44]

template<>

void dataStore	(	std::ostream &	stream,
		libMesh::Parameters &	p,
		void *	context
	)

Definition at line 258 of file DataIO.C.

{
  // First store the size of the map
  unsigned int size = p.n_parameters();
  stream.write((char *)&size, sizeof(size));

  auto it = p.begin();
  auto end = p.end();

  for (; it != end; ++it)
  {
    auto & key = const_cast<std::string &>(it->first);
    auto type = it->second->type();

    storeHelper(stream, key, context);
    storeHelper(stream, type, context);

#define storescalar(ptype)                                                                         \
  else if (it->second->type() == demangle(typeid(ptype).name())) storeHelper(                      \
      stream,                                                                                      \
      (dynamic_cast<libMesh::Parameters::Parameter<ptype> *>(MooseUtils::get(it->second)))->get(), \
      context)

    if (false)
      ;
    storescalar(Real);
    storescalar(short);
    storescalar(int);
    storescalar(long);
    storescalar(unsigned short);
    storescalar(unsigned int);
    storescalar(unsigned long);

#undef storescalar
  }
}

dataStore() [30/44]

template<>

void dataStore	(	std::ostream &	stream,
		std::unique_ptr< libMesh::NumericVector< libMesh::Number >> &	v,
		void *	context
	)

Stores an owned numeric vector.

This should be used in lieu of the NumericVector<Number> & implementation when the vector may not necessarily be initialized yet on the loading of the data. It stores the partitioning (total and local number of entries).

Requirements: the unique_ptr must exist (cannot be null), the vector cannot be ghosted, and the provided context must be the Communicator.

dataStore() [31/44]

template<std::size_t N>

void dataStore ( std::ostream &  stream, std::array< ADReal, N > &  dn, void *  context  )

inline

Definition at line 451 of file DataIO.h.

{
  for (std::size_t i = 0; i < N; ++i)
    dataStore(stream, dn[i], context);
}

dataStore() [32/44]

template<std::size_t N>

void dataStore ( std::ostream &  stream, ADReal(&)  dn[N], void *  context  )

inline

Definition at line 459 of file DataIO.h.

{
  for (std::size_t i = 0; i < N; ++i)
    dataStore(stream, dn[i], context);
}

dataStore() [33/44]

template<typename T >

void dataStore	(	std::ostream &	stream,
		libMesh::NumericVector< T > &	v,
		void *	context
	)

Definition at line 467 of file DataIO.h.

{
  v.close();

  numeric_index_type size = v.local_size();

  for (numeric_index_type i = v.first_local_index(); i < v.first_local_index() + size; i++)
  {
    T r = v(i);
    dataStore(stream, r, context);
  }
}

dataStore() [34/44]

template<>

void dataStore	(	std::ostream &	stream,
		Vec &	v,
		void *	context
	)

Definition at line 679 of file DataIO.C.

{
  PetscInt local_size;
  LibmeshPetscCallA(PETSC_COMM_WORLD, VecGetLocalSize(v, &local_size));
  PetscScalar * array;
  LibmeshPetscCallA(PETSC_COMM_WORLD, VecGetArray(v, &array));
  for (PetscInt i = 0; i < local_size; i++)
    dataStore(stream, array[i], context);

  LibmeshPetscCallA(PETSC_COMM_WORLD, VecRestoreArray(v, &array));
}

dataStore() [35/44]

template<typename T >

void dataStore	(	std::ostream &	stream,
		DenseVector< T > &	v,
		void *	context
	)

Definition at line 485 of file DataIO.h.

{
  unsigned int m = v.size();
  dataStore(stream, m, nullptr);
  for (unsigned int i = 0; i < v.size(); i++)
  {
    T r = v(i);
    dataStore(stream, r, context);
  }
}

dataStore() [36/44]

template<typename T >

void dataStore	(	std::ostream &	stream,
		libMesh::TensorValue< T > &	v,
		void *	context
	)

Definition at line 198 of file DataIO.C.

{
  for (const auto i : make_range(Moose::dim))
    for (const auto j : make_range(Moose::dim))
    {
      T r = v(i, j);
      dataStore(stream, r, context);
    }
}

dataStore() [37/44]

template<typename T >

void dataStore	(	std::ostream &	stream,
		libMesh::DenseMatrix< T > &	v,
		void *	context
	)

Definition at line 213 of file DataIO.C.

{
  unsigned int m = v.m();
  unsigned int n = v.n();
  stream.write((char *)&m, sizeof(m));
  stream.write((char *)&n, sizeof(n));
  for (unsigned int i = 0; i < m; i++)
    for (unsigned int j = 0; j < n; j++)
    {
      T r = v(i, j);
      dataStore(stream, r, context);
    }
}

dataStore() [38/44]

template<typename T >

void dataStore	(	std::ostream &	stream,
		libMesh::VectorValue< T > &	v,
		void *	context
	)

Definition at line 232 of file DataIO.C.

{
  // Obviously if someone loads data with different LIBMESH_DIM than was used for saving them, it
  // won't work.
  for (const auto i : make_range(Moose::dim))
  {
    T r = v(i);
    dataStore(stream, r, context);
  }
}

dataStore() [39/44]

template<typename T >

void dataStore	(	std::ostream &	stream,
		RankTwoTensorTempl< T > &	rtt,
		void *	context
	)

Definition at line 507 of file DataIO.h.

{
  dataStore(stream, rtt._coords, context);
}

dataStore() [40/44]

template<typename T >

void dataStore	(	std::ostream &	stream,
		RankThreeTensorTempl< T > &	rtt,
		void *	context
	)

Definition at line 514 of file DataIO.h.

{
  dataStore(stream, rtt._vals, context);
}

dataStore() [41/44]

template<typename T >

void dataStore	(	std::ostream &	stream,
		RankFourTensorTempl< T > &	rft,
		void *	context
	)

Definition at line 521 of file DataIO.h.

{
  dataStore(stream, rft._vals, context);
}

dataStore() [42/44]

template<typename T >

void dataStore	(	std::ostream &	stream,
		SymmetricRankTwoTensorTempl< T > &	srtt,
		void *	context
	)

Definition at line 528 of file DataIO.h.

{
  dataStore(stream, srtt._vals, context);
}

dataStore() [43/44]

template<typename T >

void dataStore	(	std::ostream &	stream,
		SymmetricRankFourTensorTempl< T > &	srft,
		void *	context
	)

Definition at line 535 of file DataIO.h.

{
  dataStore(stream, srft._vals, context);
}

dataStore() [44/44]

template<typename T >

void dataStore	(	std::ostream &	stream,
		ColumnMajorMatrixTempl< T > &	cmm,
		void *	context
	)

Definition at line 542 of file DataIO.h.

{
  dataStore(stream, cmm._values, context);
}

loadHelper() [1/10]

template<typename P >

void loadHelper ( std::istream &  stream, P &  data, void *  context  )

inline

Scalar helper routine.

Definition at line 1010 of file DataIO.h.

Referenced by dataLoad(), MaterialPropertyBase< T, false >::load(), loadHelper(), ReporterState< std::vector< T > >::loadInternal(), and RestartableData< std::list< T > >::loadInternal().

{
  dataLoad(stream, data, context);
}

loadHelper() [2/10]

template<typename P >

void loadHelper ( std::istream &  stream, std::vector< P > &  data, void *  context  )

inline

Vector helper routine.

Definition at line 1018 of file DataIO.h.

{
  dataLoad(stream, data, context);
}

loadHelper() [3/10]

template<typename P >

void loadHelper ( std::istream &  stream, std::shared_ptr< P > &  data, void *  context  )

inline

Shared Pointer helper routine.

Definition at line 1026 of file DataIO.h.

{
  dataLoad(stream, data, context);
}

loadHelper() [4/10]

template<typename P >

void loadHelper ( std::istream &  stream, std::unique_ptr< P > &  data, void *  context  )

inline

Unique Pointer helper routine.

Definition at line 1034 of file DataIO.h.

{
  dataLoad(stream, data, context);
}

loadHelper() [5/10]

template<typename P >

void loadHelper ( std::istream &  stream, std::set< P > &  data, void *  context  )

inline

Set helper routine.

Definition at line 1042 of file DataIO.h.

{
  dataLoad(stream, data, context);
}

loadHelper() [6/10]

template<typename P , typename Q >

void loadHelper ( std::istream &  stream, std::map< P, Q > &  data, void *  context  )

inline

Map helper routine.

Definition at line 1050 of file DataIO.h.

{
  dataLoad(stream, data, context);
}

loadHelper() [7/10]

template<typename P , typename Q >

void loadHelper ( std::istream &  stream, std::unordered_map< P, Q > &  data, void *  context  )

inline

Unordered_map helper routine.

Definition at line 1058 of file DataIO.h.

{
  dataLoad(stream, data, context);
}

loadHelper() [8/10]

template<typename P >

void loadHelper ( std::istream &  stream, std::optional< P > &  data, void *  context  )

inline

Optional helper routine.

Definition at line 1066 of file DataIO.h.

{
  dataLoad(stream, data, context);
}

loadHelper() [9/10]

template<typename P , typename Q >

void loadHelper ( std::istream &  stream, HashMap< P, Q > &  data, void *  context  )

inline

Hashmap helper routine.

Definition at line 1074 of file DataIO.h.

{
  dataLoad(stream, data, context);
}

loadHelper() [10/10]

template<typename T >

void loadHelper ( std::istream &  stream, UniqueStorage< T > &  data, void *  context  )

inline

UniqueStorage helper routine.

UniqueStorage Helper Function.

The unique_ptr<T> loader is called to load the data. That is, you will likely need a specialization of unique_ptr<T> that will appropriately construct and then fill the piece of data.

Definition at line 1088 of file DataIO.h.

{
  std::size_t size;
  dataLoad(stream, size, nullptr);
  data.resize(size);

  for (const auto i : index_range(data))
    loadHelper(stream, data.pointerValue(i), context);
}

storeHelper() [1/10]

template<typename P >

void storeHelper ( std::ostream &  stream, P &  data, void *  context  )

inline

Scalar helper routine.

Definition at line 918 of file DataIO.h.

Referenced by dataStore(), MaterialPropertyBase< T, false >::store(), storeHelper(), ReporterState< std::vector< T > >::storeInternal(), and RestartableData< std::list< T > >::storeInternal().

{
  dataStore(stream, data, context);
}

storeHelper() [2/10]

template<typename P >

void storeHelper ( std::ostream &  stream, std::vector< P > &  data, void *  context  )

inline

Vector helper routine.

Definition at line 926 of file DataIO.h.

{
  dataStore(stream, data, context);
}

storeHelper() [3/10]

template<typename P >

void storeHelper ( std::ostream &  stream, std::shared_ptr< P > &  data, void *  context  )

inline

Shared pointer helper routine.

Definition at line 934 of file DataIO.h.

{
  dataStore(stream, data, context);
}

storeHelper() [4/10]

template<typename P >

void storeHelper ( std::ostream &  stream, std::unique_ptr< P > &  data, void *  context  )

inline

Unique pointer helper routine.

Definition at line 942 of file DataIO.h.

{
  dataStore(stream, data, context);
}

storeHelper() [5/10]

template<typename P >

void storeHelper ( std::ostream &  stream, std::set< P > &  data, void *  context  )

inline

Set helper routine.

Definition at line 950 of file DataIO.h.

{
  dataStore(stream, data, context);
}

storeHelper() [6/10]

template<typename P , typename Q >

void storeHelper ( std::ostream &  stream, std::map< P, Q > &  data, void *  context  )

inline

Map helper routine.

Definition at line 958 of file DataIO.h.

{
  dataStore(stream, data, context);
}

storeHelper() [7/10]

template<typename P , typename Q >

void storeHelper ( std::ostream &  stream, std::unordered_map< P, Q > &  data, void *  context  )

inline

Unordered_map helper routine.

Definition at line 966 of file DataIO.h.

{
  dataStore(stream, data, context);
}

storeHelper() [8/10]

template<typename P >

void storeHelper ( std::ostream &  stream, std::optional< P > &  data, void *  context  )

inline

Optional helper routine.

Definition at line 974 of file DataIO.h.

{
  dataStore(stream, data, context);
}

storeHelper() [9/10]

template<typename P , typename Q >

void storeHelper ( std::ostream &  stream, HashMap< P, Q > &  data, void *  context  )

inline

HashMap helper routine.

Definition at line 982 of file DataIO.h.

{
  dataStore(stream, data, context);
}

storeHelper() [10/10]

template<typename T >

void storeHelper ( std::ostream &  stream, UniqueStorage< T > &  data, void *  context  )

inline

UniqueStorage helper routine.

The data within the UniqueStorage object cannot be null. The helper for unique_ptr<T> is called to store the data.

Definition at line 995 of file DataIO.h.

{
  std::size_t size = data.size();
  dataStore(stream, size, nullptr);

  for (const auto i : index_range(data))
  {
    mooseAssert(data.hasValue(i), "Data doesn't have a value");
    storeHelper(stream, data.pointerValue(i), context);
  }
}