3espacketstream.h

//
// author: Kazys Stepanas
//
#ifndef _3ESHEADERSTREAM_H_
#define _3ESHEADERSTREAM_H_

#include "3es-core.h"

#include "3esendian.h"
#include "3espacketheader.h"

namespace tes
{
  template <class HEADER>
  class PacketStream
  {
  public:
    typedef uint16_t CrcType;

    enum SeekPos
    {
      Begin,    
      Current,  
      End       
    };

    enum Status
    {
      Ok = 0,
      EOP = (1 << 0),
      Fail = (1 << 1),
      ReadOnly = (1 << 2),
      CrcValid = (1 << 3),
    };

    PacketStream(HEADER &packet);

    // PacketHeader member access. Ensures network endian swap as required.
    uint32_t marker() const { return networkEndianSwapValue(_packet.marker); }
    uint16_t versionMajor() const { return networkEndianSwapValue(_packet.versionMajor); }
    uint16_t versionMinor() const { return networkEndianSwapValue(_packet.versionMinor); }
    uint16_t payloadSize() const { return networkEndianSwapValue(_packet.payloadSize); }
    uint16_t packetSize() const { return sizeof(HEADER) + payloadSize() + (((packet().flags & PF_NoCrc) == 0) ? sizeof(CrcType) : 0); }
    uint16_t routingId() const { return networkEndianSwapValue(_packet.routingId); }
    uint16_t messageId() const { return networkEndianSwapValue(_packet.messageId); }
    CrcType crc() const { return networkEndianSwapValue(*crcPtr()); }
    CrcType *crcPtr();
    const CrcType *crcPtr() const;

    inline uint16_t status() const;

    inline bool isEop() const { return _status & EOP; }
    inline bool isOk() const { return !isFail(); }
    inline bool isFail() const { return (_status & Fail) != 0; }
    inline bool isReadOnly() const { return (_status & ReadOnly) != 0; }
    inline bool isCrcValid() const { return (_status & CrcValid) != 0; }

    HEADER &packet() const;

    uint16_t tell() const;
    bool seek(int offset, SeekPos pos = Begin);
    const uint8_t *payload() const;

  protected:
    HEADER &_packet;    
    uint16_t _status;   
    uint16_t _payloadPosition;  

    template <class T>
    struct IsConst
    {
      inline bool check() const { return false; }
    };

    template <class T>
    struct IsConst<const T>
    {
      inline bool check() const { return true; }
    };
  };

  template class _3es_coreAPI PacketStream<PacketHeader>;
  template class _3es_coreAPI PacketStream<const PacketHeader>;

  template <class HEADER>
  PacketStream<HEADER>::PacketStream(HEADER &packet)
    : _packet(packet)
    , _status(Ok)
    , _payloadPosition(0u)
  {
    if (IsConst<HEADER>().check())
    {
      _status |= ReadOnly;
    }
  }


  template <class HEADER>
  bool PacketStream<HEADER>::seek(int offset, SeekPos pos)
  {
    switch (pos)
    {
    case Begin:
      if (offset <= _packet.payloadSize)
      {
        _payloadPosition = offset;
        return true;
      }
      break;

    case Current:
      if (offset >= 0 && offset + _payloadPosition <= _packet.payloadSize ||
        offset < 0 && _payloadPosition >= -offset)
      {
        _payloadPosition += offset;
        return true;
      }
      break;

    case End:
      if (offset < _packet.payloadSize)
      {
        _payloadPosition = _packet.payloadSize - 1 - offset;
        return true;
      }
      break;

    default:
      break;
    }

    return false;
  }


  template <class HEADER>
  typename PacketStream<HEADER>::CrcType *PacketStream<HEADER>::crcPtr()
  {
    // CRC appears after the payload.
    // TODO: fix the const correctness of this.
    uint8_t *pos = const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(&_packet)) + sizeof(HEADER) + payloadSize();
    return reinterpret_cast<CrcType*>(pos);
  }


  template <class HEADER>
  const typename PacketStream<HEADER>::CrcType *PacketStream<HEADER>::crcPtr() const
  {
    // CRC appears after the payload.
    const uint8_t *pos = reinterpret_cast<const uint8_t*>(&_packet) + sizeof(HEADER) + payloadSize();
    return reinterpret_cast<const CrcType*>(pos);
  }


  template <class HEADER>
  inline uint16_t PacketStream<HEADER>::status() const
  {
    return _status;
  }

  template <class HEADER>
  inline HEADER &PacketStream<HEADER>::packet() const
  {
    return _packet;
  }

  template <class HEADER>
  inline uint16_t PacketStream<HEADER>::tell() const
  {
    return _payloadPosition;
  }

  template <class HEADER>
  inline const uint8_t *PacketStream<HEADER>::payload() const
  {
    return reinterpret_cast<const uint8_t*>(&_packet) + sizeof(HEADER);
  }
}

#endif // _3ESHEADERSTREAM_H_