TinyPacket.h

Go to the documentation of this file.

/*
    Copyright 2016-2024 (C) Alexey Dynda

    This file is part of Tiny Protocol Library.

    GNU General Public License Usage

    Protocol Library is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Protocol Library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with Protocol Library.  If not, see <http://www.gnu.org/licenses/>.

    Commercial License Usage

    Licensees holding valid commercial Tiny Protocol licenses may use this file in
    accordance with the commercial license agreement provided in accordance with
    the terms contained in a written agreement between you and Alexey Dynda.
    For further information contact via email on github account.
*/

#ifndef _TINY_PACKET_H_
#define _TINY_PACKET_H_

#ifdef ARDUINO
#include <HardwareSerial.h>
#else
#include <stdint.h>
#include <string.h>
#endif

#include <stdio.h>

namespace tinyproto
{

class IPacket
{
public:
    IPacket(char *buf, int size)
    {
        m_size = size;
        m_buf = reinterpret_cast<uint8_t *>(buf);
    }

    IPacket(const IPacket &packet)
    {
        m_len = packet.m_len;
        m_size = packet.m_size;
        m_buf = packet.m_buf;
    }

    IPacket()
    {
    }

    virtual ~IPacket() = default;

    void clear()
    {
        m_len = 0;
        m_p = 0;
    }

    void put(uint8_t byte)
    {
        m_buf[m_len++] = byte;
    }

    void put(char chr)
    {
        put(static_cast<uint8_t>(chr));
    }

    inline void put(uint16_t data)
    {
        m_buf[m_len++] = data & 0x00FF;
        m_buf[m_len++] = data >> 8;
    }

    inline void put(uint32_t data)
    {
        put((uint16_t)(data & 0x0000FFFF));
        put((uint16_t)(data >> 16));
    }

    inline void put(int16_t data)
    {
        put((uint16_t)data);
    }

    inline void put(const char *str)
    {
        int room = m_size - m_len - 1;
        if ( !room ) return;
        int strSize = static_cast<int>(strlen(str));
        strncpy((char *)&m_buf[m_len], str, room);
        m_len += strSize < room ? strSize : room;
        m_buf[m_len++] = 0;
    }

    inline void put(const IPacket &pkt)
    {
        memcpy(&m_buf[m_len], pkt.m_buf, pkt.m_len);
        m_len += pkt.m_len;
    }

    inline uint8_t getByte()
    {
        return m_buf[m_p++];
    }

    inline char getChar()
    {
        return (char)IPacket::getByte();
    }

    inline uint16_t getUint16()
    {
        uint16_t t = m_buf[m_p++];
        return t | ((uint16_t)m_buf[m_p++] << 8);
    }

    inline int16_t getInt16()
    {
        return (int16_t)(getUint16());
    }

    inline uint32_t getUint32()
    {
        return getUint16() | ((uint32_t)getUint16()) << 16;
    }

    inline char *getString()
    {
        char *p = (char *)&m_buf[m_p];
        m_p += static_cast<int>(strlen(p)) + 1;
        return p;
    }

    inline int size() const
    {
        return m_len;
    }

    inline int maxSize() const
    {
        return m_size;
    }

    inline char *data() const
    {
        return (char *)m_buf;
    }

    inline size_t availableBytes()
    {
        return (size_t)(m_len - m_p);
    }

    uint8_t &operator[](int idx)
    {
        return m_buf[idx];
    }

    IPacket &operator=(const IPacket &source)
    {
        m_size = source.m_size;
        m_buf = source.m_buf;
        return *this;
    }

    void allocate(int bytes)
    {
        m_len += bytes;
    }

private:
    friend class Hdlc;
    friend class IFd;
    friend class Light;
    friend class Proto;

    uint8_t *m_buf = nullptr;
    IPacket *m_next = nullptr; // For organizing ring buffers
    IPacket *m_prev = nullptr; // For organizing ring buffers
    int m_size = 0; // maximum space available for payload data
    int m_len = 0;  // length of payload data
    int m_p = 0;    // current pointer
};

template <int S> class StaticPacket: public IPacket
{
public:
    StaticPacket()
        : IPacket(m_data, S)
    {
    }

private:
    char m_data[S]{};
};

class HeapPacket: public IPacket
{
public:
    explicit HeapPacket(int size)
        : IPacket((char *)(new uint8_t[size]), size)
    {
    }

    explicit HeapPacket( const IPacket &src )
        : IPacket((char *)(new uint8_t[src.size()]), src.size())
    {
        memcpy(data(), src.data(), src.size());
    }

    ~HeapPacket()
    {
        delete[](uint8_t *) data();
    }

private:
};

} // namespace tinyproto

#endif