libMesh::Xdr Class Reference

#include <xdr_cxx.h>

List of all members.

Public Member Functions
	Xdr (const std::string &name="", const libMeshEnums::XdrMODE m=UNKNOWN)
	~Xdr ()
void	open (const std::string &name)
void	close ()
bool	is_open () const
bool	reading () const
bool	writing () const
XdrMODE	access_mode () const
template<typename T >
void	data (T &a, const char *comment="")
template<typename T >
Xdr &	operator<< (T &a)
template<typename T >
Xdr &	operator>> (T &a)
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)
int	version () const
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 (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)
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)
Private Attributes
const XdrMODE	mode
std::string	file_name
XDR *	xdrs
FILE *	fp
AutoPtr< std::istream >	in
AutoPtr< std::ostream >	out
const int	comm_len
char	comm [xdr_MAX_STRING_LENGTH]
bool	gzipped_file
bool	bzipped_file
bool	xzipped_file
int	version_number

---

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.

Definition at line 65 of file xdr_cxx.h.

---

Constructor & Destructor Documentation

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

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

libMesh::Xdr::~Xdr

(

)

Destructor. Closes the file if it is open.

Definition at line 178 of file xdr_cxx.C.

References close().

{
  this->close();
}

---

Member Function Documentation

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 113 of file xdr_cxx.h.

References mode.

{ return mode; }

void libMesh::Xdr::close

(

)

Closes the file if it is open.

Definition at line 302 of file xdr_cxx.C.

References bzipped_file, libMeshEnums::DECODE, libMeshEnums::ENCODE, libMesh::err, file_name, fp, libMesh::AutoPtr< Tp >::get(), in, mode, out, libMeshEnums::READ, libMesh::AutoPtr< Tp >::reset(), libMeshEnums::WRITE, xdrs, and xzipped_file.

Referenced by libMesh::EquationSystems::_read_impl(), libMesh::XdrIO::read(), libMesh::XdrIO::write(), and ~Xdr().

