3espacketwriter.h

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

#include "3es-core.h"

#include "3espacketstream.h"

namespace tes
{
  class _3es_coreAPI PacketWriter : public PacketStream<PacketHeader>
  {
  public:
    PacketWriter(PacketHeader &packet, uint16_t maxPayloadSize, uint16_t routingId = 0, uint16_t messageId = 0);

    PacketWriter(uint8_t *buffer, uint16_t bufferSize, uint16_t routingId = 0, uint16_t messageId = 0);

    PacketWriter(const PacketWriter &other);

    ~PacketWriter();

    PacketWriter &operator = (const PacketWriter &other);

    void reset(uint16_t routingId, uint16_t messageId);

    inline void reset() { reset(0, 0); }

    void setRoutingId(uint16_t routingId);
    PacketHeader &packet() const;

    const uint8_t *data() const;

    uint8_t *payload();

    inline void invalidateCrc() { _status &= ~CrcValid; }

    uint16_t bytesRemaining() const;

    uint16_t maxPayloadSize() const;

    bool finalise();

    CrcType calculateCrc();

    size_t writeElement(const uint8_t *bytes, size_t elementSize);

    size_t writeArray(const uint8_t *bytes, size_t elementSize, size_t elementCount);

    size_t writeRaw(const uint8_t *bytes, size_t byteCount);

    template <typename T>
    size_t writeElement(const T &element);

    template <typename T>
    size_t writeArray(const T *elements, size_t elementCount);

    template <typename T>
    PacketWriter &operator >> (T &val);

  protected:
    uint8_t *payloadWritePtr();
    void incrementPayloadSize(size_t inc);

    uint16_t _bufferSize;
  };

  inline void PacketWriter::setRoutingId(uint16_t routingId)
  {
    _packet.routingId = routingId;
  }

  inline PacketHeader &PacketWriter::packet() const
  {
    return _packet;
  }

  inline const uint8_t *PacketWriter::data() const
  {
    return reinterpret_cast<uint8_t*>(&_packet);
  }

  inline uint8_t *PacketWriter::payload()
  {
    return reinterpret_cast<uint8_t*>(&_packet) + sizeof(PacketHeader);
  }

  template <typename T>
  inline size_t PacketWriter::writeElement(const T &element)
  {
    return writeElement(reinterpret_cast<const uint8_t *>(&element), sizeof(T));
  }

  template <typename T>
  inline size_t PacketWriter::writeArray(const T *elements, size_t elementCount)
  {
    return writeArray(reinterpret_cast<const uint8_t *>(elements), sizeof(T), elementCount);
  }


  template <typename T>
  inline PacketWriter &PacketWriter::operator >> (T &val)
  {
    int written = writeElement(val);
    _status |= !(written == sizeof(T)) * Fail;
    return *this;
  }


  inline uint8_t *PacketWriter::payloadWritePtr()
  {
    return payload() + _payloadPosition;
  }
}

#endif // _3ESPACKETWRITER_H_