BCP_buffer.hpp

Go to the documentation of this file.

// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef _BCP_BUFFER_H
#define _BCP_BUFFER_H

#include <memory>
#include <vector>

// This file is fully docified.

#include "BCP_error.hpp"
#include "BCP_string.hpp"
#include "BCP_message_tag.hpp"
#include "BCP_message.hpp"
#include "BCP_vector.hpp"

class BCP_buffer{
public:
   /* The data members are public for efficiency reasons. The message
       environment's receiving function should be able to directly manipulate
       these fields. However, making the virtual base class of all message
       passing environment to be a friend doesn't help... Anyway, access these
       fields sparingly.<br>
       THINK: maybe it's not that inefficient to access the fields thru
       functions... */
   BCP_message_tag _msgtag;
   int    _sender;
   size_t _pos;
   size_t _max_size;
   size_t _size;
   char*  _data;
public:
   //=========================================================================
   inline BCP_message_tag msgtag() const { return _msgtag; }
   inline int         sender() const { return _sender; }
   inline int         size() const { return _size; }
   inline const char* data() const { return _data; }
   //=========================================================================

   inline void set_position(const int pos) throw(BCP_fatal_error) {
     if (pos < 0 || pos > size())
       throw BCP_fatal_error("Incorrest buffer position setting.\n");
     _pos = pos;
   }
   inline void set_size(const int s) throw(BCP_fatal_error) {
     if (s < 0 || s > size())
       throw BCP_fatal_error("Incorrest buffer position setting.\n");
     _size = s;
   }
   inline void set_msgtag(const BCP_message_tag tag) { _msgtag = tag; }

  void set_content(const char* data, const size_t size,
                   int sender, BCP_message_tag msgtag) {
    _sender = sender;
    _msgtag = msgtag;
    if (_max_size < size) {
      delete[] _data;
      _data = new char[size];
      _max_size = size;
    }
    _pos = 0;
    _size = size;
    if (_size)
      memcpy(_data, data, size * sizeof(char));
   }
     
    
   BCP_buffer& operator=(const BCP_buffer& buf) {
      _msgtag = buf._msgtag;
      _sender = buf._sender;
      _pos = buf._pos;
      if (_max_size < buf._max_size) {
         delete[] _data;
         _data = new char[buf._max_size];
         _max_size = buf._max_size;
      }
      _size = buf._size;
      if (_size)
         memcpy(_data, buf._data, _size * sizeof(char));
      return *this;
   }
   inline void make_fit(const int add_size){
      if (_max_size < _size + add_size) {
         _max_size = _size + add_size;
         /* If > 1M then have spare space of 1/16th (~6%) of used space,
            if <= 1M then have 64K spare space */
         _max_size += (_max_size > 1<<20) ? (_max_size >> 4) : (1 << 16) ;
         char *new_data = new char[_max_size];
         if (_size)
            memcpy(new_data, _data, _size);
         delete[] _data;
         _data = new_data;
      }
   }
   inline void clear(){
      _msgtag = BCP_Msg_NoMessage;
      _size = 0;
      _pos = 0;
      _sender = -1;
   }

   template <class T> BCP_buffer& pack(const T& value) {
     make_fit( sizeof(T) );
     memcpy(_data + _size, &value, sizeof(T));
     _size += sizeof(T);
     return *this;
   }

   template <class T> BCP_buffer& unpack(T& value){
#ifdef PARANOID
     if (_pos + sizeof(T) > _size)
       throw BCP_fatal_error("Reading over the end of buffer.\n");
#endif
     memcpy(&value, _data + _pos, sizeof(T));
     _pos += sizeof(T);
     return *this;
   }

   template <class T> BCP_buffer& pack(const T* const values,
                                       const int length){
     make_fit( sizeof(int) + sizeof(T) * length );
     memcpy(_data + _size, &length, sizeof(int));
     _size += sizeof(int);
     if (length > 0){
       memcpy(_data + _size, values, sizeof(T) * length);
       _size += sizeof(T) * length;
     }
     return *this;
   }

