libMesh::Xdr Class Reference

This class implements a C++ interface to the XDR (eXternal Data Representation) format. More...

#include <xdr_cxx.h>

Public Member Functions
	Xdr (std::string name="", const XdrMODE m=UNKNOWN)
	File-based constructor.
	Xdr (std::ostream &stream)
	Output stream based constructor.
	Xdr (std::istream &stream)
	Input stream based constructor.
	~Xdr ()
	Destructor.
void	open (std::string name)
	Opens the file.
void	close ()
	Closes the file if it is open.
bool	is_open () const
bool	is_eof ()
bool	reading () const
bool	writing () const
XdrMODE	access_mode () const
template<typename T >
void	data (T &a, std::string_view comment="")
	Inputs or outputs a single value.
template<typename T >
Xdr &	operator<< (T &a)
	Same, but provides an ostream like interface.
template<typename T >
Xdr &	operator>> (T &a)
	Same, but provides an istream like interface.
template<typename T >
void	data_stream (T *val, const unsigned int len, const unsigned int line_break=libMesh::invalid_uint)
	Inputs or outputs a raw data stream.
void	comment (std::string &)
	Writes or reads (ignores) a comment line.
void	set_version (int ver)
	Sets the version of the file that is being read.
int	version () const
	Gets the version of the file that is being read.
template<>
void	do_read (std::string &a)
template<>
void	data_stream (double *val, const unsigned int len, const unsigned int line_break)
template<>
void	data_stream (float *val, const unsigned int len, const unsigned int line_break)
template<>
void	data_stream (long double *val, const unsigned int len, const unsigned int line_break)
template<>
void	data_stream (Real *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 xdr_proc, #else void *, #endif const unsigned int line_break, const int n_digits)
template<>
void	data_stream (std::complex< double > *val, const unsigned int len, const unsigned int line_break)
template<>
void	data_stream (std::complex< long double > *val, const unsigned int len, const unsigned int line_break)

Private Member Functions
template<typename T >
void	do_read (T &a)
	Helper method for reading different data types.
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)
	Helper method for writing different data types.
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)
	Helper method for complex types.
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)
	Helper method for extended FP types.

Private Attributes
const XdrMODE	mode
	The mode used for accessing the file.
std::string	file_name
	The file name.
std::unique_ptr< XDR >	xdrs
	Pointer to the standard XDR struct.
FILE *	fp
	File pointer.
std::unique_ptr< std::istream >	in
	The input file stream.
std::unique_ptr< std::ostream >	out
	The output file stream.
const int	comm_len
	A buffer to put comment strings into.
char	comm [xdr_MAX_STRING_LENGTH]
bool	gzipped_file
	Are we reading/writing zipped files?
bool	bzipped_file
bool	xzipped_file
int	version_number
	Version of the file being read.

Detailed Description

This class implements a C++ interface to the XDR (eXternal Data Representation) format.

XDR is useful for creating platform-independent binary files. This class was created to handle equation system output as a replacement for XdrIO since that is somewhat limited.

Author

Benjamin Kirk

Date

2003

C++ interface for the XDR (eXternal Data Representation) format.

Definition at line 67 of file xdr_cxx.h.

Constructor & Destructor Documentation

Xdr() [1/3]

libMesh::Xdr::Xdr	(	std::string	name = "",
		const XdrMODE	m = UNKNOWN
	)

File-based constructor.

Takes the filename and the mode. Valid modes are ENCODE, DECODE, READ, and WRITE.

Definition at line 104 of file xdr_cxx.C.

                           :
  mode(m),
  file_name(std::move(name)),
#ifdef LIBMESH_HAVE_XDR
  fp(nullptr),
#endif
  in(),
  out(),
  comm_len(xdr_MAX_STRING_LENGTH),
  gzipped_file(false),
  bzipped_file(false),
  xzipped_file(false),
  version_number(LIBMESH_VERSION_ID(LIBMESH_MAJOR_VERSION, LIBMESH_MINOR_VERSION, LIBMESH_MICRO_VERSION))
{
  this->open(file_name);
}

References file_name, and open().

Xdr() [2/3]

libMesh::Xdr::Xdr

(

std::ostream &

stream

)

Output stream based constructor.

Assumes mode WRITE.

Definition at line 124 of file xdr_cxx.C.

                             :
  mode(WRITE),
  file_name(),
#ifdef LIBMESH_HAVE_XDR
  fp(nullptr),
#endif
  in(),
  out(std::make_unique<std::ostream>(stream.rdbuf())),
  comm_len(xdr_MAX_STRING_LENGTH),
  gzipped_file(false),
  bzipped_file(false),
  xzipped_file(false),
  version_number(LIBMESH_VERSION_ID(LIBMESH_MAJOR_VERSION, LIBMESH_MINOR_VERSION, LIBMESH_MICRO_VERSION))
{
}

Xdr() [3/3]

libMesh::Xdr::Xdr

(

std::istream &

stream

)

Input stream based constructor.

Assumes mode READ.

Definition at line 142 of file xdr_cxx.C.

                             :
  mode(READ),
  file_name(),
#ifdef LIBMESH_HAVE_XDR
  fp(nullptr),
#endif
  in(std::make_unique<std::istream>(stream.rdbuf())),
  out(),
  comm_len(xdr_MAX_STRING_LENGTH),
  gzipped_file(false),
  bzipped_file(false),
  xzipped_file(false),
  version_number(LIBMESH_VERSION_ID(LIBMESH_MAJOR_VERSION, LIBMESH_MINOR_VERSION, LIBMESH_MICRO_VERSION))
{
}

