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<>
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, RealEigenVector &v, void *context)
template<>
void	dataStore (std::ostream &stream, RealEigenMatrix &v, 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<>
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, RealEigenVector &v, void *context)
template<>
void	dataLoad (std::istream &stream, RealEigenMatrix &v, 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/45]

template<typename T >

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

inline

Definition at line 540 of file DataIO.h.

Referenced by dataLoad(), and loadHelper().

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

dataLoad() [2/45]

template<typename T >

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

Definition at line 548 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/45]

template<typename T , typename U >

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

inline

Definition at line 557 of file DataIO.h.

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

dataLoad() [4/45]

template<typename T >

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

inline

Definition at line 565 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/45]

template<typename T >

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

inline

Definition at line 579 of file DataIO.h.

{
  T * tmp = v.get();

  loadHelper(stream, tmp, context);
}

dataLoad() [6/45]

template<typename T >

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

inline

Definition at line 588 of file DataIO.h.

{
  T * tmp = v.get();

  loadHelper(stream, tmp, context);
}

dataLoad() [7/45]

template<typename T >

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

inline

Definition at line 597 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/45]

template<typename T >

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

inline

Definition at line 613 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/45]

template<typename T >

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

inline

Definition at line 629 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/45]

template<typename T , typename U >

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

inline

Definition at line 645 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/45]

template<typename T , typename U >

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

inline

Definition at line 665 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/45]

template<typename T >

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

inline

Definition at line 685 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/45]

template<typename T >

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

inline

Definition at line 704 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/45]

template<typename T , typename U >

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

inline

Definition at line 720 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/45]

template<>

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

Definition at line 372 of file DataIO.C.

Referenced by dataLoad().

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

dataLoad() [16/45]

template<>

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

Definition at line 379 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() [17/45]

template<>

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

Definition at line 394 of file DataIO.C.

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

dataLoad() [18/45]

template<>

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

Definition at line 402 of file DataIO.C.

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

dataLoad() [19/45]

template<>

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

Definition at line 410 of file DataIO.C.

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

dataLoad() [20/45]

template<>

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

Definition at line 417 of file DataIO.C.

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

dataLoad() [21/45]

template<>

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

dataLoad() [22/45]

template<>

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

dataLoad() [23/45]

template<>

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

dataLoad() [24/45]

template<>

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

dataLoad() [25/45]

template<>

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

Definition at line 526 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() [26/45]

template<>

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

Definition at line 425 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() [27/45]

template<>

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

dataLoad() [28/45]

template<>

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

dataLoad() [29/45]

template<>

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

Definition at line 640 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() [30/45]

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() [31/45]

template<std::size_t N>

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

inline

Definition at line 793 of file DataIO.h.

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

dataLoad() [32/45]

template<std::size_t N>

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

inline

Definition at line 801 of file DataIO.h.

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

dataLoad() [33/45]

template<typename T >

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

Definition at line 809 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() [34/45]

template<>

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

Definition at line 727 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() [35/45]

template<typename T >

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

Definition at line 826 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() [36/45]

template<typename T >

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

Definition at line 574 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() [37/45]

template<typename T >

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

Definition at line 592 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() [38/45]

template<typename T >

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

Definition at line 612 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() [39/45]

template<typename T >

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

Definition at line 850 of file DataIO.h.

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

dataLoad() [40/45]

template<typename T >

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

Definition at line 857 of file DataIO.h.

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

dataLoad() [41/45]

template<typename T >

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

Definition at line 864 of file DataIO.h.

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

dataLoad() [42/45]

template<typename T >

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

Definition at line 871 of file DataIO.h.

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

dataLoad() [43/45]

template<typename T >

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

Definition at line 878 of file DataIO.h.

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

dataLoad() [44/45]

template<typename T >

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

Definition at line 885 of file DataIO.h.

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

dataLoad() [45/45]

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

dataStore() [1/45]

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

  // Moose::out<<"Generic dataStore"<<std::endl;
  stream.write((char *)&v, sizeof(v));
  mooseAssert(!stream.bad(), "Failed to store");
}

dataStore() [2/45]

template<typename T >

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

inline

Definition at line 202 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/45]

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

dataStore() [4/45]

template<typename T , typename U >

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

inline

Definition at line 213 of file DataIO.h.

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

dataStore() [5/45]

template<typename T >

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

inline

Definition at line 221 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/45]

template<typename T >

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

inline

Definition at line 233 of file DataIO.h.

{
  T * tmp = v.get();

  storeHelper(stream, tmp, context);
}

dataStore() [7/45]

template<typename T >

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

inline

Definition at line 242 of file DataIO.h.

{
  T * tmp = v.get();

  storeHelper(stream, tmp, context);
}

dataStore() [8/45]

template<typename T >

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

inline

Definition at line 251 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/45]

template<typename T >

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

inline

Definition at line 269 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/45]

template<typename T >

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

inline

Definition at line 287 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/45]

template<typename T , typename U >

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

inline

Definition at line 305 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/45]

template<typename T , typename U >

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

inline

Definition at line 326 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/45]

template<typename T >

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

inline

Definition at line 347 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/45]

template<typename T >

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

inline

Definition at line 359 of file DataIO.h.

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

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

dataStore() [15/45]

template<typename T , typename U >

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

inline

Definition at line 370 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/45]

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() [17/45]

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() [18/45]

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() [19/45]

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() [20/45]

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() [21/45]

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() [22/45]

template<>

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

dataStore() [23/45]

template<>

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

dataStore() [24/45]

template<>

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

dataStore() [25/45]

template<>

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

dataStore() [26/45]

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() [27/45]

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() [28/45]

template<>

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

dataStore() [29/45]

template<>

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

dataStore() [30/45]

template<>

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

Definition at line 287 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() [31/45]

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() [32/45]

template<std::size_t N>

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

inline

Definition at line 440 of file DataIO.h.

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

dataStore() [33/45]

template<std::size_t N>

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

inline

Definition at line 448 of file DataIO.h.

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

dataStore() [34/45]

template<typename T >

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

Definition at line 456 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() [35/45]

template<>

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

Definition at line 741 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() [36/45]

template<typename T >

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

Definition at line 474 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() [37/45]

template<typename T >

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

Definition at line 227 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() [38/45]

template<typename T >

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

Definition at line 242 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() [39/45]

template<typename T >

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

Definition at line 261 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() [40/45]

template<typename T >

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

Definition at line 496 of file DataIO.h.

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

dataStore() [41/45]

template<typename T >

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

Definition at line 503 of file DataIO.h.

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

dataStore() [42/45]

template<typename T >

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

Definition at line 510 of file DataIO.h.

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

dataStore() [43/45]

template<typename T >

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

Definition at line 517 of file DataIO.h.

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

dataStore() [44/45]

template<typename T >

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

Definition at line 524 of file DataIO.h.

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

dataStore() [45/45]

template<typename T >

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

Definition at line 531 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 985 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 993 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 1001 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 1009 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 1017 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 1025 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 1033 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 1041 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 1049 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 1063 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 893 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 901 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 909 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 917 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 925 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 933 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 941 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 949 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 957 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 970 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);
  }
}