{
  switch (mode)
    {
    case ENCODE:
    case DECODE:
      {
#ifdef LIBMESH_HAVE_XDR

        if (xdrs)
          {
            xdr_destroy (xdrs);
            delete xdrs;
            xdrs = NULL;
          }

        if (fp)
          {
            fflush(fp);
            fclose(fp);
            fp = NULL;
          }
#else

        libMesh::err << "ERROR: Functionality is not available." << std::endl
                      << "Make sure LIBMESH_HAVE_XDR is defined at build time"
                      << std::endl
                      << "The XDR interface is not available in this installation"
                      << std::endl;

        libmesh_error();

#endif
        file_name = "";
        return;
      }

    case READ:
      {
        if (in.get() != NULL)
          {
            in.reset();

            if (bzipped_file || xzipped_file)
              remove_unzipped_file(file_name);
          }
        file_name = "";
        return;
      }

    case WRITE:
      {
        if (out.get() != NULL)
          {
            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();
    }
}

void libMesh::Xdr::comment

(

std::string &

comment_in

)

Writes or reads (ignores) a comment line.

Definition at line 1374 of file xdr_cxx.C.

References comm, comm_len, libMeshEnums::DECODE, libMeshEnums::ENCODE, libMesh::AutoPtr< Tp >::get(), in, mode, out, libMeshEnums::READ, and libMeshEnums::WRITE.

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

{
  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();
    }
}

template<typename T >

void libMesh::Xdr::data	(	T &	a,
		const char *	comment = ""
	)			[inline]

Inputs or outputs a single value.

Definition at line 632 of file xdr_cxx.C.

References libMeshEnums::DECODE, do_read(), do_write(), libMeshEnums::ENCODE, libMesh::err, libMesh::AutoPtr< Tp >::get(), in, is_open(), mode, out, libMeshEnums::READ, libMeshEnums::WRITE, and xdrs.

Referenced by libMesh::EquationSystems::_read_impl(), do_read(), do_write(), operator<<(), operator>>(), libMesh::XdrIO::read(), libMesh::System::read_header(), libMesh::System::read_legacy_data(), libMesh::System::read_parallel_data(), libMesh::XdrIO::read_serialized_bcs(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::System::read_serialized_vector(), libMesh::System::read_serialized_vectors(), libMesh::MeshData::read_xdr(), libMesh::XdrIO::write(), libMesh::EquationSystems::write(), libMesh::System::write_header(), libMesh::System::write_parallel_data(), libMesh::XdrIO::write_serialized_bcs(), libMesh::System::write_serialized_vector(), libMesh::System::write_serialized_vectors(), and libMesh::MeshData::write_xdr().

{
  switch (mode)
    {
    case ENCODE:
    case DECODE:
      {
#ifdef LIBMESH_HAVE_XDR

        libmesh_assert (is_open());

        xdr_translate(xdrs, a);

#else

        libMesh::err << "ERROR: Functionality is not available." << std::endl
                      << "Make sure LIBMESH_HAVE_XDR is defined at build time"
                      << std::endl
                      << "The XDR interface is not available in this installation"
                      << std::endl;

        libmesh_error();

#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());

        this->do_write(a);
        *out << "\t " << comment_in << '\n';

        return;
      }

    default:
      libmesh_error();
    }
}

template<>

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

Definition at line 1244 of file xdr_cxx.C.

References libMeshEnums::DECODE, libMeshEnums::ENCODE, libMesh::err, libMesh::AutoPtr< Tp >::get(), in, libMesh::invalid_uint, is_open(), std::min(), mode, out, libMeshEnums::READ, libMeshEnums::WRITE, and xdrs.

{
  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,
                       (char*) &io_buffer[0],
                       2*len,
                       sizeof(double),
                       (xdrproc_t) 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<long double>(re, im);
                }
          }
#else

        libMesh::err << "ERROR: Functionality is not available." << std::endl
                      << "Make sure LIBMESH_HAVE_XDR is defined at build time"
                      << std::endl
                      << "The XDR interface is not available in this installation"
                      << std::endl;

        libmesh_error();

#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());
            long double re, im;
            *in >> re >> im;
            val[i] = std::complex<long double>(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
        // '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<long double>::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
          {
            unsigned int cnt=0;
            while (cnt < len)
              {
                for (unsigned int i=0; i<std::min(line_break,len); i++)
                  {
                    libmesh_assert(out.get());
                    libmesh_assert (out->good());
                    *out << val[cnt].real() << ' ' << val[cnt].imag() << ' ';
                    cnt++;
                  }
                libmesh_assert(out.get());
                libmesh_assert (out->good());
                *out << '\n';
              }
          }

        // Restore stream flags
        out->flags(out_flags);

        return;
      }

    default:
      libmesh_error();
    }
}

template<>

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

Definition at line 1121 of file xdr_cxx.C.

References libMeshEnums::DECODE, libMeshEnums::ENCODE, libMesh::err, libMesh::AutoPtr< Tp >::get(), in, libMesh::invalid_uint, is_open(), std::min(), mode, out, libMeshEnums::READ, libMeshEnums::WRITE, and xdrs.

