DataBuffer.h

Go to the documentation of this file.

//- ****************************************************************************
//-
//- Copyright 2009 National Technology & Engineering Solutions of Sandia, LLC
//- (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S.
//- Government retains certain rights in this software.
//-
//- BSD Open Source License
//- All rights reserved.
//-
//- Redistribution and use in source and binary forms, with or without
//- modification, are permitted provided that the following conditions are met:
//-
//-   1. Redistributions of source code must retain the above copyright notice,
//-      this list of conditions and the following disclaimer.
//-
//-   2. Redistributions in binary form must reproduce the above copyright
//-      notice, this list of conditions and the following disclaimer in the
//-      documentation and/or other materials provided with the distribution.
//-
//-   3. Neither the name of the copyright holder nor the names of its
//-      contributors may be used to endorse or promote products derived from
//-      this software without specific prior written permission.
//-
//- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
//- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
//- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
//- ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
//- LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
//- CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
//- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
//- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
//- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
//- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
//- POSSIBILITY OF SUCH DAMAGE.
//-
//- ****************************************************************************
 
#ifndef DATABUFFER_H
#define DATABUFFER_H
 
// **** _SYSTEM INCLUDES_ ******************************************************
 
#include <iostream>
#include <cstring>
#include <fstream>
#include <sstream>
#include <string>
 
using namespace std;
 
// **** _LOCAL INCLUDES_ *******************************************************
 
#include "UtilGlobals.h"
#include "CPPUtils.h"
 
// **** _BEGIN SLBM NAMESPACE_ **************************************************
 
namespace util {
 
// **** _CLASS CONSTANTS_ ******************************************************
// **** _FORWARD REFERENCES_ ***************************************************
 
// **** _CLASS DEFINITION_ *****************************************************
//
//
//
// *****************************************************************************
//class PGL_EXP_IMP DataBuffer : public DataObject
class UTIL_EXP DataBuffer
{
  public:
 
    // **** _PUBLIC LIFECYCLES_ ************************************************
 
    DataBuffer();
    //- Public Default Constructor.
 
    DataBuffer(bool doPad);
    //- Standard constructor that sets the padding option to doPad.
 
    DataBuffer(string * str);
    //- Standard constructor that uses a string ptr provided.
 
    DataBuffer(const DataBuffer& db);
    //- Copy Constructor.
 
    virtual ~DataBuffer();
    //- Public destructor
 
    // **** _PUBLIC OPERATORS_ *************************************************
 
    DataBuffer&      operator=(const DataBuffer& db);
    //- Assignment operator
 
    // **** _PUBLIC METHODS_ ***************************************************
 
    void             dumpBuffer();
    //- Debug dump of the data.
 
    void             writeToFile(ofstream& ofs);
    void             writeToFile(fstream& ofs);
    //- Write the buffer to the output stream ofs
 
    void             readFromFile(fstream& ifs, int num_bytes);
    void             readFromFile(ifstream& ifs, int num_bytes);
    void             readFromFile(fstream& ifs, int64 filePos,
                                  int num_bytes);
    void             readFromFile(ifstream& ifs, int64 filePos,
                                  int num_bytes);
    //- read the num_bytes from the input file stream (ifs) into the buffer.
    //- The second form sets the streams input file pointer to file_pos as the
    //- point to begin reading.
 
    const string&    readMD5HashKey();
    //- Returns the md5 hash key assumed to be stored at the beginning of this
    //- DataBuffer (32 bytes). Don't call this function if a hash key was not
    //- stored at the beginning of the buffer. The buffer pointer (dbDataPos)
    //- is left unchanged on exit.
 
    string           generateMD5HashKey();
    //- Writes an md5 hash key generated from this DataBuffer into the first 32
    //- locations of the DataBuffer. This function assumes that the first 32
    //- positions of the DataBuffer were reserved for the hexadecimal string.
 
    string           generateDataBufMD5HashKey();
    //- Returns an MD5 hash key string that represents all the data
    //- stored in this data buffer.
 
    void             align4Byte();
    void             align8Byte();
    //- These functions ensure that the buffer position pointer (dbDataPos) is
    //- aligned on a 4 or 8 byte boundary, respectivly.
 