~Xdr()

libMesh::Xdr::~Xdr

(

)

Destructor.

Closes the file if it is open.

Definition at line 160 of file xdr_cxx.C.

{
  this->close();
}

References close().

Member Function Documentation

_complex_data_stream()

template<typename T >

void libMesh::Xdr::_complex_data_stream ( std::complex< T > *  val, const unsigned int  len, const unsigned int  line_break  )

private

Helper method for complex types.

Definition at line 1248 of file xdr_cxx.C.

{
  switch (mode)
    {
    case ENCODE:
    case DECODE:
      {
#ifdef LIBMESH_HAVE_XDR
 
        libmesh_assert (this->is_open());
 
        // FIXME[JWP]: How to implement this for long double?  Mac OS
        // X defines 'xdr_quadruple' but AFAICT, it does not exist for
        // Linux... for now, reading/writing XDR files with long
        // doubles drops back to double precision, but you can still
        // write long double ASCII files of course.
 
        if (len > 0)
          {
            std::vector<double> io_buffer (2*len);
 
            // Fill io_buffer if we are writing.
            if (mode == ENCODE)
              for (unsigned int i=0, cnt=0; i<len; i++)
                {
                  io_buffer[cnt++] = val[i].real();
                  io_buffer[cnt++] = val[i].imag();
                }
 
            xdr_vector(xdrs.get(),
                       reinterpret_cast<char *>(io_buffer.data()),
                       2*len,
                       sizeof(double),
                       (xdrproc_t) libmesh_xdr_double);
 
            // Fill val array if we are reading.
            if (mode == DECODE)
              for (unsigned int i=0, cnt=0; i<len; i++)
                {
                  double re = io_buffer[cnt++];
                  double im = io_buffer[cnt++];
                  val[i] = std::complex<T>(re, im);
                }
          }
#else
 
        libmesh_error_msg("ERROR: Functionality is not available.\n"    \
                          << "Make sure LIBMESH_HAVE_XDR is defined at build time\n" \
                          << "The XDR interface is not available in this installation");
 
#endif
        return;
      }
 
    case READ:
      {
        libmesh_assert(in.get());
        libmesh_assert (in->good());
 
        for (unsigned int i=0; i<len; i++)
          {
            libmesh_assert(in.get());
            libmesh_assert (in->good());
            T re, im;
            *in >> re >> im;
            val[i] = std::complex<T>(re,im);
          }
 
        return;
      }
 
    case WRITE:
      {
        libmesh_assert(out.get());
        libmesh_assert (out->good());
 
 
        // Save stream flags
        std::ios_base::fmtflags out_flags = out->flags();
 
        // We will use scientific notation with a precision of
        // 'max_digits10' digits in the following output.  The desired
        // precision and format will automatically determine the
        // width.  Note: digit10 is the number of digits (in decimal
        // base) that can be represented without change.  Equivalent
        // to FLT_DIG, DBL_DIG or LDBL_DIG for floating types.
        *out << std::scientific
             << std::setprecision(std::numeric_limits<T>::max_digits10);
 
        if (line_break == libMesh::invalid_uint)
          for (unsigned int i=0; i<len; i++)
            {
              libmesh_assert(out.get());
              libmesh_assert (out->good());
              *out << val[i].real() << ' ' << val[i].imag() << ' ';
            }
        else
          {
            const unsigned imax = std::min(line_break, len);
            unsigned int cnt=0;
            while (cnt < len)
              {
                for (unsigned int i=0; (i<imax && cnt<len); i++)
                  {
                    libmesh_assert(out.get());
                    libmesh_assert (out->good());
                    *out << val[cnt].real() << ' ' << val[cnt].imag();
                    cnt++;
 
                    // Write a space unless this is the last character on the current line.
                    if (i+1 != imax)
                      *out << " ";
                  }
                libmesh_assert(out.get());
                libmesh_assert (out->good());
                *out << '\n';
              }
          }
 
        // Restore stream flags
        out->flags(out_flags);
 
        return;
      }
 
    default:
      libmesh_error_msg("Invalid mode = " << mode);
    }
}

References libMesh::DECODE, libMesh::ENCODE, in, libMesh::invalid_uint, is_open(), libMesh::libmesh_assert(), mode, out, libMesh::READ, libMesh::WRITE, and xdrs.

Referenced by data_stream(), and data_stream().

_xfp_data_stream() [1/2]

template<typename XFP >

void libMesh::Xdr::_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  )

private

Helper method for extended FP types.

Referenced by data_stream(), data_stream(), data_stream(), and data_stream().

_xfp_data_stream() [2/2]

template<typename XFP >

void libMesh::Xdr::_xfp_data_stream	(	XFP *	val,
		const unsigned int	len,
		#ifdef LIBMESH_HAVE_XDR xdrproc_t	xdr_proc,
		#else void *	,
		#endif const unsigned int	line_break,
		const int	n_digits
	)

Definition at line 1090 of file xdr_cxx.C.

