CkptByteArray.h

Go to the documentation of this file.

#ifndef CKPTBYTEARRAY_H_
#define CKPTBYTEARRAY_H_

#include <stdio.h>
#include <stdlib.h>
#include <string>

class CkptByteArray {

  static const unsigned int MIN_BUFFER_SIZE=64;
  static const unsigned int GROWTH_SIZE=MIN_BUFFER_SIZE;

public:
 CkptByteArray() {
   _bufferSize = MIN_BUFFER_SIZE;
   _dataBuffer = (char*)malloc(_bufferSize);
   _dataSize = 0;
   resetPtr();
 }

 CkptByteArray(unsigned int size) {
   _bufferSize = size;
   _dataBuffer = (char*)malloc(_bufferSize);
   _dataSize = 0;
   resetPtr();
 }

 CkptByteArray(char* buf, unsigned int bufSize) {
  _bufferSize = bufSize;
   _dataBuffer = (char*)malloc(bufSize);
   _dataSize = bufSize;
   memcpy(_dataBuffer, buf, bufSize);
   resetPtr();
 }

 ~CkptByteArray() {
   if (_dataBuffer != NULL) free(_dataBuffer);
 }

 bool writeBytes(char* userBuffer, unsigned int numBytes) {
   if ( (_dataSize + numBytes) > _bufferSize) {
     // Buffer is too small, attempt to grow
     if (grow() == false) return false;
   }

   memcpy(_currDataPtr, userBuffer, numBytes);
   _currDataPtr += numBytes;
   _dataSize    += numBytes;

   return true;
 }

 int readBytes(char* userBuffer, unsigned int numBytes) {
   char* userPtr = userBuffer;
   numBytes = (numBytes > bytesRemaining() ) ? bytesRemaining() : numBytes;
   for (unsigned int i=0; i < numBytes; i++) *userPtr++ = *_currDataPtr++;
   return numBytes;
 }
 bool write(long   &lValue) { return writeBytes( (char*)&lValue, sizeof(lValue)); }
 bool write(int    &iValue) { return writeBytes( (char*)&iValue, sizeof(iValue)); }
 bool write(short  &sValue) { return writeBytes( (char*)&sValue, sizeof(sValue)); }
 bool write(double &dValue) { return writeBytes( (char*)&dValue, sizeof(dValue)); }
 bool write(float  &fValue) { return writeBytes( (char*)&fValue, sizeof(fValue)); }
 bool write(char   &cValue) { return writeBytes( (char*)&cValue, sizeof(cValue)); }

 bool write(unsigned long   &ulValue) { return writeBytes( (char*)&ulValue, sizeof(ulValue)); }
 bool write(unsigned int    &uiValue) { return writeBytes( (char*)&uiValue, sizeof(uiValue)); }
 bool write(unsigned short  &usValue) { return writeBytes( (char*)&usValue, sizeof(usValue)); }
 //bool write(unsigned double &udValue) { return writeBytes( (char*)&udValue, sizeof(udValue)); }
 //bool write(unsigned float  &ufValue) { return writeBytes( (char*)&ufValue, sizeof(ufValue)); }
 bool write(unsigned char   &ucValue) { return writeBytes( (char*)&ucValue, sizeof(ucValue)); }

 bool write(std::string &str) {
   unsigned int strLen = str.length();
   if (write(strLen) == false) return false;
   return writeBytes((char*)str.c_str(), strLen);
 }
 long    readLong()   { long   v = *(long*)_currDataPtr;   _currDataPtr+=sizeof(long);   return v; }
 int     readInt()    { int    v = *(int*)_currDataPtr;    _currDataPtr+=sizeof(int);    return v; }
 short   readShort()  { short  v = *(short*)_currDataPtr;  _currDataPtr+=sizeof(short);  return v; }
 double  readDouble() { double v = *(double*)_currDataPtr; _currDataPtr+=sizeof(double); return v; }
 float   readFloat()  { float  v = *(float*)_currDataPtr;  _currDataPtr+=sizeof(float);  return v; }
 char    readChar()   { char   v = *_currDataPtr;          _currDataPtr+=sizeof(char);   return v; }

 unsigned long    readULong()   { unsigned long   v; readBytes((char*)&v, sizeof(unsigned long));   return v; }
 unsigned int     readUInt()    { unsigned int    v; readBytes((char*)&v, sizeof(unsigned int));    return v; }
 unsigned short   readUShort()  { unsigned short  v; readBytes((char*)&v, sizeof(unsigned short));  return v; }
 unsigned char    readUChar()   { unsigned char   v; readBytes((char*)&v, sizeof(unsigned char));   return v; }

 std::string readString() {
   unsigned int strLength = readUInt();
   char* buf = (char*)malloc(strLength+1);
   readBytes(buf, strLength);
   buf[strLength] = 0; // Have to null terminate before assigning to a std::string
   std::string str(buf, strLength);
   free(buf);
   return str;
 }
 void resetPtr() { _currDataPtr = _dataBuffer; }
 char* getDataPtr() { return _dataBuffer; }
 unsigned int getDataSize() { return _dataSize; }
 unsigned int bytesRemaining() { return (_dataSize - (_currDataPtr - _dataBuffer)); }

private:

 bool grow() {
   int dist = _currDataPtr - _dataBuffer;
   char* newBuffer = (char*)realloc(_dataBuffer, _bufferSize + GROWTH_SIZE);
   if (newBuffer == NULL) {
     return false;
   }
   _dataBuffer = newBuffer;
   _currDataPtr = newBuffer + dist;
   _bufferSize += GROWTH_SIZE;
   return true;
 }

 unsigned int _bufferSize;  
 unsigned int _dataSize;    
 char*        _dataBuffer;  
 char*        _currDataPtr; 
};

typedef CkptByteArray byte_array;

#endif /*CKPTBYTEARRAY_H_*/

---