    void             checkBufferSize(int sincr);
    //- This function checks to make sure that the buffer is large enough to
    //- contain sincr more bytes ... if not it is resized so that it can.
 
    void             clear();
    //- Clears the buffer.
 
    const string&    readString();
    void             readString(string& str, int num_chars);
    void             readCharArray(char* array, int num_chars);
    //- Read string data. readString assumes the string length immediately
    //- precedes the string data. The other two functions read num_chars of
    //- characters at a time into a string or character array.
 
    uByte            readByte();
    uByte            readByte(int pos);
    void             readByteArray(uByte* array, int num_bytes);
    //- Read uByte data. readByte reads one uByte from the DataBuffer and
    //- updates buffer iterator. The second form specifies where to read but
    //- does not update the iterator. The last form reads num_bytes into the
    //- input array.
 
    bool             readBool();
    bool             readBool(int pos);
    void             readBoolArray(bool* array, int num_bools);
    //- Read bool data. readBool reads one bool from the DataBuffer and
    //- updates buffer iterator. The second form specifies where to read but
    //- does not update the iterator. The last form reads num_bool into the
    //- input array.
 
    int              readInt32();
    int              readInt32(int pos);
    int              readRawInt32();
    void             readIntArray(int* array, int num_ints);
    //- Read int data. readInt32 reads one int from the DataBuffer and
    //- updates buffer iterator. The second form specifies where to read but
    //- does not update the iterator. The third form is like the first except
    //- that byte alignment is assumed to be ok. This is faster but not as safe.
    //- The last form reads num_ints into the input array.
 
    int64            readInt64();
    int64            readInt64(int pos);
    int64            readRawInt64();
    void             readLongArray(int64* array, int num_longs);
    //- Read long data. readInt64 reads one long from the DataBuffer and
    //- updates buffer iterator. The second form specifies where to read but
    //- does not update the iterator. The third form is like the first except
    //- that byte alignment is assumed to be ok. This is faster but not as safe.
    //- The last form reads num_longs into the input array.
 
    float            readFloat();
    float            readFloat(int pos);
    float            readRawFloat();
    void             readFloatArray(float* array, int num_floats);
    //- Read float data. readFloat reads one float from the DataBuffer and
    //- updates buffer iterator. The second form specifies where to read but
    //- does not update the iterator. The third form is like the first except
    //- that byte alignment is assumed to be ok. This is faster but not as safe.
    //- The last form reads num_floats into the input array.
 
    double           readDouble();
    double           readDouble(int pos);
    double           readRawDouble();
    void             readDoubleArray(double* array, int num_doubles);
    //- Read double data. readDouble reads one double from the DataBuffer and
    //- updates buffer iterator. The second form specifies where to read but
    //- does not update the iterator. The third form is like the first except
    //- that byte alignment is assumed to be ok. This is faster but not as safe.
    //- The last form reads num_doubles into the input array.
 
    void             writeString(const string& in_string);
    void             writeString(char* char_string);
    void             writeCharArray(const char* array, int num_chars);
    //- Write string data to 'this' DataBuffer. The two writeString functions
    //- first writes the the input string length immediately followed by the
    //- string data. The last function writes num_chars from the input character
    //- array into 'this' DataBuffer.
 
    void             writeByte(uByte b);
    void             writeByte(uByte b, int pos);
    void             writeRawByte(uByte b);
    void             writeByteArray(const uByte* array, int num_bytes);
    //- Write uByte data. writeByte writes one uByte to the DataBuffer and
    //- updates buffer iterator. The second form specifies where to write but
    //- does not update the iterator. The third form is like the first except
    //- that buffer size checking is not performed and is assumed to be ok. The
    //- last form writes num_bytes from the input array into the 'this'
    //- DataBuffer.
 
    void             writeBool(bool b);
    void             writeBool(bool b, int pos);
    void             writeRawBool(bool b);
    void             writeBoolArray(const bool* array, int num_bools);
    //- Write bool data. writeBool writes one bool to the DataBuffer and
    //- updates buffer iterator. The second form specifies where to write but
    //- does not update the iterator. The third form is like the first except
    //- that buffer size checking is not performed and is assumed to be ok. The
    //- last form writes num_bools from the input array into the 'this'
    //- DataBuffer.
 