{
  switch (mode)
    {
    case ENCODE:
    case DECODE:
      {
#ifdef LIBMESH_HAVE_XDR

        libmesh_assert (this->is_open());


        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,
                       (char*) &io_buffer[0],
                       2*len,
                       sizeof(double),
                       (xdrproc_t) 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<double>(re,im);
                }
          }
#else

        libMesh::err << "ERROR: Functionality is not available." << std::endl
                      << "Make sure LIBMESH_HAVE_XDR is defined at build time"
                      << std::endl
                      << "The XDR interface is not available in this installation"
                      << std::endl;

        libmesh_error();

#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());
            double re, im;
            *in >> re >> im;
            val[i] = std::complex<double>(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 16
        // digits in the following output.  The desired precision and
        // format will automatically determine the width.
        *out << std::scientific
             << std::setprecision(16);

        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() << ' ';
              *out << val[i].imag() << ' ';
            }
        else
          {
            unsigned int cnt=0;
            while (cnt < len)
              {
                for (unsigned int i=0; i<std::min(line_break,len); i++)
                  {
                    libmesh_assert(out.get());
                    libmesh_assert (out->good());
                    *out << val[cnt].real() << ' ';
                    *out << val[cnt].imag() << ' ';
                    cnt++;
                  }
                libmesh_assert(out.get());
                libmesh_assert (out->good());
                *out << '\n';
              }
          }

        // Restore stream flags
        out->flags(out_flags);

        return;
      }

    default:
      libmesh_error();
    }
}

template<>

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

Definition at line 994 of file xdr_cxx.C.

References libMeshEnums::DECODE, libMeshEnums::ENCODE, libMesh::err, libMesh::AutoPtr< Tp >::get(), in, libMesh::invalid_uint, is_open(), std::min(), mode, out, libMeshEnums::READ, libMeshEnums::WRITE, and xdrs.

{
  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)
        //   xdr_vector(xdrs,
        //           (char*) val,
        //           len,
        //           sizeof(double),
        //           (xdrproc_t) xdr_quadruple);

        if (len > 0)
          {
            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++] = val[i];

            xdr_vector(xdrs,
                       (char*) &io_buffer[0],
                       len,
                       sizeof(double),
                       (xdrproc_t) 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::err << "ERROR: Functionality is not available." << std::endl
                      << "Make sure LIBMESH_HAVE_XDR is defined at build time"
                      << std::endl
                      << "The XDR interface is not available in this installation"
                      << std::endl;

        libmesh_error();

#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 a precision of 16
        // digits in the following output.  The desired precision and
        // format will automatically determine the width.
        *out << std::scientific
             << std::setprecision(16);

        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
          {
            unsigned int cnt=0;
            while (cnt < len)
              {
                for (unsigned int i=0; i<std::min(line_break,len); i++)
                  {
                    libmesh_assert(out.get());
                    libmesh_assert (out->good());
                    *out << val[cnt++] << ' ';
                  }
                libmesh_assert(out.get());
                libmesh_assert (out->good());
                *out << '\n';
              }
          }

        // Restore stream flags
        out->flags(out_flags);

        return;
      }

    default:
      libmesh_error();
    }
}

template<>

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

Definition at line 898 of file xdr_cxx.C.

References libMeshEnums::DECODE, libMeshEnums::ENCODE, libMesh::err, libMesh::AutoPtr< Tp >::get(), in, libMesh::invalid_uint, is_open(), std::min(), mode, out, libMeshEnums::READ, libMeshEnums::WRITE, and xdrs.

{
  switch (mode)
    {
    case ENCODE:
    case DECODE:
      {
#ifdef LIBMESH_HAVE_XDR

        libmesh_assert (this->is_open());

        if (len > 0)
          xdr_vector(xdrs,
                     (char*) val,
                     len,
                     sizeof(float),
                     (xdrproc_t) xdr_float);

#else

        libMesh::err << "ERROR: Functionality is not available." << std::endl
                      << "Make sure LIBMESH_HAVE_XDR is defined at build time"
                      << std::endl
                      << "The XDR interface is not available in this installation"
                      << std::endl;

        libmesh_error();

#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 a precision of 16
        // digits in the following output.  The desired precision and
        // format will automatically determine the width.
        *out << std::scientific
             << std::setprecision(16);

        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
          {
            unsigned int cnt=0;
            while (cnt < len)
              {
                for (unsigned int i=0; i<std::min(line_break,len); i++)
                  {
                    libmesh_assert(out.get());
                    libmesh_assert (out->good());
                    *out << val[cnt++] << ' ';
                  }
                libmesh_assert(out.get());
                libmesh_assert (out->good());
                *out << '\n';
              }
          }

        // Restore stream flags
        out->flags(out_flags);

        return;
      }

    default:
      libmesh_error();
    }
}

