JSocketChannel.hh

Go to the documentation of this file.

#ifndef __JNET__JSOCKETCHANNEL__
#define __JNET__JSOCKETCHANNEL__

#include <vector>
#include <string.h>

#include "JLang/JException.hh"
#include "JIO/JByteArrayIO.hh"
#include "JNet/JSocketNonblocking.hh"


/**
 * \author mdejong
 */

namespace JNET {}
namespace JPP { using namespace JNET; }

namespace JNET {

  using JLANG::JSocketChannelException;
  using JIO::JByteArrayReader;
  using JIO::JByteArrayWriter;


  /**
   * Get size of data, including the header.
   * This method should be implemented for each template class for read operations.
   *
   * \param  prefix          prefix
   * \return                 number of bytes
   */
  template<class JPrefix_t>
  int getSizeOfPacket(const JPrefix_t& prefix);


  /**
   * Set size of data, including the header.
   * This method should be implemented for each template class for write operations.
   *
   * \param  prefix          prefix
   * \param  size            number of bytes
   */
  template<class JPrefix_t>
  void setSizeOfPacket(const int size, JPrefix_t& prefix);


  /**
   * Auxiliary class for socket channel.
   */
  class JSocketChannel {
  public:
    
    enum JType { IO_PREFIX = 1, IO_DATA = 2 };


    /**
     * Reset channel.
     */
    void reset()
    {
      type = IO_PREFIX;
    }


  protected:
    JType  type;
  };


  /**
   * Socket input channel.
   *
   * This class can be used to read a data packet from a socket without blocking and
   * to buffer these data for subsequent user read operations.
   *
   * The template argument corresponds to a header that precedes any data.
   * This header acts as a protocol specifier that is used to determine the size of the data packet.
   * To this end, the method getSizeOfPacket() should be implemented for each header type.
   *
   * The reading from the socket may be non-blocking (depending on the configuration of the socket).
   * The status of this object should be checked for completion of the data packet.
   * The method reset() should be called before reading the next data packet.
   */
  template<class JPrefix_t>
  class JSocketInputChannel :
    public JSocketNonblockingReader,
    public JSocketChannel,
    public JByteArrayReader
  {
  public:


    using JByteArrayReader::read;


    /**
     * Constructor.
     *
     * \param  socket          socket
     */
    JSocketInputChannel(JSocket& socket) :
      JSocketNonblockingReader(socket),
      JSocketChannel(),
      JByteArrayReader()
    {
      reset();
    }


    /**
     * Interruptable read method.
     *
     * \return                 status
     */
    JStatus_t read()
    {
      if (type == IO_PREFIX) {

        if (isReset()) {
          set((char*) &prefix, sizeof(JPrefix_t));
        }

        if (isBusy()) {
          JSocketNonblockingReader::read();
        }

        if (isReady()) {

          buffer.clear();

          buffer.resize(getSizeOfPacket(prefix));

          memcpy(buffer.data(), &prefix, sizeof(JPrefix_t));

          set(buffer.data() + sizeof(JPrefix_t), 
              buffer.size() - sizeof(JPrefix_t));

          type = IO_DATA;
        }
      }

      if (type == IO_DATA) {

        if (isBusy()) {
          JSocketNonblockingReader::read();
        }

        if (isReady()) {
          static_cast<JByteArrayReader&>(*this) = JByteArrayReader(buffer.data(), buffer.size());
        }
      }

      return JSocketStatus::getStatus();
    }


    /**
     * Reset channel.
     * After a reset, the socket channel is ready to receive a new data packet.
     */
    void reset()
    {
      JSocketNonblockingReader::reset();
      JSocketChannel          ::reset();

      buffer.clear();
    }


    JPrefix_t prefix;

  private:
    std::vector<char> buffer;
  };


  /**
   * Socket output channel.
   *
   * This class can be used to user write to an internal buffer, to format these data as
   * a packet and to write this packet to the socket without blocking.
   *
   * The template argument corresponds to a header that precedes any data.
   * This header acts as a protocol specifier that is used to determine the size of the data packet.
   * To this end, the method setSizeOfPacket() should be implemented for each header type.
   *
   * The wroting to the socket may be non-blocking (depending on the configuration of the socket).
   * The status of this object should be checked for completion of the data packet.
   * The method reset() should be called before writing the next data packet.
   */
  template<class JPrefix_t>
  class JSocketOutputChannel :
    public JSocketNonblockingWriter,
    public JSocketChannel,
    public JByteArrayWriter
  {
  public:

    using JByteArrayWriter::write;


    /**
     * Constructor.
     *
     * \param  socket          socket
     */
    JSocketOutputChannel(JSocket& socket) :
      JSocketNonblockingWriter(socket),
      JSocketChannel(),
      JByteArrayWriter()
    {
      reset();
    }


    /**
     * Interruptable write method.
     *
     * \return                 status
     */
    JStatus_t write()
    {
      if (type == IO_PREFIX) {

        const int length = tellp();

        setSizeOfPacket(length, prefix);

        // overwrite prefix

        seekp(0);

        JByteArrayWriter::write((char*) &prefix, sizeof(JPrefix_t));

        seekp(length);

        type = IO_DATA;

        set(data(), tellp());
      }

      if (isBusy()) {
        JSocketNonblockingWriter::write();
      }

      return JSocketStatus::getStatus();
    }


    /**
     * Reset channel.
     * After a reset, the socket channel is ready to receive a new data packet.
     */
    void reset()
    {
      JSocketNonblockingWriter::reset();
      JSocketChannel          ::reset();

      // reserve space for prefix

      resize(sizeof(JPrefix_t));
      seekp (sizeof(JPrefix_t));
    }


    JPrefix_t prefix;
  };
}

#endif