PackBuf.h

/*  _________________________________________________________________________
 *
 *  UTILIB: A utility library for developing portable C++ codes.
 *  Copyright (c) 2001, Sandia National Laboratories.
 *  This software is distributed under the GNU Lesser General Public License.
 *  For more information, see the README file in the top UTILIB directory.
 *  _________________________________________________________________________
 */

//
// PackBuf.h
//
#ifndef __PackBuf_h
#define __PackBuf_h

#ifdef __GNUC__
#pragma interface
#endif
 
#include "utilib_dll.h"

typedef unsigned char unsigned_char;
typedef unsigned short unsigned_short;
typedef unsigned int unsigned_int;
typedef unsigned long unsigned_long;


//---------------------------------------------------------------------
//
// PackBuffer
//
//---------------------------------------------------------------------

class UTILIB_API PackBuffer {
 
public:
 
  PackBuffer(int size_=1024) {index=0; size=size_; buffer = new char [size_];}
  ~PackBuffer() {if (buffer) delete buffer;}
 
  const char* buf() {return buffer;}
  int len() {return index;}
  void reset() {index=0;}

  void pack(const int* data, const int num=1);
  void pack(const unsigned_int* data, const int num=1);
  void pack(const long* data, const int num=1);
  void pack(const unsigned_long* data, const int num=1);
  void pack(const short* data, const int num=1);
  void pack(const unsigned_short* data, const int num=1);
  void pack(const char* data, const int num=1);
  void pack(const unsigned_char* data, const int num=1);
  void pack(const double* data, const int num=1);
  void pack(const float* data, const int num=1);
  void pack(const bool* data, const int num=1);

  void pack(const int data)             {pack(&data);}
  void pack(const unsigned_int data)    {pack(&data);}
  void pack(const long data)            {pack(&data);}
  void pack(const unsigned_long data)   {pack(&data);}
  void pack(const short data)           {pack(&data);}
  void pack(const unsigned_short data)  {pack(&data);}
  void pack(const char data)            {pack(&data);}
  void pack(const unsigned_char data)   {pack(&data);}
  void pack(const double data)          {pack(&data);}
  void pack(const float data)           {pack(&data);}
  void pack(const bool data)            {pack(&data);}

protected:
 
  char* buffer;
  int index;
  int size;
  void resize(const int newsize);

};
 
 

inline PackBuffer& operator<< (PackBuffer& buff, const int data)
        {buff.pack(data); return buff;}
inline PackBuffer& operator<< (PackBuffer& buff, const unsigned_int data)
        {buff.pack(data); return buff;}
inline PackBuffer& operator<< (PackBuffer& buff, const long data)
        {buff.pack(data); return buff;}
inline PackBuffer& operator<< (PackBuffer& buff, const unsigned_long data)
        {buff.pack(data); return buff;}
inline PackBuffer& operator<< (PackBuffer& buff, const short data)
        {buff.pack(data); return buff;}
inline PackBuffer& operator<< (PackBuffer& buff, const unsigned_short data)
        {buff.pack(data); return buff;}
inline PackBuffer& operator<< (PackBuffer& buff, const char data)
        {buff.pack(data); return buff;}
inline PackBuffer& operator<< (PackBuffer& buff, const unsigned_char data)
        {buff.pack(data); return buff;}
inline PackBuffer& operator<< (PackBuffer& buff, const double data)
        {buff.pack(data); return buff;}
inline PackBuffer& operator<< (PackBuffer& buff, const float data)
        {buff.pack(data); return buff;}
inline PackBuffer& operator<< (PackBuffer& buff, const bool data)
        {buff.pack(data); return buff;}


//---------------------------------------------------------------------
//
// UnPackBuffer
//
//---------------------------------------------------------------------

class UTILIB_API UnPackBuffer {
 
public:
 
  void setup(char* buf_, int size_, int flag=0);