{
  switch (mode)
    {
    case ENCODE:
    case DECODE:
      {
#ifdef LIBMESH_HAVE_XDR
        libmesh_assert (this->is_open());
 
        if (len > 0)
          {
            if (xdr_proc)
              {
                xdr_vector(xdrs.get(),
                           (char *) val,
                           len,
                           sizeof(XFP),
                           xdr_proc);
                return;
              }
 
            // FIXME[JWP]: How to implement this for long double?  Mac
            // OS X defines 'xdr_quadruple' but AFAICT, it does not
            // exist for Linux... for now, reading/writing XDR files
            // with long doubles drops back to double precision, but
            // you can still write long double ASCII files of course.
 
            // FIXME[RHS]: 128 bit FP has the same problem as long
            // double, only much worse since even _Quad/__float128
            // aren't standard either.
 
            std::vector<double> io_buffer (len);
 
            // Fill io_buffer if we are writing.
            if (mode == ENCODE)
              for (unsigned int i=0, cnt=0; i<len; i++)
                io_buffer[cnt++] = double(val[i]);
 
            xdr_vector(xdrs.get(),
                       reinterpret_cast<char *>(io_buffer.data()),
                       len,
                       sizeof(double),
                       (xdrproc_t) libmesh_xdr_double);
 
            // Fill val array if we are reading.
            if (mode == DECODE)
              for (unsigned int i=0, cnt=0; i<len; i++)
                {
                  val[i] = io_buffer[cnt++];
                }
          }
 
#else
 
        libmesh_error_msg("ERROR: Functionality is not available.\n"    \
                          << "Make sure LIBMESH_HAVE_XDR is defined at build time\n" \
                          << "The XDR interface is not available in this installation");
 
#endif
        return;
      }
 
    case READ:
      {
        libmesh_assert(in.get());
        libmesh_assert (in->good());
 
        for (unsigned int i=0; i<len; i++)
          {
            libmesh_assert(in.get());
            libmesh_assert (in->good());
            *in >> val[i];
          }
 
        return;
      }
 
    case WRITE:
      {
        libmesh_assert(out.get());
        libmesh_assert (out->good());
 
        // Save stream flags
        std::ios_base::fmtflags out_flags = out->flags();
 
        // We will use scientific notation with specified digit
        // count in the following output.  The desired precision and
        // format will automatically determine the width.
        *out << std::scientific
             << std::setprecision(n_digits);
 
        if (line_break == libMesh::invalid_uint)
          for (unsigned int i=0; i<len; i++)
            {
              libmesh_assert(out.get());
              libmesh_assert (out->good());
              *out << val[i] << ' ';
            }
        else
          {
            const unsigned imax = std::min(line_break, len);
            unsigned int cnt=0;
            while (cnt < len)
              {
                for (unsigned int i=0; (i<imax && cnt<len); i++)
                  {
                    libmesh_assert(out.get());
                    libmesh_assert (out->good());
                    *out << val[cnt++];
 
                    // Write a space unless this is the last character on the current line.
                    if (i+1 != imax)
                      *out << " ";
                  }
                libmesh_assert(out.get());
                libmesh_assert (out->good());
                *out << '\n';
              }
          }
 
        // Restore stream flags
        out->flags(out_flags);
 
        return;
      }
 
    default:
      libmesh_error_msg("Invalid mode = " << mode);
    }
}

References libMesh::DECODE, libMesh::ENCODE, in, libMesh::invalid_uint, is_open(), libMesh::libmesh_assert(), mode, out, libMesh::READ, libMesh::WRITE, and xdrs.

access_mode()

XdrMODE libMesh::Xdr::access_mode ( ) const

inline

Returns

The mode used to access the file. Valid modes are ENCODE, DECODE, READ, or WRITE.

Definition at line 135 of file xdr_cxx.h.

{ return mode; }

References mode.

close()

void libMesh::Xdr::close

(

)

Closes the file if it is open.

Definition at line 278 of file xdr_cxx.C.

{
  switch (mode)
    {
    case ENCODE:
    case DECODE:
      {
#ifdef LIBMESH_HAVE_XDR
 
        if (xdrs)
          {
            xdr_destroy (xdrs.get());
            xdrs.reset();
          }
 
        if (fp)
          {
            fflush(fp);
            fclose(fp);
            fp = nullptr;
          }
#else
 
        libmesh_error_msg("ERROR: Functionality is not available.\n" \
                          << "Make sure LIBMESH_HAVE_XDR is defined at build time\n" \
                          << "The XDR interface is not available in this installation");
 
#endif
        file_name = "";
        return;
      }
 
    case READ:
      {
        if (in.get() != nullptr)
          {
            in.reset();
 
            if (bzipped_file || xzipped_file)
              remove_unzipped_file(file_name);
          }
        file_name = "";
        return;
      }
 
    case WRITE:
      {
        if (out.get() != nullptr)
          {
            out.reset();
 
            if (bzipped_file)
              bzip_file(std::string(file_name.begin(), file_name.end()-4));
 
            else if (xzipped_file)
              xzip_file(std::string(file_name.begin(), file_name.end()-3));
          }
        file_name = "";
        return;
      }
 
    default:
      libmesh_error_msg("Invalid mode = " << mode);
    }
}

References bzipped_file, libMesh::DECODE, libMesh::ENCODE, file_name, fp, in, mode, out, libMesh::READ, libMesh::WRITE, xdrs, and xzipped_file.

Referenced by libMesh::RBEvaluation::legacy_read_offline_data_from_files(), libMesh::TransientRBEvaluation::legacy_read_offline_data_from_files(), libMesh::RBSCMEvaluation::legacy_read_offline_data_from_files(), libMesh::RBEvaluation::legacy_write_offline_data_to_files(), libMesh::RBSCMEvaluation::legacy_write_offline_data_to_files(), libMesh::TransientRBEvaluation::legacy_write_offline_data_to_files(), libMesh::CheckpointIO::read(), libMesh::EquationSystems::read(), libMesh::RBParametrized::read_parameter_ranges_from_file(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), libMesh::EquationSystems::write(), libMesh::RBParametrized::write_parameter_ranges_to_file(), and ~Xdr().

