JByteArrayIO.hh

Go to the documentation of this file.

#ifndef __JIO__JBYTEARRAYIO__
#define __JIO__JBYTEARRAYIO__
 
#include <cstring>
#include <algorithm>
#include <vector>
 
#include "JIO/JSerialisable.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JIO {}
namespace JPP { using namespace JIO; }
 
namespace JIO {
 
 
  /**
   * Byte array binary input.
   * This class implements the JReader interface.
   */
  class JByteArrayReader : 
    public JReader 
  {
  public:
    /**
     * Default constructor.
     */
    JByteArrayReader() :
      __data(NULL),
      __size(0),
      __pos (0)
    {}
 
 
    /**
     * Constructor.
     *
     * \param  buffer  pointer to input data
     * \param  length  number of bytes
     */
    JByteArrayReader(const char* buffer, const int length = 0) :
      __data(buffer),
      __size(length),
      __pos (0)
    {}
 
 
    /**
     * Get size.
     *
     * \return         number of bytes
     */
    int size() const
    {
      return __size;
    }
 
 
    /**
     * Get data.
     *
     * \return         pointer to data
     */
    const char* data() const
    {
      return __data;
    }
 
 
    /**
     * Get remaining size.
     *
     * \return         number of bytes
     */
    int getRemainingSize() const
    {
      return __size - __pos;
    }
 
 
    /**
     * Get remaining data.
     *
     * \return         pointer to remaining data
     */
    const char* getRemainingData() const
    {
      return __data + __pos;
    }
 
 
    /**
     * Get read position.
     *
     * \return         read position
     */
    int tellg() const
    {
      return __pos;
    }
 
 
    /**
     * Set read position.
     *
     * \param pos      read position
     */
    void seekg(const int pos)
    {
      __pos = pos;
    }
 
 
    /**
     * Status of reader.
     *
     * \return         status of this reader
     */
    virtual bool getStatus() const 
    { 
      return __size - __pos >= 0; 
    }
 
 
    /**
     * Read byte array.
     *
     * \param  buffer  pointer to byte array
     * \param  length  number of bytes
     * \return         number of bytes
     */
    virtual int read(char* buffer, const int length)
    { 
      memcpy(buffer, __data + __pos, length);
        
      __pos += length;
 
      return length;
    }
 
 
  protected:
    const char* __data;
    int         __size;
    int         __pos;
  };
 
 
  /**
   * Byte array binary output.
   * This class implements the JWriter interface.
   */
  class JByteArrayWriter : 
    public JWriter,
    public std::vector<char>
  {
  public:
    /**
     * Constructor.
     *
     * \param  size    reserved number of bytes
     */
    JByteArrayWriter(const int size = 65536) :
      std::vector<char>(),
      __pos(0)
    {
      reserve(size);
    }
 
 
    /**
     * Status of writer.
     *
     * \return         status of this writer
     */
    virtual bool getStatus() const 
    { 
      return true; 
    }
 
 
    /**
     * Clear buffer.
     */
    void clear()
    {
      std::vector<char>::clear();
 
      __pos = 0;
    }
 
 
    /**
     * Get write position.
     *
     * \return         write position
     */
    int tellp() const
    {
      return __pos;
    }
 
 
    /**
     * Set write position.
     *
     * \param pos      write position
     */
    void seekp(const int pos)
    {
      __pos = pos;
    }
 
 
    /**
     * Write byte array.
     *
     * \param  buffer  pointer to byte array
     * \param  length  number of bytes
     * \return         number of bytes
     */
    virtual int write(const char* buffer, const int length)
    { 
      if (__pos + length > (int) this->size()) {
        this->resize(__pos + length);
      }
 
      memcpy(this->data() + __pos, buffer, length);
 
      __pos += length;
 
      return length;
    }
 
 
  protected:
    int   __pos;
  };
}
 
#endif