  UnPackBuffer() : buffer(0), own_flag(0)
        {setup(0,0,0);}
  UnPackBuffer(int size_) : buffer(0), own_flag(0)
        {setup(new char [size_],size_,1);}
  UnPackBuffer(char* buf_, int size_, int flag=0) : buffer(0), own_flag(0)
        {setup(buf_,size_,flag);}
  ~UnPackBuffer() {if (buffer && own_flag) delete buffer;}

  void resize(const int newsize);
  const char* buf() {return buffer;}
  int len() {return size;}
  int curr() {return index;}
  void reset() {index=0;}

  void unpack(int* data, const int num=1);
  void unpack(unsigned_int* data, const int num=1);
  void unpack(long* data, const int num=1);
  void unpack(unsigned_long* data, const int num=1);
  void unpack(short* data, const int num=1);
  void unpack(unsigned_short* data, const int num=1);
  void unpack(char* data, const int num=1);
  void unpack(unsigned_char* data, const int num=1);
  void unpack(double* data, const int num=1);
  void unpack(float* data, const int num=1);
  void unpack(bool* data, const int num=1);

  void unpack(int& data)                {unpack(&data);}
  void unpack(unsigned_int& data)       {unpack(&data);}
  void unpack(long& data)               {unpack(&data);}
  void unpack(unsigned_long& data)      {unpack(&data);}
  void unpack(short& data)              {unpack(&data);}
  void unpack(unsigned_short& data)     {unpack(&data);}
  void unpack(char& data)               {unpack(&data);}
  void unpack(unsigned_char& data)      {unpack(&data);}
  void unpack(double& data)             {unpack(&data);}
  void unpack(float& data)              {unpack(&data);}
  void unpack(bool& data)               {unpack(&data);}

protected:
 
  char* buffer;
  int index;
  int size;
  int own_flag;

};
 
 

inline UnPackBuffer& operator>> (UnPackBuffer& buff, int& data)
        {buff.unpack(data); return buff;}
inline UnPackBuffer& operator>> (UnPackBuffer& buff, unsigned_int& data)
        {buff.unpack(data); return buff;}
inline UnPackBuffer& operator>> (UnPackBuffer& buff, long& data)
        {buff.unpack(data); return buff;}
inline UnPackBuffer& operator>> (UnPackBuffer& buff, unsigned_long& data)
        {buff.unpack(data); return buff;}
inline UnPackBuffer& operator>> (UnPackBuffer& buff, short& data)
        {buff.unpack(data); return buff;}
inline UnPackBuffer& operator>> (UnPackBuffer& buff, unsigned_short& data)
        {buff.unpack(data); return buff;}
inline UnPackBuffer& operator>> (UnPackBuffer& buff, char& data)
        {buff.unpack(data); return buff;}
inline UnPackBuffer& operator>> (UnPackBuffer& buff, unsigned_char& data)
        {buff.unpack(data); return buff;}
inline UnPackBuffer& operator>> (UnPackBuffer& buff, double& data)
        {buff.unpack(data); return buff;}
inline UnPackBuffer& operator>> (UnPackBuffer& buff, float& data)
        {buff.unpack(data); return buff;}
inline UnPackBuffer& operator>> (UnPackBuffer& buff, bool& data)
        {buff.unpack(data); return buff;}


//---------------------------------------------------------------------
//
// PackSize
//
//---------------------------------------------------------------------

int PackSize(const int& data, const int num=1);
int PackSize(const unsigned_int& data, const int num=1);
int PackSize(const long& data, const int num=1);
int PackSize(const unsigned_long& data, const int num=1);
int PackSize(const short& data, const int num=1);
int PackSize(const unsigned_short& data, const int num=1);
int PackSize(const char& data, const int num=1);
int PackSize(const unsigned_char& data, const int num=1);
int PackSize(const double& data, const int num=1);
int PackSize(const float& data, const int num=1);
int PackSize(const bool& data, const int num=1);


#endif // __PackBuf_h