comment()

void libMesh::Xdr::comment

(

std::string &

comment_in

)

Writes or reads (ignores) a comment line.

Definition at line 1380 of file xdr_cxx.C.

{
  switch (mode)
    {
    case ENCODE:
    case DECODE:
      {
        return;
      }
 
    case READ:
      {
        libmesh_assert(in.get());
        libmesh_assert (in->good());
        in->getline(comm, comm_len);
        return;
      }
 
    case WRITE:
      {
        libmesh_assert(out.get());
        libmesh_assert (out->good());
        *out << "\t " << comment_in << '\n';
        return;
      }
 
    default:
      libmesh_error_msg("Invalid mode = " << mode);
    }
}

References comm, comm_len, libMesh::DECODE, libMesh::ENCODE, in, libMesh::libmesh_assert(), mode, out, libMesh::READ, and libMesh::WRITE.

Referenced by libMesh::System::read_serialized_data(), and libMesh::System::write_serialized_data().

data()

template<typename T >

template LIBMESH_EXPORT void libMesh::Xdr::data< Real >	(	T &	a,
		std::string_view	comment = ""
	)

Inputs or outputs a single value.

Definition at line 860 of file xdr_cxx.C.

{
  switch (mode)
    {
    case ENCODE:
    case DECODE:
      {
#ifdef LIBMESH_HAVE_XDR
 
        libmesh_assert (is_open());
 
        xdr_translate(xdrs.get(), a);
 
#else
 
        libmesh_error_msg("ERROR: Functionality is not available.\n"    \
                          << "Make sure LIBMESH_HAVE_XDR is defined at build time\n" \
                          << "The XDR interface is not available in this installation");
 
#endif
        return;
      }
 
    case READ:
      {
        libmesh_assert(in.get());
        libmesh_assert (in->good());
 
        this->do_read(a);
 
        return;
      }
 
    case WRITE:
      {
        libmesh_assert(out.get());
        libmesh_assert (out->good());
 
        // We will use scientific notation sufficient to exactly
        // represent our floating point precision in the following
        // output.  The desired precision and format will
        // automatically determine the width.
        *out << std::scientific
             << std::setprecision(std::numeric_limits<T>::max_digits10);
 
        this->do_write(a);
 
        // If there's a comment provided, write a tab character and
        // then the comment.
        if (comment_in != "")
          *out << "\t " << comment_in;
 
        // Go to the next line.
        *out << '\n';
 
        return;
      }
 
    default:
      libmesh_error_msg("Invalid mode = " << mode);
    }
}

References libMesh::DECODE, do_read(), do_write(), libMesh::ENCODE, in, is_open(), libMesh::libmesh_assert(), mode, out, libMesh::READ, libMesh::WRITE, and xdrs.

