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<typename T >
void	dataStore (std::ostream &stream, GenericTwoVector< T > &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, libMesh::FEType &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<typename T >
void	dataLoad (std::istream &stream, GenericTwoVector< T > &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, libMesh::FEType &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/46]

template<typename T >

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

inline

Definition at line 562 of file DataIO.h.

Referenced by dataLoad(), and loadHelper().

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

dataLoad() [2/46]

template<typename T >

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

Definition at line 570 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/46]

template<typename T , typename U >

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

inline

Definition at line 579 of file DataIO.h.

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

dataLoad() [4/46]

template<typename T >

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

inline

Definition at line 587 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/46]

template<typename T >

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

inline

Definition at line 601 of file DataIO.h.

{
  T * tmp = v.get();

  loadHelper(stream, tmp, context);
}

dataLoad() [6/46]

template<typename T >

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

inline

Definition at line 610 of file DataIO.h.

{
  T * tmp = v.get();

  loadHelper(stream, tmp, context);
}

dataLoad() [7/46]

template<typename T >

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

inline

Definition at line 619 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/46]

template<typename T >

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

inline

Definition at line 635 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/46]

template<typename T >

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

inline

Definition at line 651 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/46]

template<typename T , typename U >

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

inline

Definition at line 667 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/46]

template<typename T , typename U >

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

inline

Definition at line 687 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/46]

template<typename T >

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

inline

Definition at line 707 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/46]

template<typename T >

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

inline

Definition at line 726 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/46]

template<typename T , typename U >

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

inline

Definition at line 742 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/46]

template<typename T , int Rows, int Cols>

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

Definition at line 760 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/46]

template<typename T >

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

Definition at line 778 of file DataIO.h.

{
  dataLoad(stream, static_cast<Eigen::Matrix<T, 2, 1> &>(v), context);
}

dataLoad() [17/46]

template<>

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

Definition at line 369 of file DataIO.C.

Referenced by dataLoad().

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

dataLoad() [18/46]

template<>

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

Definition at line 376 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() [19/46]

template<>

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

Definition at line 391 of file DataIO.C.

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

dataLoad() [20/46]

template<>

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

Definition at line 399 of file DataIO.C.

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

dataLoad() [21/46]

template<>

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

Definition at line 407 of file DataIO.C.

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

dataLoad() [22/46]

template<>

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

Definition at line 414 of file DataIO.C.

{
  int order = 0;
  dataLoad(stream, order, context);
  v.order = order;

  dataLoad(stream, v.family, context);

#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
  int radial_order = 0;
  dataLoad(stream, radial_order, context);
  v.radial_order = radial_order;

  dataLoad(stream, v.radial_family, context);
  dataLoad(stream, v.inf_map, context);
#endif

  dataLoad(stream, v.p_refinement, context);
}

dataLoad() [23/46]

template<>

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

Definition at line 436 of file DataIO.C.

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

dataLoad() [24/46]

template<>

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

dataLoad() [25/46]

template<>

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

dataLoad() [26/46]

template<>

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

dataLoad() [27/46]

template<>

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

dataLoad() [28/46]

template<>

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

Definition at line 545 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() [29/46]

template<>

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

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

template<>

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

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

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

template<std::size_t N>

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

inline

Definition at line 838 of file DataIO.h.

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

dataLoad() [33/46]

template<std::size_t N>

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

inline

Definition at line 846 of file DataIO.h.

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

dataLoad() [34/46]

template<typename T >

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

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

template<>

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

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

template<typename T >

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

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

template<typename T >

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

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

template<typename T >

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

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

template<typename T >

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

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

template<typename T >

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

Definition at line 895 of file DataIO.h.

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

dataLoad() [41/46]

template<typename T >

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

Definition at line 902 of file DataIO.h.

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

dataLoad() [42/46]

template<typename T >

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

Definition at line 909 of file DataIO.h.

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

dataLoad() [43/46]

template<typename T >

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

Definition at line 916 of file DataIO.h.

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

dataLoad() [44/46]

template<typename T >

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

Definition at line 923 of file DataIO.h.

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

dataLoad() [45/46]

template<typename T >

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

Definition at line 930 of file DataIO.h.

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

dataLoad() [46/46]

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

dataStore() [1/46]

template<typename T >

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

inline