   template <class T> BCP_buffer& unpack(T*& values, int& length,
                                         bool allocate = true)
     throw(BCP_fatal_error) {
     if (allocate) {
#ifdef PARANOID
       if (_pos + sizeof(int) > _size)
         throw BCP_fatal_error("Reading over the end of buffer.\n");
#endif
       memcpy(&length, _data + _pos, sizeof(int));
       _pos += sizeof(int);
       if (length > 0){
#ifdef PARANOID
         if (_pos + sizeof(T)*length > _size)
           throw BCP_fatal_error("Reading over the end of buffer.\n");
#endif
         values = new T[length];
         memcpy(values, _data + _pos, sizeof(T)*length);
         _pos += sizeof(T) * length;
       }
       
     } else { /* ! allocate */

       int l;
#ifdef PARANOID
       if (_pos + sizeof(int) > _size)
         throw BCP_fatal_error("Reading over the end of buffer.\n");
#endif
       memcpy(&l, _data + _pos, sizeof(int));
       _pos += sizeof(int);
       if (l != length)
         throw BCP_fatal_error("BCP_buffer::unpack() : bad array lentgh.\n");
       if (length > 0){
#ifdef PARANOID
         if (_pos + sizeof(T)*length > _size)
           throw BCP_fatal_error("Reading over the end of buffer.\n");
#endif
         memcpy(values, _data + _pos, sizeof(T)*length);
         _pos += sizeof(T) * length;
       }
       
     }
     
     return *this;
   }

   BCP_buffer& pack(const BCP_string& value){
      // must define here, 'cos in BCP_message.C we have only templated members
      int len = value.length();
      make_fit( sizeof(int) + len );
      memcpy(_data + _size, &len, sizeof(int));
      _size += sizeof(int);
      if (len > 0){
         memcpy(_data + _size, value.c_str(), len);
         _size += len;
      }
      return *this;
   }
   BCP_buffer& pack(BCP_string& value){
      // must define here, 'cos in BCP_message.C we have only templated members
      int len = value.length();
      make_fit( sizeof(int) + len );
      memcpy(_data + _size, &len, sizeof(int));
      _size += sizeof(int);
      if (len > 0){
         memcpy(_data + _size, value.c_str(), len);
         _size += len;
      }
      return *this;
   }
   BCP_buffer& unpack(BCP_string& value){
      int len;
      unpack(len);
      value.assign(_data + _pos, len);
      _pos += len;
      return *this;
   }

   // packing/unpacking for BCP_vec
   template <class T> BCP_buffer& pack(const BCP_vec<T>& vec) {
     int objnum = vec.size();
     int new_bytes = objnum * sizeof(T);
     make_fit( sizeof(int) + new_bytes );
     memcpy(_data + _size, &objnum, sizeof(int));
     _size += sizeof(int);
     if (objnum > 0){
       memcpy(_data + _size, vec.begin(), new_bytes);
       _size += new_bytes;
     }
     return *this;
   }

   template <class T> BCP_buffer& pack(const std::vector<T>& vec) {
     int objnum = vec.size();
     int new_bytes = objnum * sizeof(T);
     make_fit( sizeof(int) + new_bytes );
     memcpy(_data + _size, &objnum, sizeof(int));
     _size += sizeof(int);
     if (objnum > 0){
       memcpy(_data + _size, &vec[0], new_bytes);
       _size += new_bytes;
     }
     return *this;
   }

   template <class T> BCP_buffer& unpack(BCP_vec<T>& vec) {
     int objnum;
#ifdef PARANOID
     if (_pos + sizeof(int) > _size)
       throw BCP_fatal_error("Reading over the end of buffer.\n");
#endif
     memcpy(&objnum, _data + _pos, sizeof(int));
     _pos += sizeof(int);
     vec.clear();
     if (objnum > 0){
#ifdef PARANOID
       if (_pos + sizeof(T)*objnum > _size)
         throw BCP_fatal_error("Reading over the end of buffer.\n");
#endif
       vec.reserve(objnum);
       vec.insert(vec.end(), _data + _pos, objnum);
       _pos += objnum * sizeof(T);
     }
     return *this;
   }

   template <class T> BCP_buffer& unpack(std::vector<T>& vec) {
     int objnum;
#ifdef PARANOID
     if (_pos + sizeof(int) > _size)
       throw BCP_fatal_error("Reading over the end of buffer.\n");
#endif
     memcpy(&objnum, _data + _pos, sizeof(int));
     _pos += sizeof(int);
     vec.clear();
     if (objnum > 0){
#ifdef PARANOID
       if (_pos + sizeof(T)*objnum > _size)
         throw BCP_fatal_error("Reading over the end of buffer.\n");
#endif
       vec.insert(vec.end(), objnum, T());
       memcpy(&vec[0], _data + _pos, objnum * sizeof(T));
       _pos += objnum * sizeof(T);
     }
     return *this;
   }

   BCP_buffer() : _msgtag(BCP_Msg_NoMessage), _sender(-1), _pos(0),
                  _max_size(1<<16/*64K*/), _size(0),
                  _data(new char[_max_size]) {}
   BCP_buffer(const BCP_buffer& buf) :
      _msgtag(BCP_Msg_NoMessage), _sender(-1), _pos(0),
      _max_size(0), _size(0), _data(0){
         operator=(buf);
   }
   ~BCP_buffer() {
      delete[] _data;
   }
};

#endif