    void             writeInt32(int i);
    void             writeInt32(int i, int pos);
    void             writeRawInt32(int i);
    void             writeIntArray(const int* array, int num_ints);
    //- Write int data. writeInt32 writes one int to the DataBuffer and
    //- updates buffer iterator. The second form specifies where to write but
    //- does not update the iterator. The third form is like the first except
    //- that byte alignment and buffer size checking is not performed and is
    //- assumed to be ok. This is faster but not as safe. The last form writes
    //- num_ints from the input array into 'this' DataBuffer.
 
    void             writeInt64(int64 i);
    void             writeInt64(int64 i, int pos);
    void             writeRawInt64(int64 i);
    void             writeLongArray(const int64* array, int num_longs);
    //- Write long data. writeInt64 writes one long to the DataBuffer and
    //- updates buffer iterator. The second form specifies where to write but
    //- does not update the iterator. The third form is like the first except
    //- that byte alignment and buffer size checking is not performed and is
    //- assumed to be ok. This is faster but not as safe. The last form writes
    //- num_longs from the input array into 'this' DataBuffer.
 
    void             writeFloat(float f);
    void             writeFloat(float f, int pos);
    void             writeRawFloat(float f);
    void             writeFloatArray(const float* array, int num_floats);
    //- Write float data. writeFloat writes one float to the DataBuffer and
    //- updates buffer iterator. The second form specifies where to write but
    //- does not update the iterator. The third form is like the first except
    //- that byte alignment and buffer size checking is not performed and is
    //- assumed to be ok. This is faster but not as safe. The last form writes
    //- num_floats from the input array into 'this' DataBuffer.
 
    void             writeDouble(double d);
    void             writeDouble(double d, int pos);
    void             writeRawDouble(double d);
    void             writeDoubleArray(const double* array, int num_doubles);
    //- Write double data. writeDouble writes one double to the DataBuffer and
    //- updates buffer iterator. The second form specifies where to write but
    //- does not update the iterator. The third form is like the first except
    //- that byte alignment and buffer size checking is not performed and is
    //- assumed to be ok. This is faster but not as safe. The last form writes
    //- num_doubles from the input array into 'this' DataBuffer.
 
    static void      reverseBOArray(int n, char* a, int s);
    //- Reverses each s-byte element of array a containing n elements
    //- (s*n bytes). The element size s must be 2, 4, or 8.
 
    static void      reverseBO2Array(int n, char* a);
    static void      reverseBO4Array(int n, char* a);
    static void      reverseBO8Array(int n, char* a);
    //- Reverses the byte order of each element of a where a is an array of n
    //- 2, 4, or 8 byte elements. Used to convert between big-and
    //- little-endian formats.
 
    static void      reverseBO2(char* d);
    static void      reverseBO4(char* d);
    static void      reverseBO8(char* d);
    //- Reverses the byte order of d, where d is a 2, 4, or 8 byte array. Used
    //- to convert between big-and little-endian formats.
 
    // **** _PUBLIC PROPERTIES_ ************************************************
 
    static  string   class_name();
    virtual string   get_class_name() const;
    virtual int      class_size() const;
    //- Return class name and size.
 
    void             setSize(int num_bytes);
    //- This function reserves num_bytes in the buffer to minimize reallocation.
 
    int              size();
    //- Returns the DataBuffer size.
 
    void             resetPos();
    void             setPosToEnd();
    int              getPos() const;
    //- Reset, set, and get the current iterator position.
 
    void             incrementPos(int increment);
    void             decrementPos(int decrement);
    //- Increment / decrement the iterator position.
 
    string           getData() const;
    //- Return a const reference to 'this' DataBuffers data.
 
    int              getCapacity() const;
    //- Return the allocated capacity of this DataBuffer.
 
    char*            getPosPointer();
    //- Return a pointer at the current iterator location in the DataBuffers
    //- data.
 
    char*            getPosPointer(int pos);
    //- Return a pointer to position pos in 'this' DataBuffers data.
 
    void             setByteOrderReverse(bool bor);
    void             byteOrderReverseOn();
    void             byteOrderReverseOff();
    //- Sets the byte order reverse flag to bor (1st function), true (on
    //- function) or false (off function).
 
    static int       getAllocationReqSize();
    //- Returns the default DataBuffer allocation size.
 