template<>

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

Definition at line 800 of file xdr_cxx.C.

References libMeshEnums::DECODE, libMeshEnums::ENCODE, libMesh::err, libMesh::AutoPtr< Tp >::get(), in, libMesh::invalid_uint, is_open(), std::min(), mode, out, libMeshEnums::READ, libMeshEnums::WRITE, and xdrs.

{
  switch (mode)
    {
    case ENCODE:
    case DECODE:
      {
#ifdef LIBMESH_HAVE_XDR

        libmesh_assert (this->is_open());

        if (len > 0)
          xdr_vector(xdrs,
                     (char*) val,
                     len,
                     sizeof(double),
                     (xdrproc_t) xdr_double);

#else

        libMesh::err << "ERROR: Functionality is not available." << std::endl
                      << "Make sure LIBMESH_HAVE_XDR is defined at build time"
                      << std::endl
                      << "The XDR interface is not available in this installation"
                      << std::endl;

        libmesh_error();

#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 a precision of 16
        // digits in the following output.  The desired precision and
        // format will automatically determine the width.
        *out << std::scientific
             << std::setprecision(16);

        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
          {
            unsigned int cnt=0;
            while (cnt < len)
              {
                for (unsigned int i=0; i<std::min(line_break,len); i++)
                  {
                    libmesh_assert(out.get());
                    libmesh_assert (out->good());
                    *out << val[cnt++] << ' ';
                  }
                libmesh_assert(out.get());
                libmesh_assert (out->good());
                *out << '\n';
              }
          }

        // Restore stream flags
        out->flags(out_flags);

        return;
      }

    default:
      libmesh_error();
    }
}

template<typename T >

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

Inputs or outputs a raw data stream.

Definition at line 687 of file xdr_cxx.C.

References libMeshEnums::DECODE, libMeshEnums::ENCODE, libMesh::err, libMesh::AutoPtr< Tp >::get(), in, libMesh::invalid_uint, is_open(), std::min(), mode, out, libMeshEnums::READ, libMeshEnums::WRITE, and xdrs.

