JBufferedIO.hh

Go to the documentation of this file.

#ifndef __JIO__JBUFFEREDIO__
#define __JIO__JBUFFEREDIO__
 
#include <algorithm>
#include <cstring>
 
#include "JLang/JSinglePointer.hh"
#include "JIO/JSerialisable.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JIO {}
namespace JPP { using namespace JIO; }
 
namespace JIO {
 
 
  /**
   * Buffered binary input.
   * This class implements the JReader interface.
   */
  class JBufferedReader : 
    public JReader 
  {
  public:
    /**
     * Constructor.
     * Note that this object owns the reader pointed to.
     *
     * \param  __in    pointer to reader
     * \param  __size  size of internal buffer
     */
    JBufferedReader(JReader* __in, const int __size = 1048576) :
      in(__in)
    {
      size   = std::max(__size, 1024);
      buffer = new char[size];
 
      reset();
    }
 
 
    /**
     * Destructor.
     */
    ~JBufferedReader()
    {
      delete [] buffer;
    }
 
 
    /**
     * Status of reader.
     *
     * \return         status of this reader
     */
    virtual bool getStatus() const override 
    { 
      return in->getStatus() || !eof;
    }
 
 
    /**
     * Clear status of reader.
     */
    virtual void clear() override 
    {
      in->clear();
    }
 
 
    /**
     * Read byte array.
     *
     * \param  zbuf    pointer to byte array
     * \param  n       number of bytes
     * \return         number of bytes
     */
    virtual int read(char* zbuf, int n) override 
    { 
      for (int i = 0; i != n; ) {
 
        int m = n - i;
 
        if (m > ls - pos) {
          
          memmove(buffer, buffer + pos, ls - pos);
          
          ls  -= pos;
          pos  = 0;
          ls  += in->read(buffer + ls, size - ls); 
 
          if (m > ls) {
 
            if (ls == 0) {
 
              eof = true;
 
              return n - i;
            }
 
            m = ls;
          }
        }
 
        memcpy(zbuf + i, buffer + pos, m);
        
        i   += m;
        pos += m;
      }
 
      eof = false;
 
      return n;
    }
 
  protected:
    /**
     * Reset.
     */
    void reset()
    {
      pos = 0;
      ls  = 0;
      eof = true;
    }
 
    JLANG::JSinglePointer<JReader> in;
 
    char* buffer;  //!< internal buffer
    int   size;    //!< size of internal buffer
    int   pos;     //!< pointer to begin of available data
    int   ls;      //!< pointer to end   of available data
    bool  eof;     //!< end of file
 
  private:
    JBufferedReader(const JBufferedReader&);
    JBufferedReader(JBufferedReader&&);
    JBufferedReader& operator=(const JBufferedReader&);
    JBufferedReader& operator=(JBufferedReader&&);
  };
 
 
  /**
   * Buffered binary output.
   * This class implements the JWriter interface.
   */
  class JBufferedWriter : 
    public JWriter 
  {
  public:
    /**
     * Constructor.
     * Note that this object owns the writer pointed to.
     *
     * \param  __out   pointer to writer
     * \param  __size  size of internal buffer
     */
    JBufferedWriter(JWriter* __out, const int __size = 1048576) :
      out(__out)
    {
      size   = std::max(__size, 1024);
      buffer = new char[size];
 
      pos = 0;
    }
 
 
    /**
     * Destructor.
     */
    ~JBufferedWriter()
    {
      flush();
 
      delete [] buffer;
    }
 
 
    /**
     * Status of writer.
     *
     * \return         status of this writer
     */
    virtual bool getStatus() const override 
    { 
      return (bool) *out;
    }
 
 
    /**
     * Write byte array.
     *
     * \param  zbuf    pointer to byte array
     * \param  n       number of bytes
     * \return         number of bytes
     */
    virtual int write(const char* zbuf, int n) override 
    { 
      for (int i = 0; i != n; ) {
 
        int m = n - i;
 
        if (m > size - pos) {
 
          flush();
        
          if (m > size - pos) {
            m = size - pos;
          }
        }
 
        memcpy(buffer + pos, zbuf + i, m);
        
        i   += m;
        pos += m;
      }
 
      return n;
    }
 
    
    /**
     * Write internal data to output.
     */
    void flush()
    {
      pos -= out->write(buffer, pos); 
    }
 
 
  protected:
    JLANG::JSinglePointer<JWriter> out;
 
    char* buffer;  //!< internal buffer
    int   size;    //!< size of internal buffer
    int   pos;     //!< pointer to end of buffered data
 
  private:
    JBufferedWriter(const JBufferedWriter&);
    JBufferedWriter(JBufferedWriter&&);
    JBufferedWriter& operator=(const JBufferedWriter&);
    JBufferedWriter& operator=(JBufferedWriter&&);
  };
}
 
#endif