www.mooseframework.org
Classes | Namespaces | Typedefs | Functions
DataIO.h File Reference

Go to the source code of this file.

Classes

class  ColumnMajorMatrixTempl< T >
 This class defines a Tensor that can change its shape. More...
 
class  libMesh::NumericVector< T >
 
class  libMesh::DenseMatrix< T >
 
class  libMesh::DenseVector< T >
 
class  libMesh::VectorValue< typename >
 
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
 

Typedefs

typedef ColumnMajorMatrixTempl< Real > ColumnMajorMatrix
 

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 , typename Q >
void storeHelper (std::ostream &stream, HashMap< P, Q > &data, void *context)
 HashMap 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 , typename Q >
void loadHelper (std::istream &stream, HashMap< P, Q > &data, void *context)
 Hashmap 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 , 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 , typename U >
void dataStore (std::ostream &stream, HashMap< T, U > &m, void *context)
 
template<>
void dataStore (std::ostream &stream, Real &v, void *)
 
template<>
void dataStore (std::ostream &stream, std::string &v, void *)
 
template<>
void dataStore (std::ostream &stream, ColumnMajorMatrix &v, void *)
 
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, std::stringstream *&s, void *context)
 
template<>
void dataStore (std::ostream &stream, DualReal &dn, void *context)
 
template<std::size_t N>
void dataStore (std::ostream &stream, DualReal(&dn)[N], void *context)
 
template<typename T >
void dataStore (std::ostream &stream, NumericVector< T > &v, void *context)
 
template<typename T >
void dataStore (std::ostream &stream, DenseVector< T > &v, void *context)
 
template<typename T >
void dataStore (std::ostream &stream, TensorValue< T > &v, void *context)
 
template<typename T >
void dataStore (std::ostream &stream, DenseMatrix< T > &v, void *context)
 
template<typename T >
void dataStore (std::ostream &stream, 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, MooseADWrapper< T > &dn_wrapper, 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 , 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 , 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, ColumnMajorMatrix &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, std::stringstream *&s, void *context)
 
template<>
void dataLoad (std::istream &stream, DualReal &dn, void *context)
 
template<typename T >
void dataLoad (std::istream &stream, NumericVector< T > &v, void *context)
 
template<typename T >
void dataLoad (std::istream &stream, DenseVector< T > &v, void *context)
 
template<typename T >
void dataLoad (std::istream &stream, TensorValue< T > &v, void *context)
 
template<typename T >
void dataLoad (std::istream &stream, DenseMatrix< T > &v, void *context)
 
template<typename T >
void dataLoad (std::istream &stream, 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, MooseADWrapper< T > &dn_wrapper, void *context)
 
template<>
void dataStore (std::ostream &stream, Backup *&backup, void *context)
 
template<>
void dataLoad (std::istream &stream, Backup *&backup, void *context)
 
void dataLoad (std::istream &stream, Point &p, void *context)
 

Typedef Documentation

◆ ColumnMajorMatrix

Definition at line 39 of file DataIO.h.

Function Documentation

◆ dataLoad() [1/32]

template<typename T >
void dataLoad ( std::istream &  stream,
T &  v,
void *   
)
inline

Definition at line 435 of file DataIO.h.

Referenced by dataLoad(), and loadHelper().

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

◆ dataLoad() [2/32]

template<typename T >
void dataLoad ( std::istream &  ,
T *&  ,
void *   
)

Definition at line 442 of file DataIO.h.