Referenced by libMesh::System::read_SCALAR_dofs(), libMesh::XdrIO::read_serialized_bcs(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::System::write_SCALAR_dofs(), libMesh::XdrIO::write_serialized_bcs(), and libMesh::XdrIO::write_serialized_nodes().

{
  switch (mode)
    {
    case ENCODE:
      {
#ifdef LIBMESH_HAVE_XDR

        libmesh_assert (this->is_open());


        xdr_vector(xdrs,
                   (char*) val,
                   len,
                   sizeof(unsigned int),
                   (xdrproc_t) xdr_u_int);

#else

        libMesh::err << "ERROR: Functionality is not available." << std::endl
                      << "Make sure LIBMESH_HAVE_XDR is defined at build time"
                      << std::endl
                      << "The XDR interface is not available in this installation"
                      << std::endl;

        libmesh_error();

#endif
        return;
      }

    case DECODE:
      {
#ifdef LIBMESH_HAVE_XDR

        libmesh_assert (this->is_open());

        if (len > 0)
          xdr_vector(xdrs,
                     (char*) val,
                     len,
                     sizeof(unsigned int),
                     (xdrproc_t) xdr_u_int);

#else

        libMesh::err << "ERROR: Functionality is not available." << std::endl
                      << "Make sure LIBMESH_HAVE_XDR is defined at build time"
                      << std::endl
                      << "The XDR interface is not available in this installation"
                      << std::endl;

        libmesh_error();

#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());

        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
          {
            unsigned int cnt=0;
            while (cnt < len)
              {
                for (unsigned int i=0; i<std::min(line_break,len); i++)
                  {
                    libmesh_assert(out.get());
                    libmesh_assert (out->good());
                    *out << val[cnt++] << " ";
                  }
                libmesh_assert(out.get());
                libmesh_assert (out->good());
                *out << '\n';
              }
          }

        return;
      }

    default:
      libmesh_error();
    }
}

template<>

void libMesh::Xdr::do_read

(

std::string &

a

)

[inline]

Definition at line 548 of file xdr_cxx.C.

References comm, comm_len, and in.

                              {
  in->getline(comm, comm_len);

  a = "";

  for (unsigned int c=0; c<std::strlen(comm); c++)
    {
      if (comm[c] == '\t')
        break;
      a.push_back(comm[c]);
    }
}

template<typename T >

void libMesh::Xdr::do_read

(

std::vector< std::complex< T > > &

a

)

[inline, private]

Definition at line 577 of file xdr_cxx.C.

References comm, comm_len, data(), libMesh::AutoPtr< Tp >::get(), and in.

                                              {
  unsigned int length=0;
  data(length, "# vector length x 2 (complex)");
  a.resize(length);

  for (unsigned int i=0; i<a.size(); i++)
    {
      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);
}

template<typename T >

void libMesh::Xdr::do_read

(

std::vector< T > &

a

)

[inline, private]

Definition at line 562 of file xdr_cxx.C.

References comm, comm_len, data(), libMesh::AutoPtr< Tp >::get(), and in.

                                 {
  unsigned int length=0;
  data(length, "# vector length");
  a.resize(length);

  for (unsigned int i=0; i<a.size(); i++)
    {
      libmesh_assert(in.get());
      libmesh_assert (in->good());
      *in >> a[i];
    }
  in->getline(comm, comm_len);
}

template<typename T >

void libMesh::Xdr::do_read

(

std::complex< T > &

a

)

[inline, private]

Definition at line 540 of file xdr_cxx.C.

References comm, comm_len, and in.

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

template<typename T >

void libMesh::Xdr::do_read

(

T &

a

)

[inline, private]

Helper method for reading different data types

Definition at line 534 of file xdr_cxx.C.

References comm, comm_len, and in.

Referenced by data().

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

template<typename T >

void libMesh::Xdr::do_write

(

std::vector< std::complex< T > > &

a

)

[inline, private]

Definition at line 616 of file xdr_cxx.C.

References data(), do_write(), libMesh::AutoPtr< Tp >::get(), and out.

                                               {
  std::size_t length=a.size();
  data(length, "# vector length x 2 (complex)");

  for (std::size_t i=0; i<a.size(); i++)
    {
      libmesh_assert(out.get());
      libmesh_assert (out->good());
      this->do_write(a[i]);
      *out << "\t ";
    }
}

template<typename T >

void libMesh::Xdr::do_write

(

std::vector< T > &

a

)

[inline, private]

Definition at line 602 of file xdr_cxx.C.

References data(), do_write(), libMesh::AutoPtr< Tp >::get(), and out.

                                  {
  std::size_t length = a.size();
  data(length, "# vector length");

  for (std::size_t i=0; i<a.size(); i++)
    {
      libmesh_assert(out.get());
      libmesh_assert (out->good());
      this->do_write(a[i]);
      *out << "\t ";
    }
}

template<typename T >

void libMesh::Xdr::do_write

(

std::complex< T > &

a

)

[inline, private]

Definition at line 597 of file xdr_cxx.C.

References out.

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

template<typename T >

void libMesh::Xdr::do_write

(

T &

a

)

[inline, private]

Helper method for writing different data types

Definition at line 594 of file xdr_cxx.C.

References out.

Referenced by data(), and do_write().

{ *out << a; }

bool libMesh::Xdr::is_open

(

)

const

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

Definition at line 375 of file xdr_cxx.C.

References libMeshEnums::DECODE, libMeshEnums::ENCODE, libMesh::err, fp, libMesh::AutoPtr< Tp >::get(), in, mode, out, libMeshEnums::READ, libMeshEnums::WRITE, and xdrs.

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

{
  switch (mode)
    {
    case ENCODE:
    case DECODE:
      {
#ifdef LIBMESH_HAVE_XDR

        if (fp)
          if (xdrs)
            return true;

        return false;

#else

        libMesh::err << "ERROR: Functionality is not available." << std::endl
                      << "Make sure LIBMESH_HAVE_XDR is defined at build time"
                      << std::endl
                      << "The XDR interface is not available in this installation"
                      << std::endl;

        libmesh_error();

        return false;

#endif

      }

    case READ:
      {
        if (in.get() != NULL)
          return in->good();
        return false;
      }

    case WRITE:
      {
        if (out.get() != NULL)
          return out->good();
        return false;
      }

    default:
      libmesh_error();
    }

  return false;
}

void libMesh::Xdr::open

(

const std::string &

name

)

Opens the file.

Definition at line 185 of file xdr_cxx.C.

References bzipped_file, libMeshEnums::DECODE, libMeshEnums::ENCODE, libMesh::err, file_name, fp, libMesh::AutoPtr< Tp >::get(), gzipped_file, in, mode, libMesh::out, out, libMeshEnums::READ, libMesh::AutoPtr< Tp >::reset(), libMeshEnums::WRITE, xdrs, and xzipped_file.

{
  file_name = name;

  if (name == "")
    return;

  switch (mode)
    {
    case ENCODE:
    case DECODE:
      {
#ifdef LIBMESH_HAVE_XDR

        fp = fopen(name.c_str(), (mode == ENCODE) ? "w" : "r");
        if (!fp)
          libmesh_file_error(name.c_str());
        xdrs = new XDR;
        xdrstdio_create (xdrs, fp, (mode == ENCODE) ? XDR_ENCODE : XDR_DECODE);
#else

        libMesh::err << "ERROR: Functionality is not available." << std::endl
                      << "Make sure LIBMESH_HAVE_XDR is defined at build time"
                      << std::endl
                      << "The XDR interface is not available in this installation"
                      << std::endl;

        libmesh_error();

#endif
        return;

      }

    case READ:
      {
        gzipped_file = (name.size() - name.rfind(".gz")  == 3);
        bzipped_file = (name.size() - name.rfind(".bz2") == 4);
        xzipped_file = (name.size() - name.rfind(".xz") == 3);

        if (gzipped_file)
          {
#ifdef LIBMESH_HAVE_GZSTREAM
            igzstream *inf = new igzstream;
            libmesh_assert(inf);
            in.reset(inf);
            inf->open(name.c_str(), std::ios::in);
#else
            libMesh::err << "ERROR: need gzstream to handle .gz files!!!"
                          << std::endl;
            libmesh_error();
#endif
          }
        else
          {
            std::ifstream *inf = new std::ifstream;
            libmesh_assert(inf);
            in.reset(inf);

            std::string new_name = unzip_file(name);

            inf->open(new_name.c_str(), std::ios::in);
          }

        libmesh_assert(in.get());
        libmesh_assert (in->good());
        return;
      }

    case WRITE:
      {
        gzipped_file = (name.size() - name.rfind(".gz")  == 3);
        bzipped_file = (name.size() - name.rfind(".bz2") == 4);
        xzipped_file = (name.size() - name.rfind(".xz")  == 3);

        if (gzipped_file)
          {
#ifdef LIBMESH_HAVE_GZSTREAM
            ogzstream *outf = new ogzstream;
            libmesh_assert(outf);
            out.reset(outf);
            outf->open(name.c_str(), std::ios::out);
#else
            libMesh::err << "ERROR: need gzstream to handle .gz files!!!"
                          << std::endl;
            libmesh_error();
#endif
          }
        else
          {
            std::ofstream *outf = new std::ofstream;
            libmesh_assert(outf);
            out.reset(outf);

            std::string new_name = 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);
          }

        libmesh_assert(out.get());
        libmesh_assert (out->good());
        return;
      }

    default:
      libmesh_error();
    }
}

