xdr_cxx.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2026 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
 
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
 
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
 
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 
 
#ifndef LIBMESH_XDR_CXX_H
#define LIBMESH_XDR_CXX_H
 
// Local includes
#include "libmesh/libmesh_common.h"
#include "libmesh/libmesh.h"
#include "libmesh/enum_xdr_mode.h" // READ, WRITE, etc.
 
// C++ includes
#include <memory>
#include <cstdio> // FILE
#ifdef LIBMESH_HAVE_XDR
// I see a redundant declaration warning here on Ubuntu 20.10
#include "libmesh/ignore_warnings.h"
# include <rpc/rpc.h>
# include <rpc/xdr.h>
#include "libmesh/restore_warnings.h"
#endif
 
#include <complex>
#include <iosfwd>
#include <vector>
#include <string>
#include <string_view>
 
const unsigned int xdr_MAX_STRING_LENGTH=256;
 
#ifndef LIBMESH_DEFAULT_SINGLE_PRECISION
#define xdr_REAL xdr_double
#else
#define xdr_REAL xdr_float
#endif
 
namespace libMesh
{
 
class Xdr
{
 
public:
 
  Xdr (std::string name="", const XdrMODE m=UNKNOWN);
 
  Xdr (std::ostream & stream);
  Xdr (std::istream & stream);
 
  ~Xdr ();
 
  void open (std::string name);
 
  void close();
 
  bool is_open() const;
 
  bool is_eof();
 
  bool reading() const { return ((mode == DECODE) || (mode == READ)); }
 
  bool writing() const { return ((mode == ENCODE) || (mode == WRITE)); }
 
  XdrMODE access_mode () const { return mode; }
 
  // Data access methods
 
  template <typename T>
  void data(T & a, std::string_view comment="");
 
  template <typename T>
  Xdr & operator << (T & a) { libmesh_assert (writing()); data(a); return *this; }
 
  template <typename T>
  Xdr & operator >> (T & a) { libmesh_assert (reading()); data(a); return *this; }
 
  template <typename T>
  void data_stream (T * val, const unsigned int len, const unsigned int line_break=libMesh::invalid_uint);
 
  void comment (std::string &);
 
  void set_version(int ver) { version_number = ver; }
 
  int version() const { return version_number; }
 
private:
 
  template <typename T>
  void do_read(T & a);
 
  template <typename T>
  void do_read(std::complex<T> & a);
 
  template <typename T>
  void do_read(std::vector<T> & a);
 
  template <typename T>
  void do_read(std::vector<std::complex<T>> & a);
 
  template <typename T>
  void do_write(T & a);
 
  template <typename T>
  void do_write(std::complex<T> & a);
 
  template <typename T>
  void do_write(std::vector<T> & a);
 
  template <typename T>
  void do_write(std::vector<std::complex<T>> & a);
 
  template <typename T>
  void _complex_data_stream (std::complex<T> * val, const unsigned int len,
                             const unsigned int line_break);
 
  template <typename XFP>
  void _xfp_data_stream (XFP * val, const unsigned int len,
#ifdef LIBMESH_HAVE_XDR
                         xdrproc_t
#else
                         void *
#endif
                           xdr_proc,
                         const unsigned int line_break,
                         const int n_digits);
 
  const XdrMODE mode;
 
  std::string file_name;
 
#ifdef LIBMESH_HAVE_XDR
 
  std::unique_ptr<XDR> xdrs;
 
  FILE * fp;
 
#endif
 
  std::unique_ptr<std::istream> in;
 
  std::unique_ptr<std::ostream> out;
 
  const int comm_len;
  char comm[xdr_MAX_STRING_LENGTH];
 
  bool gzipped_file, bzipped_file, xzipped_file;
 
  int version_number;
};
 
 
} // namespace libMesh
 
 
#endif // LIBMESH_XDR_CXX_H