    // **** _PUBLIC INQUIRIES_ *************************************************
 
    bool             isByteOrderReversed() const;
    //- Returns true if the byte order in reads and writes is reversed for all
    //- 2, 4, or 8 byte intrinsincs (short, int, long, float, double, etc.).
 
    // **** _PUBLIC DATA_ ******************************************************
 
    static const int ALLOCATION_REQ_SIZE;
 
    void reserve(int sze);
 
  protected:
 
    // **** _PRIVATE LIFECYCLES_ ***********************************************
    // **** _PROTECTED OPERATORS_ ***********************************************
    // **** _PROTECTED METHODS_ *************************************************
 
    // **** _PROTECTED DATA_ ****************************************************
 
    string*          dbData;
 
    int              dbDataPos;
 
    int              dbSize;
 
    bool             dbPad;
 
    bool             dbReverse;
 
    bool             dbOwnStr;
 
}; // DataBuffer End Definition
 
// **** _INLINE FUNCTION IMPLEMENTATIONS_ **************************************
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline string DataBuffer::class_name()
{
  return "DataBuffer";
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline string DataBuffer::get_class_name() const
{
  return class_name();
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline int DataBuffer::class_size() const
{
  return (int) sizeof(DataBuffer);
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::align4Byte()
{
  // get position from an 4 byte alignment location
 
  int sm = dbDataPos % sizeof(int);
 
  // If not zero and dbPad is not set then add pad
 
  if (sm && dbPad) dbDataPos += sizeof(int) - sm;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::align8Byte()
{
  // get position from an 8 byte alignment location
 
  int sm = dbDataPos % sizeof(double);
 
  // If not zero and dbPad is not set then add pad
 
  if (sm && dbPad) dbDataPos += sizeof(double) - sm;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::checkBufferSize(int sincr)
{
  // append spaces to dbData if its current size is less than the position
  // pointer + sincr.
 
  if (dbDataPos + sincr > (int) dbData->size())
    dbData->append(dbDataPos + sincr - dbData->size(), ' ');
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::clear()
{
  (*dbData) = "";
  dbDataPos = 0;
  dbSize = 0;
}
 
//----------
//----------------------------  READ FUNCTIONS ------------------------//
//----------
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline const string& DataBuffer::readString()
{
  int len;
  static string s;
 
  // read the data
 
  len = readInt32();
  s = dbData->substr(dbDataPos, len);
  dbDataPos += len;
 
  return s;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::readString(string& str, int num_chars)
{
  // read the data
 
  str = dbData->substr(dbDataPos, num_chars);
  dbDataPos += num_chars;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::readCharArray(char* array, int num_chars)
{
  // read the data
 
  memcpy(array, &(*dbData)[dbDataPos], num_chars);
  dbDataPos += num_chars;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline uByte DataBuffer::readByte()
{
  // read the data
 
  uByte b = *((uByte*) &(*dbData)[dbDataPos]);
  dbDataPos += sizeof(uByte);
  return b;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline uByte DataBuffer::readByte(int pos)
{
  // read the data
 
  uByte b = *((uByte*) &(*dbData)[pos]);
  return b;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::readByteArray(uByte* array, int num_bytes)
{
  // read the data
 
  memcpy(array, &(*dbData)[dbDataPos], num_bytes);
  dbDataPos += num_bytes;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline bool DataBuffer::readBool()
{
  // read the data
 
  bool b = *((bool*) &(*dbData)[dbDataPos]);
  dbDataPos += sizeof(bool);
  return b;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline bool DataBuffer::readBool(int pos)
{
  // read the data
 
  bool b = *((bool*) &(*dbData)[pos]);
  return b;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::readBoolArray(bool* array, int num_bools)
{
  // read the data
 
  memcpy(array, &(*dbData)[dbDataPos], num_bools);
  dbDataPos += num_bools;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline int DataBuffer::readInt32()
{
  // check alignment
 
  align4Byte();
 
  // read the data
 
  return readRawInt32();
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline int DataBuffer::readInt32(int pos)
{
  // read the data
 
  int i = *((int*) &(*dbData)[pos]);
  if (dbReverse) reverseBO4((char*) &i);
  return i;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline int DataBuffer::readRawInt32()
{
  // read the data
 
  int i = *((int*) &(*dbData)[dbDataPos]);
  if (dbReverse) reverseBO4((char*) &i);
  dbDataPos += sizeof(int);
  return i;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::readIntArray(int* array, int num_ints)
{
  int num_bytes = num_ints * sizeof(int);
 
  // check alignment
 
  align4Byte();
 
  // read the data
  memcpy(array, &(*dbData)[dbDataPos], num_bytes);
  if (dbReverse) reverseBO4Array(num_ints, (char*) array);
  dbDataPos += num_bytes;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline int64 DataBuffer::readInt64()
{
  // check alignment
 
  align8Byte();
 
  // read the data
 
  return readRawInt64();
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline int64 DataBuffer::readInt64(int pos)
{
  // read the data
 
  int64 i = *((int64*) &(*dbData)[pos]);
  if (dbReverse) reverseBO8((char*) &i);
  return i;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline int64 DataBuffer::readRawInt64()
{
  // read the data
 
  int64 i = *((int64*) &(*dbData)[dbDataPos]);
  if (dbReverse) reverseBO8((char*) &i);
  dbDataPos += sizeof(int64);
  return i;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::readLongArray(int64* array, int num_longs)
{
  int num_bytes = num_longs * sizeof(int64);
 
  // check alignment
 
  align8Byte();
 
  // read the data
 
  memcpy(array, &(*dbData)[dbDataPos], num_bytes);
  if (dbReverse) reverseBO8Array(num_longs, (char*) array);
  dbDataPos += num_bytes;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline float DataBuffer::readFloat()
{
  // check alignment
 
  align4Byte();
 
  // read the data
 
  return readRawFloat();
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline float DataBuffer::readFloat(int pos)
{
  // read the data
 
  float f = *((float*) &(*dbData)[pos]);
  if (dbReverse) reverseBO4((char*) &f);
  return f;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline float DataBuffer::readRawFloat()
{
  // read the data
 
  float f = *((float*) &(*dbData)[dbDataPos]);
  if (dbReverse) reverseBO4((char*) &f);
  dbDataPos += sizeof(float);
  return f;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::readFloatArray(float* array, int num_floats)
{
  int num_bytes = num_floats * sizeof(float);
 
  // check alignment
 
  align4Byte();
 
  // read the data
 
  memcpy(array, &(*dbData)[dbDataPos], num_bytes);
  if (dbReverse) reverseBO4Array(num_floats, (char*) array);
  dbDataPos += num_bytes;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline double DataBuffer::readDouble()
{
  // check alignment
 
  align8Byte();
 
  // read the data
 
  return readRawDouble();
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline double DataBuffer::readDouble(int pos)
{
  // read the data
 
  double d = *((double*) &(*dbData)[pos]);
  if (dbReverse) reverseBO8((char*) &d);
  return d;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline double DataBuffer::readRawDouble()
{
  // read the data
 
  double d = *((double*) &(*dbData)[dbDataPos]);
  if (dbReverse) reverseBO8((char*) &d);
  dbDataPos += sizeof(double);
  return d;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::readDoubleArray(double* array, int num_doubles)
{
  int num_bytes = num_doubles * sizeof(double);
 
  // check alignment
 
  align8Byte();
 
  // read the data
 
  memcpy(array, &(*dbData)[dbDataPos], num_bytes);
  if (dbReverse) reverseBO8Array(num_doubles, (char*) array);
  dbDataPos += num_bytes;
}
 
//----------
//----------------------------  WRITE FUNCTIONS ------------------------//
//----------
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeString(const string& in_string)
{
  // get total size
 
  int sz = (int) in_string.size() + sizeof(int);
 
  // check alignment
 
  align4Byte();
 
  // check buffer size
 
  checkBufferSize(sz);
 
  // write the data
 
  writeRawInt32((int) in_string.size());
 
  // In Sun's V5.2 CC compiler, string replace seems to have a bug or
  // odd behavior that is not understood.  Whenever a replace occurs
  // using the following line, the strings size() is reduced by
  // dbDataPos bytes???  So we will use memcpy instead!
  // dbData.replace(dbDataPos, dbDataPos + in_string.size(), in_string);
  memcpy(&(*dbData)[dbDataPos], &in_string[0], in_string.size());
 
  dbDataPos += (int) in_string.size();
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeString(char* char_string)
{
  string tmp_string = char_string;
  writeString(tmp_string);
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeCharArray(const char* array, int num_chars)
{
  // check buffer size
 
  checkBufferSize(num_chars);
 
  // write data
 
  memcpy(&(*dbData)[dbDataPos], array, num_chars);
  dbDataPos += num_chars;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeByte(uByte b)
{
  // check buffer size
 
  checkBufferSize(sizeof(uByte));
 
  // write the data
 
  writeRawByte(b);
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeByte(uByte b, int pos)
{
  // write the data
 
  *((uByte*) &(*dbData)[pos]) = b;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeRawByte(uByte b)
{
  // write the data
 
  *((uByte*) &(*dbData)[dbDataPos]) = b;
  dbDataPos += sizeof(uByte);
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeByteArray(const uByte* array, int num_bytes)
{
  // check buffer size
 
  checkBufferSize(num_bytes);
 
  // write data
 
  memcpy(&(*dbData)[dbDataPos], array, num_bytes);
  dbDataPos += num_bytes;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeBool(bool b)
{
  // check buffer size
 
  checkBufferSize(sizeof(bool));
 
  // write the data
 
  writeRawBool(b);
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeBool(bool b, int pos)
{
  // write the data
 
  *((bool*) &(*dbData)[pos]) = b;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeRawBool(bool b)
{
  // write the data
 
  *((bool*) &(*dbData)[dbDataPos]) = b;
  dbDataPos += sizeof(bool);
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeBoolArray(const bool* array, int num_bools)
{
  // check buffer size
 
  checkBufferSize(num_bools);
 
  // write data
 
  memcpy(&(*dbData)[dbDataPos], array, num_bools);
  dbDataPos += num_bools;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeInt32(int i)
{
  // check alignment
 
  align4Byte();
 
  // check buffer size
 
  checkBufferSize(sizeof(int));
 
  // write the data
 
  writeRawInt32(i);
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeInt32(int i, int pos)
{
  // write the data
 
  if (dbReverse) reverseBO4((char*) &i);
  *((int*) &(*dbData)[pos]) = i;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeRawInt32(int i)
{
  // write the data
 
  if (dbReverse) reverseBO4((char*) &i);
  *((int*) &(*dbData)[dbDataPos]) = i;
  dbDataPos += sizeof(int);
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeIntArray(const int* array, int num_ints)
{
  int num_bytes = num_ints * sizeof(int);
 
  // check alignment
 
  align4Byte();
 
  // check buffer size
 
  checkBufferSize(num_bytes);
 
  // write data
 
  memcpy(&(*dbData)[dbDataPos], array, num_bytes);
  if (dbReverse) reverseBO4Array(num_ints, &(*dbData)[dbDataPos]);
  dbDataPos += num_bytes;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeInt64(int64 i)
{
  // check alignment
 
  align8Byte();
 
  // check buffer size
 
  checkBufferSize(sizeof(int64));
 
  // write the data
 
  writeRawInt64(i);
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeInt64(int64 i, int pos)
{
  // write the data
 
  if (dbReverse) reverseBO8((char*) &i);
  *((int64*) &(*dbData)[pos]) = i;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeRawInt64 (int64 i)
{
  // write the data
 
  if (dbReverse) reverseBO8((char*) &i);
  *((int64*) &(*dbData)[dbDataPos]) = i;
  dbDataPos += sizeof(int64);
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeLongArray(const int64* array, int num_longs)
{
  int num_bytes = num_longs * sizeof(int64);
 
  // check alignment
 
  align8Byte();
 
  // check buffer size
 
  checkBufferSize(num_bytes);
 
  // write data
 
  memcpy(&(*dbData)[dbDataPos], array, num_bytes);
  if (dbReverse) reverseBO8Array(num_longs, &(*dbData)[dbDataPos]);
  dbDataPos += num_bytes;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeFloat(float f)
{
  // check alignment
 
  align4Byte();
 
  // check buffer size
 
  checkBufferSize(sizeof(float));
 
  // write the data
 
  writeRawFloat(f);
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeFloat(float f, int pos)
{
  // write the data
 
  if (dbReverse) reverseBO4((char*) &f);
  *((float*) &(*dbData)[pos]) = f;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeRawFloat(float f)
{
  // write the data
 
  if (dbReverse) reverseBO4((char*) &f);
  *((float*) &(*dbData)[dbDataPos]) = f;
  dbDataPos += sizeof(float);
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeFloatArray(const float* array, int num_floats)
{
  int num_bytes = num_floats * sizeof(float);
 
  // check alignment
 
  align4Byte();
 
  // check buffer size
 
  checkBufferSize(num_bytes);
 
  // write data
 
  memcpy(&(*dbData)[dbDataPos], array, num_bytes);
  if (dbReverse) reverseBO4Array(num_floats, &(*dbData)[dbDataPos]);
  dbDataPos += num_bytes;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeDouble(double d)
{
  // check alignment
 
  align8Byte();
 
  // check buffer size
 
  checkBufferSize(sizeof(double));
 
  // write data
 
  writeRawDouble(d);
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeDouble(double d, int pos)
{
  // write the data
 
  if (dbReverse) reverseBO8((char*) &d);
  *((double*) &(*dbData)[pos]) = d;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeRawDouble(double d)
{
  // write data
 
  if (dbReverse) reverseBO8((char*) &d);
  *((double*) &(*dbData)[dbDataPos]) = d;
  dbDataPos += sizeof(double);
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::writeDoubleArray(const double* array, int num_doubles)
{
  int num_bytes = num_doubles * sizeof(double);
 
  // check alignment
 
  align8Byte();
 
  // check buffer size
 
  checkBufferSize(num_bytes);
 
  // write data
 
  memcpy(&(*dbData)[dbDataPos], array, num_bytes);
  if (dbReverse) reverseBO8Array(num_doubles, &(*dbData)[dbDataPos]);
  dbDataPos += num_bytes;
}
 
//----------
//----------------------------  PROPERTY FUNCTIONS ------------------------//
//----------
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::setSize(int num_bytes)
{
  dbData->resize(num_bytes);
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline int DataBuffer::size()
{
  // return dbData.size();
 
  if (dbDataPos > dbSize)
    dbSize = dbDataPos;
 
  return dbSize;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::resetPos()
{
  if (dbDataPos > dbSize)
    dbSize = dbDataPos;
 
  dbDataPos = 0;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::setPosToEnd()
{
  if (dbDataPos > dbSize)
    dbSize = dbDataPos;
 
  dbDataPos = dbSize;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline int DataBuffer::getPos() const
{
  return dbDataPos;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::incrementPos(int increment)
{
  dbDataPos += increment;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::decrementPos(int decrement)
{
  dbDataPos -= decrement;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline string DataBuffer::getData() const
{
  return *dbData;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline int DataBuffer::getCapacity() const
{
  return (int) dbData->capacity();
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline char* DataBuffer::getPosPointer()
{
  char* p = &(*dbData)[dbDataPos];
  return p;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline char* DataBuffer::getPosPointer(int pos)
{
  char* p = &(*dbData)[pos];
  return p;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::reverseBO2(char* d)
{
  char tmp = d[0];
  d[0] = d[1];
  d[1] = tmp;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::reverseBO4(char* d)
{
  char tmp = d[0];
  d[0] = d[3];
  d[3] = tmp;
 
  tmp = d[1];
  d[1] = d[2];
  d[2] = tmp;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::reverseBO8(char* d)
{
  char tmp = d[0];
  d[0] = d[7];
  d[7] = tmp;
 
  tmp = d[1];
  d[1] = d[6];
  d[6] = tmp;
 
  tmp = d[2];
  d[2] = d[5];
  d[5] = tmp;
 
  tmp = d[3];
  d[3] = d[4];
  d[4] = tmp;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::setByteOrderReverse(bool bor)
{
  dbReverse = bor;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::byteOrderReverseOn()
{
  dbReverse = true;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::byteOrderReverseOff()
{
  dbReverse = false;
}
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline bool DataBuffer::isByteOrderReversed() const
{
  return dbReverse;
}
 
//} // end namespace pgl
 
// **** _FUNCTION DESCRIPTION_ *************************************************
//
//
// *****************************************************************************
inline void DataBuffer::reserve(int sze)
{
  dbData->reserve(sze);
}
 
} // end util namespace
 
#endif // DATABUFFER_H