Definition at line 185 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/46]

template<typename T >

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

inline

Definition at line 203 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/46]

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

dataStore() [4/46]

template<typename T , typename U >

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

inline

Definition at line 214 of file DataIO.h.

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

dataStore() [5/46]

template<typename T >

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

inline

Definition at line 222 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/46]

template<typename T >

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

inline

Definition at line 234 of file DataIO.h.

{
  T * tmp = v.get();

  storeHelper(stream, tmp, context);
}

dataStore() [7/46]

template<typename T >

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

inline

Definition at line 243 of file DataIO.h.

{
  T * tmp = v.get();

  storeHelper(stream, tmp, context);
}

dataStore() [8/46]

template<typename T >

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

inline

Definition at line 252 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/46]

template<typename T >

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

inline

Definition at line 270 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/46]

template<typename T >

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

inline

Definition at line 288 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/46]

template<typename T , typename U >

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

inline

Definition at line 306 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/46]

template<typename T , typename U >

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

inline

Definition at line 327 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/46]

template<typename T >

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

inline

Definition at line 348 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/46]

template<typename T >

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

inline

Definition at line 360 of file DataIO.h.

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

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

dataStore() [15/46]

template<typename T , typename U >

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

inline

Definition at line 371 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/46]

template<typename T , int Rows, int Cols>

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

Definition at line 392 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/46]

template<typename T >

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

Definition at line 408 of file DataIO.h.

{
  dataStore(stream, static_cast<Eigen::Matrix<T, 2, 1> &>(v), context);
}

dataStore() [18/46]

template<>

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

Definition at line 29 of file DataIO.C.

Referenced by dataStore().

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

dataStore() [19/46]

template<>

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

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

template<>

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

Definition at line 48 of file DataIO.C.

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

dataStore() [21/46]

template<>

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

Definition at line 56 of file DataIO.C.

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

dataStore() [22/46]

template<>

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

Definition at line 64 of file DataIO.C.

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

dataStore() [23/46]

template<>

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

Definition at line 71 of file DataIO.C.

{
  auto order = v.order.get_order();
  dataStore(stream, order, context);

  auto family = v.family;
  dataStore(stream, family, context);

#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
  auto radial_order = v.radial_order.get_order();
  dataStore(stream, radial_order, context);

  auto radial_family = v.radial_family;
  dataStore(stream, radial_family, context);

  auto inf_map = v.inf_map;
  dataStore(stream, inf_map, context);
#endif

  auto p_refinement = v.p_refinement;
  dataStore(stream, p_refinement, context);
}

dataStore() [24/46]

template<>

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

Definition at line 96 of file DataIO.C.

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

dataStore() [25/46]

template<>

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

dataStore() [26/46]

template<>

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

dataStore() [27/46]

template<>

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

dataStore() [28/46]

template<>

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

dataStore() [29/46]

template<>

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

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

template<>

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

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

template<>

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

Definition at line 284 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() [32/46]

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() [33/46]

template<std::size_t N>

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

inline

Definition at line 462 of file DataIO.h.

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

dataStore() [34/46]

template<std::size_t N>

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

inline

Definition at line 470 of file DataIO.h.

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

dataStore() [35/46]

template<typename T >

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

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

template<>

void dataStore	(	std::ostream &	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++)
    dataStore(stream, array[i], context);

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

dataStore() [37/46]

template<typename T >

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

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

template<typename T >

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

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

template<typename T >

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

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

template<typename T >

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

Definition at line 258 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() [41/46]

template<typename T >

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

Definition at line 518 of file DataIO.h.

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

dataStore() [42/46]

template<typename T >

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

Definition at line 525 of file DataIO.h.

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

dataStore() [43/46]

template<typename T >

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

Definition at line 532 of file DataIO.h.

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

dataStore() [44/46]

template<typename T >

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

Definition at line 539 of file DataIO.h.

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

dataStore() [45/46]

template<typename T >

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

Definition at line 546 of file DataIO.h.

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

dataStore() [46/46]

template<typename T >

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

Definition at line 553 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 1030 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 1038 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 1046 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 1054 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 1062 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 1070 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 1078 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 1086 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 1094 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 1108 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 938 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 946 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 954 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 962 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 970 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 978 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 986 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 994 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 1002 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 1015 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);
  }
}