Referenced by do_read(), do_read(), do_write(), do_write(), operator<<(), operator>>(), libMesh::XdrIO::read(), libMesh::EquationSystems::read(), libMesh::CheckpointIO::read_bc_names(), libMesh::CheckpointIO::read_bcs(), libMesh::CheckpointIO::read_connectivity(), libMesh::CheckpointIO::read_header(), libMesh::System::read_header(), libMesh::XdrIO::read_header(), libMesh::RBEIMEvaluation::read_in_interior_basis_functions(), libMesh::RBEIMEvaluation::read_in_node_basis_functions(), libMesh::RBEIMEvaluation::read_in_side_basis_functions(), libMesh::RBEvaluation::read_in_vectors_from_multiple_files(), libMesh::CheckpointIO::read_integers_names(), libMesh::CheckpointIO::read_nodes(), libMesh::CheckpointIO::read_nodesets(), libMesh::System::read_parallel_data(), libMesh::CheckpointIO::read_remote_elem(), libMesh::XdrIO::read_serialized_bc_names(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::XdrIO::read_serialized_subdomain_names(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::CheckpointIO::read_subdomain_names(), libMesh::CheckpointIO::select_split_config(), libMesh::XdrIO::write(), libMesh::CheckpointIO::write(), libMesh::EquationSystems::write(), libMesh::CheckpointIO::write_bc_names(), libMesh::CheckpointIO::write_bcs(), libMesh::CheckpointIO::write_connectivity(), libMesh::System::write_header(), libMesh::CheckpointIO::write_nodes(), libMesh::CheckpointIO::write_nodesets(), libMesh::RBEIMEvaluation::write_out_node_basis_functions(), libMesh::RBEIMEvaluation::write_out_side_basis_functions(), libMesh::System::write_parallel_data(), libMesh::CheckpointIO::write_remote_elem(), libMesh::XdrIO::write_serialized_bc_names(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::XdrIO::write_serialized_subdomain_names(), libMesh::System::write_serialized_vector(), libMesh::System::write_serialized_vectors(), and libMesh::CheckpointIO::write_subdomain_names().

data_stream() [1/7]

template<>

void libMesh::Xdr::data_stream	(	double *	val,
		const unsigned int	len,
		const unsigned int	line_break
	)

Definition at line 1041 of file xdr_cxx.C.

{
  this->_xfp_data_stream
    (val, len,
#ifdef LIBMESH_HAVE_XDR
     (xdrproc_t)libmesh_xdr_double,
#else
     nullptr,
#endif
     line_break, std::numeric_limits<double>::max_digits10);
}

References _xfp_data_stream().

data_stream() [2/7]

template<>

void libMesh::Xdr::data_stream	(	float *	val,
		const unsigned int	len,
		const unsigned int	line_break
	)

Definition at line 1056 of file xdr_cxx.C.

{
  this->_xfp_data_stream
    (val, len,
#ifdef LIBMESH_HAVE_XDR
     (xdrproc_t)libmesh_xdr_float,
#else
     nullptr,
#endif
     line_break, std::numeric_limits<float>::max_digits10);
}

References _xfp_data_stream().

data_stream() [3/7]

template<>

void libMesh::Xdr::data_stream	(	long double *	val,
		const unsigned int	len,
		const unsigned int	line_break
	)

Definition at line 1071 of file xdr_cxx.C.

{
  this->_xfp_data_stream
    (val, len, nullptr, line_break,
     std::numeric_limits<long double>::max_digits10);
}

References _xfp_data_stream().

data_stream() [4/7]

template<>

void libMesh::Xdr::data_stream	(	Real *	val,
		const unsigned int	len,
		const unsigned int	line_break
	)

Definition at line 1081 of file xdr_cxx.C.

{
  this->_xfp_data_stream(val, len, nullptr, line_break, 36);
}

References _xfp_data_stream().

data_stream() [5/7]

template<>

void libMesh::Xdr::data_stream	(	std::complex< double > *	val,
		const unsigned int	len,
		const unsigned int	line_break
	)

Definition at line 1232 of file xdr_cxx.C.

{
  this->_complex_data_stream(val, len, line_break);
}

References _complex_data_stream().

data_stream() [6/7]

template<>

void libMesh::Xdr::data_stream	(	std::complex< long double > *	val,
		const unsigned int	len,
		const unsigned int	line_break
	)

Definition at line 1240 of file xdr_cxx.C.

{
  this->_complex_data_stream(val, len, line_break);
}

References _complex_data_stream().

data_stream() [7/7]

template<typename T >

void libMesh::Xdr::data_stream	(	T *	val,
		const unsigned int	len,
		const unsigned int	line_break = libMesh::invalid_uint
	)

Inputs or outputs a raw data stream.

Definition at line 925 of file xdr_cxx.C.

{
  switch (mode)
    {
    case ENCODE:
      {
#ifdef LIBMESH_HAVE_XDR
 
        libmesh_assert (this->is_open());
 
        unsigned int size_of_type = cast_int<unsigned int>(sizeof(T));
 
        xdr_vector(xdrs.get(),
                   (char *) val,
                   len,
                   size_of_type,
                   xdr_translator<T>());
#else
        libmesh_error_msg("ERROR: Functionality is not available.\n"    \
                          << "Make sure LIBMESH_HAVE_XDR is defined at build time\n" \
                          << "The XDR interface is not available in this installation");
 
#endif
        return;
      }
 
    case DECODE:
      {
#ifdef LIBMESH_HAVE_XDR
 
        libmesh_assert (this->is_open());
 
        unsigned int size_of_type = cast_int<unsigned int>(sizeof(T));
 
        if (len > 0)
          xdr_vector(xdrs.get(),
                     (char *) val,
                     len,
                     size_of_type,
                     xdr_translator<T>());
#else
        libmesh_error_msg("ERROR: Functionality is not available.\n"    \
                          << "Make sure LIBMESH_HAVE_XDR is defined at build time\n" \
                          << "The XDR interface is not available in this installation");
 
#endif
        return;
      }
 
    case READ:
      {
        libmesh_assert(in.get());
        libmesh_assert (in->good());
 
        for (unsigned int i=0; i<len; i++)
          {
            libmesh_assert(in.get());
            libmesh_assert (in->good());
            *in >> val[i];
          }
 
        return;
      }
 
    case WRITE:
      {
        libmesh_assert(out.get());
        libmesh_assert (out->good());
 
        // We will use scientific notation sufficient to exactly
        // represent our floating point precision in the following
        // output.  The desired precision and format will
        // automatically determine the width.
        *out << std::scientific
             << std::setprecision(std::numeric_limits<T>::max_digits10);
 
        if (line_break == libMesh::invalid_uint)
          for (unsigned int i=0; i<len; i++)
            {
              libmesh_assert(out.get());
              libmesh_assert (out->good());
              *out << val[i] << " ";
            }
        else
          {
            const unsigned imax = std::min(line_break, len);
            unsigned int cnt=0;
            while (cnt < len)
              {
                for (unsigned int i=0; (i<imax && cnt<len); i++)
                  {
                    libmesh_assert(out.get());
                    libmesh_assert (out->good());
                    *out << val[cnt++];
 
                    // Write a space unless this is the last character on the current line.
                    if (i+1 != imax)
                      *out << " ";
                  }
                libmesh_assert(out.get());
                libmesh_assert (out->good());
                *out << '\n';
              }
          }
 
        return;
      }
 
    default:
      libmesh_error_msg("Invalid mode = " << mode);
    }
}

References libMesh::DECODE, libMesh::ENCODE, in, libMesh::invalid_uint, is_open(), libMesh::libmesh_assert(), mode, out, libMesh::READ, libMesh::WRITE, and xdrs.

Referenced by libMesh::CheckpointIO::read_connectivity(), libMesh::CheckpointIO::read_nodes(), libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::CheckpointIO::write_connectivity(), libMesh::CheckpointIO::write_nodes(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodes(), and libMesh::XdrIO::write_serialized_nodesets().

do_read() [1/5]

template<typename T >

void libMesh::Xdr::do_read ( std::complex< T > &  a )

private

Definition at line 753 of file xdr_cxx.C.

{
  T r, i;
  *in >> r >> i;
  a = std::complex<T>(r,i);
  in->getline(comm, comm_len);
}

References comm, comm_len, and in.

do_read() [2/5]

template<>

void libMesh::Xdr::do_read

(

std::string &

a

)

Definition at line 762 of file xdr_cxx.C.

{
  in->getline(comm, comm_len);
 
  a = "";
 
  for (unsigned int c=0, sl=std::strlen(comm); c!=sl; c++)
    {
      if (comm[c] == '\t')
        break;
      a.push_back(comm[c]);
    }
}

References comm, comm_len, and in.

do_read() [3/5]

template<typename T >

void libMesh::Xdr::do_read ( std::vector< std::complex< T > > &  a )

private

Definition at line 793 of file xdr_cxx.C.

{
  unsigned int length=0;
  data(length, "# vector length x 2 (complex)");
  a.resize(length);
 
  for (std::complex<T> & a_i : a)
    {
      T r, im;
      libmesh_assert(in.get());
      libmesh_assert (in->good());
      *in >> r >> im;
      a_i = std::complex<T>(r,im);
    }
  in->getline(comm, comm_len);
}

References comm, comm_len, data(), in, and libMesh::libmesh_assert().

do_read() [4/5]

template<typename T >

void libMesh::Xdr::do_read ( std::vector< T > &  a )

private

Definition at line 777 of file xdr_cxx.C.

{
  unsigned int length=0;
  data(length, "# vector length");
  a.resize(length);
 
  for (T & a_i : a)
    {
      libmesh_assert(in.get());
      libmesh_assert (in->good());
      *in >> a_i;
    }
  in->getline(comm, comm_len);
}

References comm, comm_len, data(), in, and libMesh::libmesh_assert().

do_read() [5/5]

template<typename T >

void libMesh::Xdr::do_read ( T &  a )

private

Helper method for reading different data types.

Definition at line 746 of file xdr_cxx.C.

{
  *in >> a;
  in->getline(comm, comm_len);
}

References comm, comm_len, and in.

Referenced by data().

do_write() [1/4]

template<typename T >

void libMesh::Xdr::do_write ( std::complex< T > &  a )

private

Definition at line 814 of file xdr_cxx.C.

{
  *out << a.real() << "\t " << a.imag();
}

References out.

do_write() [2/4]

template<typename T >

void libMesh::Xdr::do_write ( std::vector< std::complex< T > > &  a )

private

Definition at line 839 of file xdr_cxx.C.

{
  std::size_t length=a.size();
  data(length, "# vector length x 2 (complex)");
 
  // Use scientific precision with lots of digits for the original type T.
  *out << std::scientific
       << std::setprecision(std::numeric_limits<T>::max_digits10);
 
  for (std::complex<T> & a_i : a)
    {
      libmesh_assert(out.get());
      libmesh_assert (out->good());
      this->do_write(a_i);
      *out << "\t ";
    }
}

References data(), do_write(), libMesh::libmesh_assert(), and out.

do_write() [3/4]

template<typename T >

void libMesh::Xdr::do_write ( std::vector< T > &  a )

private

Definition at line 820 of file xdr_cxx.C.

{
  std::size_t length = a.size();
  data(length, "# vector length");
 
  // Use scientific precision with lots of digits for the original type T.
  *out << std::scientific
       << std::setprecision(std::numeric_limits<T>::max_digits10);
 
  for (T & a_i : a)
    {
      libmesh_assert(out.get());
      libmesh_assert (out->good());
      this->do_write(a_i);
      *out << "\t ";
    }
}

References data(), do_write(), libMesh::libmesh_assert(), and out.

do_write() [4/4]

template<typename T >

void libMesh::Xdr::do_write ( T &  a )

private

Helper method for writing different data types.

Definition at line 811 of file xdr_cxx.C.

{ *out << a; }

References out.

Referenced by data(), do_write(), and do_write().

is_eof()

bool libMesh::Xdr::is_eof

(

)

Returns

true if the Xdr file being read is at End-Of-File.

Note

This is not a const method - the only portable way to test for an impending EOF is to peek at the next byte of the file first, which may set the eof flag on the istream.

Definition at line 396 of file xdr_cxx.C.

{
  switch (mode)
    {
    case ENCODE:
    case DECODE:
      {
#ifdef LIBMESH_HAVE_XDR
        libmesh_assert(fp);
 
        // Are we already at eof?
        if (feof(fp))
          return true;
 
        // Or about to reach eof?
        int next = fgetc(fp);
        if (next == EOF)
          {
            // We should *only* be at EOF, not otherwise broken
            libmesh_assert(feof(fp));
            libmesh_assert(!ferror(fp));
 
            // Reset the EOF indicator
            clearerr(fp);
            libmesh_assert(!ferror(fp));
 
            // We saw EOF
            return true;
          }
 
        // We didn't see EOF; restore whatever we did see.
        ungetc(next, fp);
        break;
#else
 
        libmesh_error_msg("ERROR: Functionality is not available.\n"    \
                          << "Make sure LIBMESH_HAVE_XDR is defined at build time\n" \
                          << "The XDR interface is not available in this installation");
 
        return false;
 
#endif
 
      }
    case READ:
      {
        libmesh_assert(in.get());
 
        // Are we already at eof?
        if (in->eof())
          return true;
 
        // Or about to reach eof?
        int next = in->peek();
        if (next == EOF)
          {
            // We should *only* be at EOF, not otherwise broken
            libmesh_assert(in->eof());
            libmesh_assert(!in->fail());
 
            // Reset the EOF indicator
            in->clear();
            libmesh_assert(in->good());
 
            // We saw EOF
            return true;
          }
        break;
      }
    default:
      libmesh_error();
    }
 
  return false;
}

References libMesh::DECODE, libMesh::ENCODE, fp, in, libMesh::libmesh_assert(), mode, and libMesh::READ.

is_open()

bool libMesh::Xdr::is_open

(

)

const

Returns

true if the Xdr file is open, false if it is closed.

Definition at line 346 of file xdr_cxx.C.

{
  switch (mode)
    {
    case ENCODE:
    case DECODE:
      {
#ifdef LIBMESH_HAVE_XDR
 
        if (fp)
          if (xdrs)
            return true;
 
        return false;
 
#else
 
        libmesh_error_msg("ERROR: Functionality is not available.\n"    \
                          << "Make sure LIBMESH_HAVE_XDR is defined at build time\n" \
                          << "The XDR interface is not available in this installation");
 
        return false;
 
#endif
 
      }
 
    case READ:
      {
        if (in.get() != nullptr)
          return in->good();
        return false;
      }
 
    case WRITE:
      {
        if (out.get() != nullptr)
          return out->good();
        return false;
      }
 
    default:
      libmesh_error_msg("Invalid mode = " << mode);
    }
 
  return false;
}

References libMesh::DECODE, libMesh::ENCODE, fp, in, mode, out, libMesh::READ, libMesh::WRITE, and xdrs.

Referenced by _complex_data_stream(), _xfp_data_stream(), data(), data_stream(), and libMesh::System::read_parallel_data().

open()

void libMesh::Xdr::open

(

std::string

name

)

Opens the file.

Definition at line 167 of file xdr_cxx.C.

{
  file_name = std::move(name);
 
  if (file_name == "")
    return;
 
  switch (mode)
    {
    case ENCODE:
    case DECODE:
      {
#ifdef LIBMESH_HAVE_XDR
 
        fp = fopen(file_name.c_str(), (mode == ENCODE) ? "w" : "r");
        if (!fp)
          libmesh_file_error(file_name.c_str());
        xdrs = std::make_unique<XDR>();
        xdrstdio_create (xdrs.get(), fp, (mode == ENCODE) ? XDR_ENCODE : XDR_DECODE);
#else
 
        libmesh_error_msg("ERROR: Functionality is not available.\n" \
                          << "Make sure LIBMESH_HAVE_XDR is defined at build time\n" \
                          << "The XDR interface is not available in this installation");
 
#endif
        return;
 
      }
 
    case READ:
      {
        gzipped_file = Utility::ends_with(file_name, ".gz");
        bzipped_file = Utility::ends_with(file_name, ".bz2");
        xzipped_file = Utility::ends_with(file_name, ".xz");
 
        if (gzipped_file)
          {
#ifdef LIBMESH_HAVE_GZSTREAM
            auto inf = std::make_unique<igzstream>();
            libmesh_assert(inf);
            inf->open(file_name.c_str(), std::ios::in);
            in = std::move(inf);
#else
            libmesh_error_msg("ERROR: need gzstream to handle .gz files!!!");
#endif
          }
        else
          {
            auto inf = std::make_unique<std::ifstream>();
            libmesh_assert(inf);
 
            std::string new_name = Utility::unzip_file(file_name);
 
            inf->open(new_name.c_str(), std::ios::in);
            in = std::move(inf);
          }
 
        libmesh_assert(in.get());
 
        if (!in->good())
          libmesh_file_error(file_name);
        return;
      }
 
    case WRITE:
      {
        gzipped_file = (file_name.rfind(".gz") == file_name.size() - 3);
        bzipped_file = (file_name.rfind(".bz2") == file_name.size() - 4);
        xzipped_file = (file_name.rfind(".xz") == file_name.size() - 3);
 
        if (gzipped_file)
          {
#ifdef LIBMESH_HAVE_GZSTREAM
            auto outf = std::make_unique<ogzstream>();
            libmesh_assert(outf);
            outf->open(file_name.c_str(), std::ios::out);
            out = std::move(outf);
#else
            libmesh_error_msg("ERROR: need gzstream to handle .gz files!!!");
#endif
          }
        else
          {
            auto outf = std::make_unique<std::ofstream>();
            libmesh_assert(outf);
 
            std::string new_name = file_name;
 
            if (bzipped_file)
              new_name.erase(new_name.end() - 4, new_name.end());
 
            if (xzipped_file)
              new_name.erase(new_name.end() - 3, new_name.end());
 
            outf->open(new_name.c_str(), std::ios::out);
            out = std::move(outf);
          }
 
        libmesh_assert(out.get());
        libmesh_assert (out->good());
        return;
      }
 
    default:
      libmesh_error_msg("Invalid mode = " << mode);
    }
}

References bzipped_file, libMesh::DECODE, libMesh::ENCODE, libMesh::Utility::ends_with(), file_name, fp, gzipped_file, in, libMesh::libmesh_assert(), mode, out, libMesh::READ, libMesh::Utility::unzip_file(), libMesh::WRITE, xdrs, and xzipped_file.

Referenced by Xdr().

operator<<()

template<typename T >

Xdr & libMesh::Xdr::operator<< ( T &  a )

inline

Same, but provides an ostream like interface.

Definition at line 149 of file xdr_cxx.h.

{ libmesh_assert (writing()); data(a); return *this; }

References data(), libMesh::libmesh_assert(), and writing().

operator>>()

template<typename T >

Xdr & libMesh::Xdr::operator>> ( T &  a )

inline

Same, but provides an istream like interface.

Definition at line 155 of file xdr_cxx.h.

{ libmesh_assert (reading()); data(a); return *this; }

References data(), libMesh::libmesh_assert(), and reading().

reading()

bool libMesh::Xdr::reading ( ) const

inline

Returns

true if the file is opened in a reading state, false otherwise.

Definition at line 123 of file xdr_cxx.h.

{ return ((mode == DECODE) || (mode == READ)); }

References libMesh::DECODE, mode, and libMesh::READ.

Referenced by operator>>(), libMesh::EquationSystems::read(), libMesh::System::read_header(), libMesh::System::read_parallel_data(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::System::read_serialized_vector(), and libMesh::System::read_serialized_vectors().

set_version()

void libMesh::Xdr::set_version ( int  ver )

inline

Sets the version of the file that is being read.

Definition at line 171 of file xdr_cxx.h.

{ version_number = ver; }

References version_number.

Referenced by libMesh::EquationSystems::read(), and libMesh::EquationSystems::write().

version()

int libMesh::Xdr::version ( ) const

inline

Gets the version of the file that is being read.

Definition at line 176 of file xdr_cxx.h.

{ return version_number; }

References version_number.

Referenced by libMesh::System::read_header(), and libMesh::System::read_serialized_vector().

writing()

bool libMesh::Xdr::writing ( ) const

inline

Returns

true if the file is opened in a writing state, false otherwise.

Definition at line 129 of file xdr_cxx.h.

{ return ((mode == ENCODE) || (mode == WRITE)); }

References libMesh::ENCODE, mode, and libMesh::WRITE.

Referenced by operator<<(), libMesh::EquationSystems::write(), libMesh::CheckpointIO::write_bcs(), libMesh::CheckpointIO::write_connectivity(), libMesh::System::write_header(), libMesh::CheckpointIO::write_nodesets(), libMesh::System::write_parallel_data(), libMesh::CheckpointIO::write_remote_elem(), libMesh::XdrIO::write_serialized_bcs_helper(), libMesh::XdrIO::write_serialized_connectivity(), libMesh::XdrIO::write_serialized_nodesets(), libMesh::System::write_serialized_vector(), and libMesh::System::write_serialized_vectors().

Member Data Documentation

bzipped_file

bool libMesh::Xdr::bzipped_file

private

Definition at line 275 of file xdr_cxx.h.

Referenced by close(), and open().

comm

char libMesh::Xdr::comm[xdr_MAX_STRING_LENGTH]

private

Definition at line 270 of file xdr_cxx.h.

Referenced by comment(), do_read(), do_read(), do_read(), do_read(), and do_read().

comm_len

const int libMesh::Xdr::comm_len

private

A buffer to put comment strings into.

Definition at line 269 of file xdr_cxx.h.

Referenced by comment(), do_read(), do_read(), do_read(), do_read(), and do_read().

file_name

std::string libMesh::Xdr::file_name

private

The file name.

Definition at line 239 of file xdr_cxx.h.

Referenced by close(), open(), and Xdr().

fp

FILE* libMesh::Xdr::fp

private

File pointer.

Definition at line 252 of file xdr_cxx.h.

Referenced by close(), is_eof(), is_open(), and open().

gzipped_file

bool libMesh::Xdr::gzipped_file

private

Are we reading/writing zipped files?

Definition at line 275 of file xdr_cxx.h.

Referenced by open().

in

std::unique_ptr<std::istream> libMesh::Xdr::in

private

The input file stream.

Definition at line 259 of file xdr_cxx.h.

Referenced by _complex_data_stream(), _xfp_data_stream(), close(), comment(), data(), data_stream(), do_read(), do_read(), do_read(), do_read(), do_read(), is_eof(), is_open(), and open().

mode

const XdrMODE libMesh::Xdr::mode

private

The mode used for accessing the file.

Definition at line 234 of file xdr_cxx.h.

Referenced by _complex_data_stream(), _xfp_data_stream(), access_mode(), close(), comment(), data(), data_stream(), is_eof(), is_open(), open(), reading(), and writing().

out

std::unique_ptr<std::ostream> libMesh::Xdr::out

private

The output file stream.

Definition at line 264 of file xdr_cxx.h.

Referenced by _complex_data_stream(), _xfp_data_stream(), close(), comment(), data(), data_stream(), do_write(), do_write(), do_write(), do_write(), is_open(), and open().

version_number

int libMesh::Xdr::version_number

private

Version of the file being read.

Definition at line 280 of file xdr_cxx.h.

Referenced by set_version(), and version().

xdrs

std::unique_ptr<XDR> libMesh::Xdr::xdrs

private

Pointer to the standard XDR struct.

See the standard header file rpc/rpc.h for more information.

Definition at line 247 of file xdr_cxx.h.

Referenced by _complex_data_stream(), _xfp_data_stream(), close(), data(), data_stream(), is_open(), and open().

xzipped_file

bool libMesh::Xdr::xzipped_file

private

Definition at line 275 of file xdr_cxx.h.

Referenced by close(), and open().

---

The documentation for this class was generated from the following files:

• include/utils/xdr_cxx.h
• src/utils/xdr_cxx.C