443 {
444  mooseError("Attempting to load a raw pointer type: \"",
445  demangle(typeid(T).name()),
446  " *\" as restartable data!\nWrite a custom dataLoad() template specialization!\n\n");
447 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:207

◆ dataLoad() [3/32]

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

Definition at line 451 of file DataIO.h.

452 {
453  loadHelper(stream, p.first, context);
454  loadHelper(stream, p.second, context);
455 }
void loadHelper(std::istream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:741

◆ dataLoad() [4/32]

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

Definition at line 459 of file DataIO.h.

460 {
461  // First read the size of the vector
462  unsigned int size = 0;
463  stream.read((char *)&size, sizeof(size));
464 
465  v.resize(size);
466 
467  for (unsigned int i = 0; i < size; i++)
468  loadHelper(stream, v[i], context);
469 }
void loadHelper(std::istream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:741

◆ dataLoad() [5/32]

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

Definition at line 473 of file DataIO.h.

474 {
475  T * tmp = v.get();
476 
477  loadHelper(stream, tmp, context);
478 }
void loadHelper(std::istream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:741

◆ dataLoad() [6/32]

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

Definition at line 482 of file DataIO.h.

483 {
484  T * tmp = v.get();
485 
486  loadHelper(stream, tmp, context);
487 }
void loadHelper(std::istream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:741

◆ dataLoad() [7/32]

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

Definition at line 491 of file DataIO.h.

492 {
493  // First read the size of the set
494  unsigned int size = 0;
495  stream.read((char *)&size, sizeof(size));
496 
497  for (unsigned int i = 0; i < size; i++)
498  {
499  T data;
500  loadHelper(stream, data, context);
501  s.insert(std::move(data));
502  }
503 }
void loadHelper(std::istream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:741

◆ dataLoad() [8/32]

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

Definition at line 507 of file DataIO.h.

508 {
509  // First read the size of the set
510  unsigned int size = 0;
511  stream.read((char *)&size, sizeof(size));
512 
513  for (unsigned int i = 0; i < size; i++)
514  {
515  T data;
516  loadHelper(stream, data, context);
517  l.push_back(std::move(data));
518  }
519 }
void loadHelper(std::istream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:741

◆ dataLoad() [9/32]

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

Definition at line 523 of file DataIO.h.

524 {
525  m.clear();
526 
527  // First read the size of the map
528  unsigned int size = 0;
529  stream.read((char *)&size, sizeof(size));
530 
531  for (unsigned int i = 0; i < size; i++)
532  {
533  T key;
534  loadHelper(stream, key, context);
535 
536  U & value = m[key];
537  loadHelper(stream, value, context);
538  }
539 }
PetscInt m
void loadHelper(std::istream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:741

◆ dataLoad() [10/32]

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

Definition at line 543 of file DataIO.h.

544 {
545  m.clear();
546 
547  // First read the size of the map
548  unsigned int size = 0;
549  stream.read((char *)&size, sizeof(size));
550 
551  for (unsigned int i = 0; i < size; i++)
552  {
553  T key;
554  loadHelper(stream, key, context);
555 
556  U & value = m[key];
557  loadHelper(stream, value, context);
558  }
559 }
PetscInt m
void loadHelper(std::istream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:741

◆ dataLoad() [11/32]

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

Definition at line 563 of file DataIO.h.

564 {
565  // First read the size of the map
566  unsigned int size = 0;
567  stream.read((char *)&size, sizeof(size));
568 
569  for (unsigned int i = 0; i < size; i++)
570  {
571  T key;
572  loadHelper(stream, key, context);
573 
574  U & value = m[key];
575  loadHelper(stream, value, context);
576  }
577 }
PetscInt m
void loadHelper(std::istream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:741

◆ dataLoad() [12/32]

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

Definition at line 235 of file DataIO.C.

Referenced by dataLoad().

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

◆ dataLoad() [13/32]

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

Definition at line 242 of file DataIO.C.

243 {
244  // Read the size of the string
245  unsigned int size = 0;
246  stream.read((char *)&size, sizeof(size));
247 
248  // Resize the string data
249  v.resize(size);
250 
251  // Read the string
252  stream.read(&v[0], sizeof(char) * size);
253 }

◆ dataLoad() [14/32]

template<>
void dataLoad ( std::istream &  stream,
ColumnMajorMatrix v,
void *   
)

Definition at line 257 of file DataIO.C.

258 {
259  for (unsigned int i = 0; i < v.m(); i++)
260  for (unsigned int j = 0; j < v.n(); j++)
261  {
262  Real r = 0;
263  stream.read((char *)&r, sizeof(r));
264  v(i, j) = r;
265  }
266 }
unsigned int m() const
Returns the number of columns.
unsigned int n() const
Returns the number of rows.

◆ dataLoad() [15/32]

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

Definition at line 281 of file DataIO.C.

282 {
283  if (!context)
284  mooseError("Can only load Elem objects using a MooseMesh context!");
285 
286  MooseMesh * mesh = static_cast<MooseMesh *>(context);
287 
288  // TODO: Write out the unique ID of this element
289  dof_id_type id = libMesh::DofObject::invalid_id;
290 
291  loadHelper(stream, id, context);
292 
293  if (id != libMesh::DofObject::invalid_id)
294  e = mesh->elemPtr(id);
295  else
296  e = NULL;
297 }
virtual Elem * elemPtr(const dof_id_type i)
Definition: MooseMesh.C:2267
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:207
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
Definition: MooseMesh.h:74
void loadHelper(std::istream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:741

◆ dataLoad() [16/32]

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

Definition at line 301 of file DataIO.C.

302 {
303  if (!context)
304  mooseError("Can only load Node objects using a MooseMesh context!");
305 
306  MooseMesh * mesh = static_cast<MooseMesh *>(context);
307 
308  // TODO: Write out the unique ID of this nodeent
309  dof_id_type id = libMesh::DofObject::invalid_id;
310 
311  loadHelper(stream, id, context);
312 
313  if (id != libMesh::DofObject::invalid_id)
314  n = mesh->nodePtr(id);
315  else
316  n = NULL;
317 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:207
virtual const Node * nodePtr(const dof_id_type i) const
Definition: MooseMesh.C:454
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
Definition: MooseMesh.h:74
PetscInt n
void loadHelper(std::istream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:741

◆ dataLoad() [17/32]

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

Definition at line 321 of file DataIO.C.

322 {
323  if (!context)
324  mooseError("Can only load Elem objects using a MooseMesh context!");
325 
326  MooseMesh * mesh = static_cast<MooseMesh *>(context);
327 
328  // TODO: Write out the unique ID of this element
329  dof_id_type id = libMesh::DofObject::invalid_id;
330 
331  loadHelper(stream, id, context);
332 
333  if (id != libMesh::DofObject::invalid_id)
334  e = mesh->elemPtr(id);
335  else
336  e = NULL;
337 }
virtual Elem * elemPtr(const dof_id_type i)
Definition: MooseMesh.C:2267
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:207
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
Definition: MooseMesh.h:74
void loadHelper(std::istream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:741

◆ dataLoad() [18/32]

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

Definition at line 341 of file DataIO.C.

342 {
343  if (!context)
344  mooseError("Can only load Node objects using a MooseMesh context!");
345 
346  MooseMesh * mesh = static_cast<MooseMesh *>(context);
347 
348  // TODO: Write out the unique ID of this nodeent
349  dof_id_type id = libMesh::DofObject::invalid_id;
350 
351  loadHelper(stream, id, context);
352 
353  if (id != libMesh::DofObject::invalid_id)
354  n = mesh->nodePtr(id);
355  else
356  n = NULL;
357 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:207
virtual const Node * nodePtr(const dof_id_type i) const
Definition: MooseMesh.C:454
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
Definition: MooseMesh.h:74
PetscInt n
void loadHelper(std::istream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:741

◆ dataLoad() [19/32]

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

Definition at line 361 of file DataIO.C.

362 {
363  size_t s_size = 0;
364  stream.read((char *)&s_size, sizeof(s_size));
365 
366  std::unique_ptr<char[]> s_s(new char[s_size]);
367  stream.read(s_s.get(), s_size);
368 
369  // Clear the stringstream before loading new data into it.
370  s.str(std::string());
371  s.write(s_s.get(), s_size);
372 }

◆ dataLoad() [20/32]

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

Definition at line 376 of file DataIO.C.

377 {
378  dataLoad(stream, *s, context);
379 }
void dataLoad(std::istream &stream, Real &v, void *)
Definition: DataIO.C:235

◆ dataLoad() [21/32]

template<>
void dataLoad ( std::istream &  stream,
DualReal dn,
void *  context 
)

Definition at line 270 of file DataIO.C.

271 {
272  dataLoad(stream, dn.value(), context);
273 
274  auto & derivatives = dn.derivatives();
275  for (MooseIndex(derivatives) i = 0; i < derivatives.size(); ++i)
276  dataLoad(stream, derivatives[i], context);
277 }
void dataLoad(std::istream &stream, Real &v, void *)
Definition: DataIO.C:235

◆ dataLoad() [22/32]

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

Definition at line 603 of file DataIO.h.

604 {
605  numeric_index_type size = v.local_size();
606  for (numeric_index_type i = v.first_local_index(); i < v.first_local_index() + size; i++)
607  {
608  T r = 0;
609  dataLoad(stream, r, context);
610  v.set(i, r);
611  }
612  v.close();
613 }
void dataLoad(std::istream &stream, T &v, void *)
Definition: DataIO.h:435

◆ dataLoad() [23/32]

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

Definition at line 617 of file DataIO.h.

618 {
619  unsigned int n = 0;
620  stream.read((char *)&n, sizeof(n));
621  v.resize(n);
622  for (unsigned int i = 0; i < n; i++)
623  {
624  T r = 0;
625  dataLoad(stream, r, context);
626  v(i) = r;
627  }
628 }
PetscInt n
void dataLoad(std::istream &stream, T &v, void *)
Definition: DataIO.h:435

◆ dataLoad() [24/32]

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

Definition at line 383 of file DataIO.C.

384 {
385  // Obviously if someone loads data with different LIBMESH_DIM than was used for saving them, it
386  // won't work.
387  for (unsigned int i = 0; i < LIBMESH_DIM; i++)
388  for (unsigned int j = 0; i < LIBMESH_DIM; i++)
389  {
390  T r = 0;
391  dataLoad(stream, r, context);
392  v(i, j) = r;
393  }
394 }
void dataLoad(std::istream &stream, Real &v, void *)
Definition: DataIO.C:235

◆ dataLoad() [25/32]

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

Definition at line 401 of file DataIO.C.

402 {
403  unsigned int m = 0, n = 0;
404  stream.read((char *)&m, sizeof(m));
405  stream.read((char *)&n, sizeof(n));
406  v.resize(m, n);
407  for (unsigned int i = 0; i < m; i++)
408  for (unsigned int j = 0; j < n; j++)
409  {
410  T r = 0;
411  dataLoad(stream, r, context);
412  v(i, j) = r;
413  }
414 }
PetscInt m
void dataLoad(std::istream &stream, Real &v, void *)
Definition: DataIO.C:235
PetscInt n

◆ dataLoad() [26/32]

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

Definition at line 421 of file DataIO.C.

422 {
423  // Obviously if someone loads data with different LIBMESH_DIM than was used for saving them, it
424  // won't work.
425  for (unsigned int i = 0; i < LIBMESH_DIM; i++)
426  {
427  T r = 0;
428  dataLoad(stream, r, context);
429  v(i) = r;
430  }
431 }
void dataLoad(std::istream &stream, Real &v, void *)
Definition: DataIO.C:235

◆ dataLoad() [27/32]

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

Definition at line 641 of file DataIO.h.

642 {
643  dataLoad(stream, rtt._coords, context);
644 }
void dataLoad(std::istream &stream, T &v, void *)
Definition: DataIO.h:435

◆ dataLoad() [28/32]

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

Definition at line 648 of file DataIO.h.

649 {
650  dataLoad(stream, rtt._vals, context);
651 }
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
void dataLoad(std::istream &stream, T &v, void *)
Definition: DataIO.h:435

◆ dataLoad() [29/32]

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

Definition at line 655 of file DataIO.h.

656 {
657  dataLoad(stream, rft._vals, context);
658 }
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
void dataLoad(std::istream &stream, T &v, void *)
Definition: DataIO.h:435

◆ dataLoad() [30/32]

template<typename T >
void dataLoad ( std::istream &  stream,
MooseADWrapper< T > &  dn_wrapper,
void *  context 
)
inline

Definition at line 662 of file DataIO.h.

663 {
664  dataLoad(stream, dn_wrapper.value(), context);
665  unsigned int n = 0;
666  stream.read((char *)&n, sizeof(n));
667  if (n)
668  {
669  dn_wrapper._dual_number = libmesh_make_unique<typename MooseADWrapper<T>::DNType>();
670  dataLoad(stream, *dn_wrapper._dual_number, context);
671  }
672 }
const T & value() const
Returns the value for any case where a MaterialProperty is requested as a regular (non-AD) property...
PetscInt n
void dataLoad(std::istream &stream, T &v, void *)
Definition: DataIO.h:435
std::unique_ptr< T > _dual_number

◆ dataLoad() [31/32]

template<>
void dataLoad ( std::istream &  stream,
Backup *&  backup,
void *  context 
)
inline

Definition at line 815 of file DataIO.h.

816 {
817  dataLoad(stream, backup->_system_data, context);
818 
819  for (unsigned int i = 0; i < backup->_restartable_data.size(); i++)
820  dataLoad(stream, backup->_restartable_data[i], context);
821 }
std::stringstream _system_data
Stream for holding binary blob data for the simulation.
Definition: Backup.h:28
std::vector< std::unique_ptr< std::stringstream > > _restartable_data
Vector of streams for holding individual thread data for the simulation.
Definition: Backup.h:33
void dataLoad(std::istream &stream, T &v, void *)
Definition: DataIO.h:435

◆ dataLoad() [32/32]

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

Definition at line 437 of file DataIO.C.

438 {
439  for (unsigned int i = 0; i < LIBMESH_DIM; i++)
440  {
441  Real r = 0;
442  dataLoad(stream, r, context);
443  p(i) = r;
444  }
445 }
void dataLoad(std::istream &stream, Real &v, void *)
Definition: DataIO.C:235

◆ dataStore() [1/33]

template<typename T >
void dataStore ( std::ostream &  stream,
T &  v,
void *   
)
inline

Definition at line 161 of file DataIO.h.

Referenced by dataStore(), and storeHelper().

162 {
163 #ifdef LIBMESH_HAVE_CXX11_TYPE_TRAITS
164  static_assert(std::is_polymorphic<T>::value == false,
165  "Cannot serialize a class that has virtual "
166  "members!\nWrite a custom dataStore() "
167  "template specialization!\n\n");
168  static_assert(std::is_trivially_copyable<T>::value,
169  "Cannot serialize a class that is not trivially copyable!\nWrite a custom "
170  "dataStore() template specialization!\n\n");
171 #endif
172 
173  // Moose::out<<"Generic dataStore"<<std::endl;
174  stream.write((char *)&v, sizeof(v));
175 }

◆ dataStore() [2/33]

template<typename T >
void dataStore ( std::ostream &  ,
T *&  ,
void *   
)
inline

Definition at line 179 of file DataIO.h.

180 {
181  mooseError("Attempting to store a raw pointer type: \"",
182  demangle(typeid(T).name()),
183  " *\" as restartable data!\nWrite a custom dataStore() template specialization!\n\n");
184 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:207

◆ dataStore() [3/33]

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

Definition at line 222 of file DataIO.C.

223 {
224  for (unsigned int i = 0; i < LIBMESH_DIM; i++)
225  {
226  Real r = p(i);
227  dataStore(stream, r, context);
228  }
229 }
void dataStore(std::ostream &stream, Real &v, void *)
Definition: DataIO.C:23

◆ dataStore() [4/33]

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

Definition at line 190 of file DataIO.h.

191 {
192  storeHelper(stream, p.first, context);
193  storeHelper(stream, p.second, context);
194 }
void storeHelper(std::ostream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:677

◆ dataStore() [5/33]

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

Definition at line 198 of file DataIO.h.

199 {
200  // First store the size of the vector
201  unsigned int size = v.size();
202  stream.write((char *)&size, sizeof(size));
203 
204  for (unsigned int i = 0; i < size; i++)
205  storeHelper(stream, v[i], context);
206 }
void storeHelper(std::ostream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:677

◆ dataStore() [6/33]

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

Definition at line 210 of file DataIO.h.

211 {
212  T * tmp = v.get();
213 
214  storeHelper(stream, tmp, context);
215 }
void storeHelper(std::ostream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:677

◆ dataStore() [7/33]

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

Definition at line 219 of file DataIO.h.

220 {
221  T * tmp = v.get();
222 
223  storeHelper(stream, tmp, context);
224 }
void storeHelper(std::ostream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:677

◆ dataStore() [8/33]

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

Definition at line 228 of file DataIO.h.

229 {
230  // First store the size of the set
231  unsigned int size = s.size();
232  stream.write((char *)&size, sizeof(size));
233 
234  typename std::set<T>::iterator it = s.begin();
235  typename std::set<T>::iterator end = s.end();
236 
237  for (; it != end; ++it)
238  {
239  T & x = const_cast<T &>(*it);
240  storeHelper(stream, x, context);
241  }
242 }
static PetscErrorCode Vec x
void storeHelper(std::ostream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:677

◆ dataStore() [9/33]

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

Definition at line 246 of file DataIO.h.

247 {
248  // First store the size of the set
249  unsigned int size = l.size();
250  stream.write((char *)&size, sizeof(size));
251 
252  typename std::list<T>::iterator it = l.begin();
253  typename std::list<T>::iterator end = l.end();
254 
255  for (; it != end; ++it)
256  {
257  T & x = const_cast<T &>(*it);
258  storeHelper(stream, x, context);
259  }
260 }
static PetscErrorCode Vec x
void storeHelper(std::ostream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:677

◆ dataStore() [10/33]

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

Definition at line 264 of file DataIO.h.

265 {
266  // First store the size of the map
267  unsigned int size = m.size();
268  stream.write((char *)&size, sizeof(size));
269 
270  typename std::map<T, U>::iterator it = m.begin();
271  typename std::map<T, U>::iterator end = m.end();
272 
273  for (; it != end; ++it)
274  {
275  T & key = const_cast<T &>(it->first);
276 
277  storeHelper(stream, key, context);
278 
279  storeHelper(stream, it->second, context);
280  }
281 }
void storeHelper(std::ostream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:677
PetscInt m

◆ dataStore() [11/33]

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

Definition at line 285 of file DataIO.h.

286 {
287  // First store the size of the map
288  unsigned int size = m.size();
289  stream.write((char *)&size, sizeof(size));
290 
291  typename std::unordered_map<T, U>::iterator it = m.begin();
292  typename std::unordered_map<T, U>::iterator end = m.end();
293 
294  for (; it != end; ++it)
295  {
296  T & key = const_cast<T &>(it->first);
297 
298  storeHelper(stream, key, context);
299 
300  storeHelper(stream, it->second, context);
301  }
302 }
void storeHelper(std::ostream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:677
PetscInt m

◆ dataStore() [12/33]

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

Definition at line 306 of file DataIO.h.

307 {
308  // First store the size of the map
309  unsigned int size = m.size();
310  stream.write((char *)&size, sizeof(size));
311 
312  typename HashMap<T, U>::iterator it = m.begin();
313  typename HashMap<T, U>::iterator end = m.end();
314 
315  for (; it != end; ++it)
316  {
317  T & key = const_cast<T &>(it->first);
318 
319  storeHelper(stream, key, context);
320 
321  storeHelper(stream, it->second, context);
322  }
323 }
HashMap is an abstraction for dictionary data type, we make it thread-safe by locking inserts...
Definition: HashMap.h:18
void storeHelper(std::ostream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:677
PetscInt m

◆ dataStore() [13/33]

template<>
void dataStore ( std::ostream &  stream,
Real &  v,
void *   
)

Definition at line 23 of file DataIO.C.

Referenced by dataStore().

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

◆ dataStore() [14/33]

template<>
void dataStore ( std::ostream &  stream,
std::string &  v,
void *   
)

Definition at line 30 of file DataIO.C.

31 {
32  // Write the size of the string
33  unsigned int size = v.size();
34  stream.write((char *)&size, sizeof(size));
35 
36  // Write the string (Do not store the null byte)
37  stream.write(v.c_str(), sizeof(char) * size);
38 }

◆ dataStore() [15/33]

template<>
void dataStore ( std::ostream &  stream,
ColumnMajorMatrix v,
void *   
)

Definition at line 42 of file DataIO.C.

43 {
44  for (unsigned int i = 0; i < v.m(); i++)
45  for (unsigned int j = 0; j < v.n(); j++)
46  {
47  Real r = v(i, j);
48  stream.write((char *)&r, sizeof(r));
49  }
50 }
unsigned int m() const
Returns the number of columns.
unsigned int n() const
Returns the number of rows.

◆ dataStore() [16/33]

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

Definition at line 86 of file DataIO.C.

87 {
88  // TODO: Write out the unique ID of this elem
89  dof_id_type id = libMesh::DofObject::invalid_id;
90 
91  if (e)
92  {
93  id = e->id();
94  if (id == libMesh::DofObject::invalid_id)
95  mooseError("Can't output Elems with invalid ids!");
96  }
97 
98  storeHelper(stream, id, context);
99 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:207
void storeHelper(std::ostream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:677

◆ dataStore() [17/33]

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

Definition at line 103 of file DataIO.C.

104 {
105  // TODO: Write out the unique ID of this node
106  dof_id_type id = libMesh::DofObject::invalid_id;
107 
108  if (n)
109  {
110  id = n->id();
111  if (id == libMesh::DofObject::invalid_id)
112  mooseError("Can't output Nodes with invalid ids!");
113  }
114 
115  storeHelper(stream, id, context);
116 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:207
void storeHelper(std::ostream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:677
PetscInt n

◆ dataStore() [18/33]

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

Definition at line 120 of file DataIO.C.

121 {
122  // TODO: Write out the unique ID of this elem
123  dof_id_type id = libMesh::DofObject::invalid_id;
124 
125  if (e)
126  {
127  id = e->id();
128  if (id == libMesh::DofObject::invalid_id)
129  mooseError("Can't output Elems with invalid ids!");
130  }
131 
132  storeHelper(stream, id, context);
133 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:207
void storeHelper(std::ostream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:677

◆ dataStore() [19/33]

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

Definition at line 137 of file DataIO.C.

138 {
139  // TODO: Write out the unique ID of this node
140  dof_id_type id = libMesh::DofObject::invalid_id;
141 
142  if (n)
143  {
144  id = n->id();
145  if (id == libMesh::DofObject::invalid_id)
146  mooseError("Can't output Nodes with invalid ids!");
147  }
148 
149  storeHelper(stream, id, context);
150 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:207
void storeHelper(std::ostream &stream, P &data, void *context)
Scalar helper routine.
Definition: DataIO.h:677
PetscInt n

◆ dataStore() [20/33]

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

Definition at line 154 of file DataIO.C.

155 {
156  const std::string & s_str = s.str();
157 
158  size_t s_size = s_str.size();
159  stream.write((char *)&s_size, sizeof(s_size));
160 
161  stream.write(s_str.c_str(), sizeof(char) * (s_str.size()));
162 }

◆ dataStore() [21/33]

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

Definition at line 166 of file DataIO.C.

167 {
168  dataStore(stream, *s, context);
169 }
void dataStore(std::ostream &stream, Real &v, void *)
Definition: DataIO.C:23

◆ dataStore() [22/33]

template<>
void dataStore ( std::ostream &  stream,
DualReal dn,
void *  context 
)

Definition at line 75 of file DataIO.C.

76 {
77  dataStore(stream, dn.value(), context);
78 
79  auto & derivatives = dn.derivatives();
80  for (MooseIndex(derivatives) i = 0; i < derivatives.size(); ++i)
81  dataStore(stream, derivatives[i], context);
82 }
void dataStore(std::ostream &stream, Real &v, void *)
Definition: DataIO.C:23

◆ dataStore() [23/33]

template<std::size_t N>
void dataStore ( std::ostream &  stream,
DualReal(&)  dn[N],
void *  context 
)
inline

Definition at line 349 of file DataIO.h.

350 {
351  for (std::size_t i = 0; i < N; ++i)
352  dataStore(stream, dn[i], context);
353 }
PetscInt N
void dataStore(std::ostream &stream, T &v, void *)
Definition: DataIO.h:161

◆ dataStore() [24/33]

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

Definition at line 357 of file DataIO.h.

358 {
359  v.close();
360 
361  numeric_index_type size = v.local_size();
362 
363  for (numeric_index_type i = v.first_local_index(); i < v.first_local_index() + size; i++)
364  {
365  T r = v(i);
366  dataStore(stream, r, context);
367  }
368 }
void dataStore(std::ostream &stream, T &v, void *)
Definition: DataIO.h:161

◆ dataStore() [25/33]

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

Definition at line 372 of file DataIO.h.

373 {
374  unsigned int m = v.size();
375  stream.write((char *)&m, sizeof(m));
376  for (unsigned int i = 0; i < v.size(); i++)
377  {
378  T r = v(i);
379  dataStore(stream, r, context);
380  }
381 }
PetscInt m
void dataStore(std::ostream &stream, T &v, void *)
Definition: DataIO.h:161

◆ dataStore() [26/33]

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

Definition at line 173 of file DataIO.C.

174 {
175  for (unsigned int i = 0; i < LIBMESH_DIM; i++)
176  for (unsigned int j = 0; i < LIBMESH_DIM; i++)
177  {
178  T r = v(i, j);
179  dataStore(stream, r, context);
180  }
181 }
void dataStore(std::ostream &stream, Real &v, void *)
Definition: DataIO.C:23

◆ dataStore() [27/33]

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

Definition at line 188 of file DataIO.C.

189 {
190  unsigned int m = v.m();
191  unsigned int n = v.n();
192  stream.write((char *)&m, sizeof(m));
193  stream.write((char *)&n, sizeof(n));
194  for (unsigned int i = 0; i < m; i++)
195  for (unsigned int j = 0; j < n; j++)
196  {
197  T r = v(i, j);
198  dataStore(stream, r, context);
199  }
200 }
PetscInt m
PetscInt n
void dataStore(std::ostream &stream, Real &v, void *)
Definition: DataIO.C:23

◆ dataStore() [28/33]

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

Definition at line 207 of file DataIO.C.

208 {
209  // Obviously if someone loads data with different LIBMESH_DIM than was used for saving them, it
210  // won't work.
211  for (unsigned int i = 0; i < LIBMESH_DIM; i++)
212  {
213  T r = v(i);
214  dataStore(stream, r, context);
215  }
216 }
void dataStore(std::ostream &stream, Real &v, void *)
Definition: DataIO.C:23

◆ dataStore() [29/33]

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

Definition at line 394 of file DataIO.h.

395 {
396  dataStore(stream, rtt._coords, context);
397 }
void dataStore(std::ostream &stream, T &v, void *)
Definition: DataIO.h:161

◆ dataStore() [30/33]

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

Definition at line 401 of file DataIO.h.

402 {
403  dataStore(stream, rtt._vals, context);
404 }
T _vals[N3]
The values of the rank-three tensor stored by index=((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) ...
void dataStore(std::ostream &stream, T &v, void *)
Definition: DataIO.h:161

◆ dataStore() [31/33]

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

Definition at line 408 of file DataIO.h.

409 {
410  dataStore(stream, rft._vals, context);
411 }
T _vals[N4]
The values of the rank-four tensor stored by index=(((i * LIBMESH_DIM + j) * LIBMESH_DIM + k) * LIBME...
void dataStore(std::ostream &stream, T &v, void *)
Definition: DataIO.h:161

◆ dataStore() [32/33]

template<typename T >
void dataStore ( std::ostream &  stream,
MooseADWrapper< T > &  dn_wrapper,
void *  context 
)
inline

Definition at line 415 of file DataIO.h.

416 {
417  dataStore(stream, dn_wrapper.value(), context);
418  if (dn_wrapper._dual_number)
419  {
420  unsigned int m = 1;
421  stream.write((char *)&m, sizeof(m));
422  dataStore(stream, *dn_wrapper._dual_number, context);
423  }
424  else
425  {
426  unsigned int m = 0;
427  stream.write((char *)&m, sizeof(m));
428  }
429 }
PetscInt m
const T & value() const
Returns the value for any case where a MaterialProperty is requested as a regular (non-AD) property...
void dataStore(std::ostream &stream, T &v, void *)
Definition: DataIO.h:161
std::unique_ptr< T > _dual_number

◆ dataStore() [33/33]

template<>
void dataStore ( std::ostream &  stream,
Backup *&  backup,
void *  context 
)
inline

Definition at line 805 of file DataIO.h.

806 {
807  dataStore(stream, backup->_system_data, context);
808 
809  for (unsigned int i = 0; i < backup->_restartable_data.size(); i++)
810  dataStore(stream, backup->_restartable_data[i], context);
811 }
std::stringstream _system_data
Stream for holding binary blob data for the simulation.
Definition: Backup.h:28
void dataStore(std::ostream &stream, T &v, void *)
Definition: DataIO.h:161
std::vector< std::unique_ptr< std::stringstream > > _restartable_data
Vector of streams for holding individual thread data for the simulation.
Definition: Backup.h:33

◆ loadHelper() [1/8]

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

Scalar helper routine.

Definition at line 741 of file DataIO.h.

Referenced by dataLoad(), RestartableDataIO::deserializeSystems(), RestartableData< T >::load(), and MaterialProperty< Real >::load().

742 {
743  dataLoad(stream, data, context);
744 }
void dataLoad(std::istream &stream, T &v, void *)
Definition: DataIO.h:435

◆ loadHelper() [2/8]

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

Vector helper routine.

Definition at line 749 of file DataIO.h.

750 {
751  dataLoad(stream, data, context);
752 }
void dataLoad(std::istream &stream, T &v, void *)
Definition: DataIO.h:435

◆ loadHelper() [3/8]

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

Shared Pointer helper routine.

Definition at line 757 of file DataIO.h.

758 {
759  dataLoad(stream, data, context);
760 }
void dataLoad(std::istream &stream, T &v, void *)
Definition: DataIO.h:435

◆ loadHelper() [4/8]

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

Unique Pointer helper routine.

Definition at line 765 of file DataIO.h.

766 {
767  dataLoad(stream, data, context);
768 }
void dataLoad(std::istream &stream, T &v, void *)
Definition: DataIO.h:435

◆ loadHelper() [5/8]

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

Set helper routine.

Definition at line 773 of file DataIO.h.

774 {
775  dataLoad(stream, data, context);
776 }
void dataLoad(std::istream &stream, T &v, void *)
Definition: DataIO.h:435

◆ loadHelper() [6/8]

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

Map helper routine.

Definition at line 781 of file DataIO.h.

782 {
783  dataLoad(stream, data, context);
784 }
void dataLoad(std::istream &stream, T &v, void *)
Definition: DataIO.h:435

◆ loadHelper() [7/8]

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 789 of file DataIO.h.

790 {
791  dataLoad(stream, data, context);
792 }
void dataLoad(std::istream &stream, T &v, void *)
Definition: DataIO.h:435

◆ loadHelper() [8/8]

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

Hashmap helper routine.

Definition at line 797 of file DataIO.h.

798 {
799  dataLoad(stream, data, context);
800 }
void dataLoad(std::istream &stream, T &v, void *)
Definition: DataIO.h:435

◆ storeHelper() [1/8]

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

Scalar helper routine.

Definition at line 677 of file DataIO.h.

Referenced by dataStore(), RestartableDataIO::serializeSystems(), RestartableData< T >::store(), and MaterialProperty< Real >::store().

678 {
679  dataStore(stream, data, context);
680 }
void dataStore(std::ostream &stream, T &v, void *)
Definition: DataIO.h:161

◆ storeHelper() [2/8]

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

Vector helper routine.

Definition at line 685 of file DataIO.h.

686 {
687  dataStore(stream, data, context);
688 }
void dataStore(std::ostream &stream, T &v, void *)
Definition: DataIO.h:161

◆ storeHelper() [3/8]

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

Shared pointer helper routine.

Definition at line 693 of file DataIO.h.

694 {
695  dataStore(stream, data, context);
696 }
void dataStore(std::ostream &stream, T &v, void *)
Definition: DataIO.h:161

◆ storeHelper() [4/8]

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

Unique pointer helper routine.

Definition at line 701 of file DataIO.h.

702 {
703  dataStore(stream, data, context);
704 }
void dataStore(std::ostream &stream, T &v, void *)
Definition: DataIO.h:161

◆ storeHelper() [5/8]

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

Set helper routine.

Definition at line 709 of file DataIO.h.

710 {
711  dataStore(stream, data, context);
712 }
void dataStore(std::ostream &stream, T &v, void *)
Definition: DataIO.h:161

◆ storeHelper() [6/8]

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

Map helper routine.

Definition at line 717 of file DataIO.h.

718 {
719  dataStore(stream, data, context);
720 }
void dataStore(std::ostream &stream, T &v, void *)
Definition: DataIO.h:161

◆ storeHelper() [7/8]

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 725 of file DataIO.h.

726 {
727  dataStore(stream, data, context);
728 }
void dataStore(std::ostream &stream, T &v, void *)
Definition: DataIO.h:161

◆ storeHelper() [8/8]

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

HashMap helper routine.

Definition at line 733 of file DataIO.h.

734 {
735  dataStore(stream, data, context);
736 }
void dataStore(std::ostream &stream, T &v, void *)
Definition: DataIO.h:161