Polaris: BinPtr.h Source File

BinPtr.h Go to the documentation of this file. #ifndef _BIN_PTR_H #define _BIN_PTR_H /// /// /// file BinPtr.h /// /// /// \class BinPtr /// \brief a class for doing item I/O on a memory buffer. /// \defgroup Polaris /// \ingroup Polaris /// Base /// \see BinPtr.h /// \see BinPtr.h /// /// \endcode /// \section Overview Overview /// This classes is intended for reading/writing binary objects to /// a section of memory. It is essentially a frontend to the <memory.h> /// commands. In addition, we can also read from a file with the same /// interface. /// /// \endcode /// \section Description Description /// The BinRep class needs to have easy access to the binary representation /// of items stored in a stream of memory. Also, we need to be able to /// do the same operations is the memory buffer is mapped to a iostream. /// #include "ClassNames.h" #include <stream.h> #include <memory.h> #include "macros.h" /// typedef char binptr_1; typedef short binptr_2; typedef int binptr_4; typedef double binptr_8; /// class BinPtr { private: iostream * _fs; ///< The file being used. Will be NULL is not used. char *_base; ///< The beginning of the memory buffer. char *_cur; ///< The current position in the memory buffer. public: BinPtr(const void *base); ///< Initialize the BinPtr the the memory buffer at base. BinPtr(istream & fs); ///< Initialize the BinPtr to the input stream fs. BinPtr(ostream & fs); ///< Initialize the BinPtr to the output stream fs. ~BinPtr(); ///< Destroy the BinPtr. void fetch(void *buf, int length); ///< Read in length bytes from the input. void fetch(binptr_4 & x); ///< Read a 4 byte integer. void fetch(binptr_2 & x); ///< Read a 2 byte integer. void fetch(binptr_1 & x); ///< Read a 1 byte integer. void fetch(double &x); ///< Read an 8 byte floating point number. void store(const void *buf, int length); ///< Write out length bytes to the output. void store(long value, int length); ///< Write value as a length byte integer. void store(binptr_4 & x); ///< Write a 4 byte integer. void store(binptr_2 & x); ///< Write a 2 byte integer. void store(binptr_1 & x); ///< Write a 1 byte integer. void store(double &x); ///< Write an 8 byte floating point number. inline void reset(const void *base); ///< Initialize the BinPtr to base. inline void reset(istream & fs); ///< Initialize the BinPtr to input from fs. inline void reset(ostream & fs); ///< Initialize the BinPtr to write to fs. }; inline BinPtr::BinPtr(const void *base) { #ifdef CLASS_INSTANCE_REGISTRY register_instance(BIN_PTR, sizeof(BinPtr), this); #endif reset(base); } inline BinPtr::BinPtr(istream & fs) { #ifdef CLASS_INSTANCE_REGISTRY register_instance(BIN_PTR, sizeof(BinPtr), this); #endif reset(fs); } inline BinPtr::BinPtr(ostream & fs) { #ifdef CLASS_INSTANCE_REGISTRY register_instance(BIN_PTR, sizeof(BinPtr), this); #endif reset(fs); } inline BinPtr::~BinPtr() { #ifdef CLASS_INSTANCE_REGISTRY unregister_instance(BIN_PTR, this); #endif } inline void BinPtr::fetch(void *buf, int length) { if (_fs) _fs->read((char *) buf, length); else { memcpy(buf, _cur, length); _cur += length; } } inline void BinPtr::fetch(binptr_4 & x) { if (_fs) _fs->read((char *) &x, sizeof(x)); else { memcpy(&x, _cur, sizeof(x)); _cur += sizeof(x); } } inline void BinPtr::fetch(binptr_2 & x) { if (_fs) _fs->read((char *) &x, sizeof(x)); else { memcpy(&x, _cur, sizeof(x)); _cur += sizeof(x); } } inline void BinPtr::fetch(binptr_1 & x) { if (_fs) _fs->read((char *) &x, sizeof(x)); else { memcpy(&x, _cur, sizeof(x)); _cur += sizeof(x); } } inline void BinPtr::fetch(double &x) { if (_fs) _fs->read((char *) &x, sizeof(x)); else { memcpy(&x, _cur, sizeof(x)); _cur += sizeof(x); } } inline void BinPtr::store(const void *buf, int length) { if (_fs) _fs->write((char *) buf, length); else { memcpy(_cur, buf, length); _cur += length; } } inline void BinPtr::store(long value, int length) { switch (length) { case 1: { binptr_1 x = (binptr_1) value; if (_fs) _fs->write((char *) &x, sizeof(x)); else { memcpy(_cur, &x, length); _cur += length; } } break; case 2: { binptr_2 x = (binptr_2) value; if (_fs) _fs->write((char *) &x, sizeof(x)); else { memcpy(_cur, &x, length); _cur += length; } } break; case 4: { binptr_4 x = (binptr_4) value; if (_fs) _fs->write((char *) &x, sizeof(x)); else { memcpy(_cur, &x, length); _cur += length; } } break; } } inline void BinPtr::store(binptr_4 & x) { if (_fs) _fs->write((char *) &x, sizeof(x)); else { memcpy(_cur, &x, sizeof(x)); _cur += sizeof(x); } } inline void BinPtr::store(binptr_2 & x) { if (_fs) _fs->write((char *) &x, sizeof(x)); else { memcpy(_cur, &x, sizeof(x)); _cur += sizeof(x); } } inline void BinPtr::store(binptr_1 & x) { if (_fs) _fs->write((char *) &x, sizeof(x)); else { memcpy(_cur, &x, sizeof(x)); _cur += sizeof(x); } } inline void BinPtr::store(double &x) { if (_fs) _fs->write((char *) &x, sizeof(x)); else { memcpy(_cur, &x, sizeof(x)); _cur += sizeof(x); } } inline void BinPtr::reset(const void *base) { _cur = _base = (char *) base; _fs = 0; } inline void BinPtr::reset(istream & fs) { _cur = _base = 0; _fs = (iostream *) & fs; } inline void BinPtr::reset(ostream & fs) { _cur = _base = 0; _fs = (iostream *) & fs; } #endif

© 1995-2005 University of Illinois, Urbana-Champaign. All rights reserved.  Fri Mar 25 23:05:41 2005