KokoBuffer.h

Go to the documentation of this file.

//
//------------------------------------------------------------------------
//
// File   : KokoBuffer.h
// Author : Patrick McCormick (pat@acl.lanl.gov)
//
// $Date: 2003/08/04 04:57:49 $
// $Revision: 1.7 $
//
// This class implements a fairly straight-forward wrapper around an 
// unsigned char buffer.  This might be a good place to implement 
// compression routines in the future. 
//
// This code has similar features to the MPI pack and unpack routines.
//
// TODO NOTE: It may be necessary to use MPI_Alloc() for memory allocation if
//       you plan on using these buffers as contents for messages.  Is 
//       this only an issue with MPIPro???  
//
//------------------------------------------------------------------------
//
#ifndef KOKO_BUFFER_H_
#define KOKO_BUFFER_H_

#include "koko.h"

class KokoBuffer {

  public:
    KokoBuffer(void);
    KokoBuffer(unsigned int size);
    KokoBuffer(unsigned char *buf, unsigned int size, bool pad = false);
    KokoBuffer(const KokoBuffer &kbuf);

    inline ~KokoBuffer(void)
    { delete []_start; };

    //=================================================================
    // Get at or set the internal buffer.  If you modify the data in
    // the buffer, make sure you call setCurSize() to update the 
    // number of bytes (of true data) now stored in the buffer.  It is
    // also important to do this if you cast to an unsigned char * or
    // a void * and then write to the buffer directly. 
    inline unsigned char *GetData(void)
    { return _buf; };

    inline unsigned char *GetBuffer(void)
    { return _start; };

    inline operator unsigned char *(void)
    { return _buf; };

    inline operator void *(void)
    { return (void *)_buf; };

    inline bool SetCurSize(unsigned int csize)
    { 
      if (csize <= (_size + sizeof(KokoTag))) {
        _cursize = csize;
        return true;
      } else {
        return false;
      }
    };

    ///================================================================
    /// Copy the given buffer into the KokoBuffer.  This completely 
    /// replaces any data in the buffer. 
    void Memcopy(unsigned char *bufp, unsigned int size); 

    ///================================================================
    /// Pack the given data to end of the current buffer.  If you want
    /// to force the packing operation to start at the begining of the
    /// buffer call Pack() with no arguments. 
    ///
    inline void Pack(void)  // Enable pack mode. 
    { 
      _aptr    = _buf; 
      _cursize = 0;
    };

    bool Pack(unsigned char *bufp, unsigned int size); 

    ///================================================================
    /// Unpack/extract chunks of data from the buffer.  If you want to
    /// force the packing operations to start at the begining of the 
    /// buffer call Unpack() with no arguments.
    inline void Unpack(void)  // Enable extraction mode. 
    { _eptr = _buf; }; 

    bool Unpack(unsigned char *dest, unsigned int size);

    ///================================================================
    /// What size is the buffer (available and total).  
    inline unsigned int Size(void)  // Actual bytes in buffer. 
    { return _cursize; };

    inline unsigned int TotalSize(void) // Full buffer size.
    { return _size + sizeof(KokoTag); };

    inline void Resize(unsigned int size)
    { this->grow(size); };

    ///=================================================================
    /// Simple buffer locking -- not thread safe...  Warning!  For the
    /// most part the Lock() and Unlock methods are intended to be used
    /// by code that knows the buffer is not safe for use yet (in this 
    /// case the Comminicator class in the Koko Library).  Be extremely
    /// careful with these two routines if you are not implementing a 
    /// feature inside a communicator. 
    inline bool Locked(void) 
    { return _locked; };

    inline void Lock(void)
    { 
      _locked = true;
    };

    inline void Unlock(void)
    {
      _locked = false;
    };

    ///=================================================================
    /// Tag handling routines.  This routines are here as one possible 
    /// work-around of some message passing libraries not formally 
    /// supporting tagged messages. 
    void SetTag(KokoTag &tag);

    KokoTag GetTag(void);

  protected:

    ///=================================================================
    /// How many bytes free to have to work with in this buffer?
    inline unsigned int bytes_free(void)
    { return _size - _cursize; };

    inline unsigned int bytes_remain(unsigned char *ucp)
    { return ucp - _buf; };

    ///=================================================================
    /// Grow the buffer to accomodate the given new size.  This keeps the
    /// current buffer data. 
    void grow(unsigned int new_size);

  private:
    bool            _locked;       // To help out with async messaging.
    unsigned int    _size;         // Total size of the buffer.
    unsigned char  *_start;        // The true start of the buffer. 
    unsigned char  *_buf;          // The start of the user buffer.
    unsigned char  *_aptr;         // Pointer to next insertion point.
    unsigned char  *_eptr;         // Pointer to extraction point.
    unsigned int    _cursize;      // Byte size of items currently 
                                   //   stored in buffer.
    float           _growfact;     // Growth factor for buffer allocation.
};

#endif

---

Send questions, comments, and bug reports to: