PacketService.h

#ifndef _LORAMESHER_PACKET_SERVICE_H
#define _LORAMESHER_PACKET_SERVICE_H
 
#include "entities/packets/Packet.h"
#include "entities/packets/ControlPacket.h"
#include "entities/packets/DataPacket.h"
#include "entities/packets/AppPacket.h"
#include "entities/packets/RoutePacket.h"
 
class PacketService {
public:
 
    static DataPacket* dataPacket(Packet<uint8_t>* p);
 
    static ControlPacket* createControlPacket(uint16_t dst, uint16_t src, uint8_t type, uint8_t* payload, uint8_t payloadSize);
 
    static ControlPacket* createEmptyControlPacket(uint16_t dst, uint16_t src, uint8_t type, uint8_t seq_id, uint16_t num_packets);
 
    static DataPacket* createDataPacket(uint16_t dst, uint16_t src, uint8_t type, uint8_t* payload, uint8_t payloadSize);
 
    static Packet<uint8_t>* createEmptyPacket(size_t packetSize);
 
    template<class T>
    static Packet<uint8_t>* copyPacket(T* p, size_t packetLength) {
        Packet<uint8_t>* cpPacket = static_cast<Packet<uint8_t>*>(malloc(packetLength));
 
        if (cpPacket) {
            memcpy(cpPacket, p, packetLength);
        } else {
            Log.errorln(F("Copy Packet not allocated"));
            return nullptr;
        }
 
        return cpPacket;
    }
 
    static RoutePacket* createRoutingPacket(uint16_t localAddress, NetworkNode* nodes, size_t numOfNodes);
 
    static AppPacket<uint8_t>* createAppPacket(uint16_t dst, uint16_t src, uint8_t* payload, uint32_t payloadSize);
 
    static AppPacket<uint8_t>* convertPacket(DataPacket* p);
 
    static size_t getPacketPayloadLength(DataPacket* p) { return p->payloadSize + sizeof(DataPacket) - sizeof(PacketHeader); }
 
    static size_t getPacketPayloadLength(ControlPacket* p) { return p->payloadSize - (sizeof(ControlPacket) - sizeof(PacketHeader)); }
 
    static uint8_t getMaximumPayloadLengthControlPacket(uint8_t type);
 
    static bool isDataPacket(uint8_t type);
 
    static bool isControlPacket(uint8_t type);
 
#ifndef LM_GOD_MODE
private:
#endif
 
    template<class T>
    static T* createPacket(uint8_t* payload, uint8_t payloadSize) {
        //Packet length = size of the packet + size of the payload
        int packetLength = sizeof(T) + payloadSize;
 
        if (packetLength > MAXPACKETSIZE) {
            Log.warningln(F("Trying to create a packet greater than MAXPACKETSIZE"));
            return nullptr;
        }
 
        T* p = static_cast<T*>(malloc(packetLength));
 
        if (p) {
            //Copy the payload into the packet
            memcpy(reinterpret_cast<void*>((unsigned long) p + (sizeof(T))), payload, payloadSize);
        } else {
            Log.errorln(F("packet not allocated"));
            return nullptr;
        }
 
        Log.traceln(F("Packet created with %d bytes"), packetLength);
 
        return p;
    };
};
 
#endif