template<typename T >

Xdr& libMesh::Xdr::operator<<

(

T &

a

)

[inline]

Same, but provides an ostream like interface.

Definition at line 127 of file xdr_cxx.h.

References data(), and writing().

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

template<typename T >

Xdr& libMesh::Xdr::operator>>

(

T &

a

)

[inline]

Same, but provides an istream like interface.

Definition at line 133 of file xdr_cxx.h.

References data(), and reading().

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

bool libMesh::Xdr::reading

(

)

const [inline]

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

Definition at line 101 of file xdr_cxx.h.

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

Referenced by libMesh::EquationSystems::_read_impl(), operator>>(), libMesh::System::read_header(), libMesh::System::read_legacy_data(), libMesh::System::read_parallel_data(), libMesh::XdrIO::read_serialized_bcs(), libMesh::XdrIO::read_serialized_connectivity(), libMesh::XdrIO::read_serialized_nodes(), libMesh::System::read_serialized_vector(), and libMesh::System::read_serialized_vectors().

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

void libMesh::Xdr::set_version

(

int

ver

)

[inline]

Sets the version of the file that is being read

Definition at line 149 of file xdr_cxx.h.

References version_number.

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

{ version_number = ver; }

int libMesh::Xdr::version

(

)

const [inline]

Gets the version of the file that is being read

Definition at line 154 of file xdr_cxx.h.

References version_number.

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

{ return version_number; }

bool libMesh::Xdr::writing

(

)

const [inline]

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

Definition at line 107 of file xdr_cxx.h.

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

Referenced by operator<<(), libMesh::EquationSystems::write(), libMesh::System::write_header(), libMesh::System::write_parallel_data(), libMesh::XdrIO::write_serialized_bcs(), libMesh::System::write_serialized_vector(), and libMesh::System::write_serialized_vectors().

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

---

Member Data Documentation

bool libMesh::Xdr::bzipped_file [private]

Definition at line 234 of file xdr_cxx.h.

Referenced by close(), and open().

char libMesh::Xdr::comm[xdr_MAX_STRING_LENGTH] [private]

Definition at line 229 of file xdr_cxx.h.

Referenced by comment(), and do_read().

const int libMesh::Xdr::comm_len [private]

A buffer to put comment strings into.

Definition at line 228 of file xdr_cxx.h.

Referenced by comment(), and do_read().

std::string libMesh::Xdr::file_name [private]

The file name

Definition at line 196 of file xdr_cxx.h.

Referenced by close(), and open().

FILE* libMesh::Xdr::fp [private]

File pointer.

Definition at line 211 of file xdr_cxx.h.

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

bool libMesh::Xdr::gzipped_file [private]

Are we reading/writing zipped files?

Definition at line 234 of file xdr_cxx.h.

Referenced by open().

AutoPtr<std::istream> libMesh::Xdr::in [private]

The input file stream.

Definition at line 218 of file xdr_cxx.h.

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

const XdrMODE libMesh::Xdr::mode [private]

The mode used for accessing the file.

Definition at line 191 of file xdr_cxx.h.

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

AutoPtr<std::ostream> libMesh::Xdr::out [private]

The output file stream.

Definition at line 223 of file xdr_cxx.h.

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

int libMesh::Xdr::version_number [private]

Version of the file being read

Definition at line 239 of file xdr_cxx.h.

Referenced by set_version(), and version().

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 206 of file xdr_cxx.h.

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

bool libMesh::Xdr::xzipped_file [private]

Definition at line 234 of file xdr_cxx.h.

Referenced by close(), and open().

---

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

• xdr_cxx.h
• xdr_cxx.C