IR-protocol/PacketTypes.h

#pragma once
#include "IR_config.h"

class IOffsets {
protected:
    uint8_t msgOffset;
    uint8_t addressFromOffset;
    uint8_t addressToOffset;
    uint8_t DataOffset;
};

class IPackInfo {
public:
    IR_FOX::PackInfo* packInfo;
};

class IBaseEmptyPack : virtual public IOffsets, virtual public IPackInfo {
};

class IR_Decoder;
class IEmptyPack : virtual protected IBaseEmptyPack {
    friend IR_Decoder;
    bool isAvailable;

protected:
    virtual void set(IR_FOX::PackInfo *packInfo) {
        IBaseEmptyPack::IPackInfo::packInfo = packInfo;
        Serial.print(" SET ");

        Serial.print("\n*******ErrAll: ");  Serial.println(packInfo->err.all());
        Serial.print("**ErrDistance: ");  Serial.println((int)(packInfo->err.highSignal - packInfo->err.lowSignal));

        isAvailable = true;
    }

public:
    virtual bool available() {
        if (isAvailable) {
            isAvailable = false;
            return true;
        } else {
            return false;
        }
    };
    virtual uint8_t getMsgInfo() { return packInfo->buffer[0] & IR_MASK_MSG_INFO; };
    virtual uint8_t getMsgType() { return (packInfo->buffer[0] >> 5) & IR_MASK_MSG_TYPE; };
    virtual uint8_t getMsgRAW() { return packInfo->buffer[0]; };
    virtual uint16_t getErrorCount() { return packInfo->err.all(); };
    virtual uint8_t getErrorLowSignal() { return packInfo->err.lowSignal; };
    virtual uint8_t getErrorHighSignal() { return packInfo->err.highSignal; };
    virtual uint8_t getErrorOther() { return packInfo->err.other; };
    virtual uint16_t getTunerTime() { return packInfo->rTime; };
};

class IHasAddresFrom : virtual protected IBaseEmptyPack {
public:
    virtual uint16_t getAddrFrom() { return (packInfo->buffer[addressFromOffset]<<8) | packInfo->buffer[addressFromOffset + 1]; };
};

class IHasAddresTo : virtual protected IBaseEmptyPack {
public:
    virtual uint16_t getAddrTo() { return (packInfo->buffer[addressToOffset]<<8) | packInfo->buffer[addressToOffset + 1]; };
};

class IHasAddresData : virtual protected IBaseEmptyPack {
public:
    virtual uint8_t getDataSize() { return &(packInfo->buffer[packInfo->packSize - 2]) - &(packInfo->buffer[DataOffset]); }; // TODO:
    virtual uint8_t* getDataPrt() { return packInfo->buffer + DataOffset; };
    virtual uint8_t getDataRawSize() { return packInfo->packSize; };
    virtual uint8_t* getDataRawPtr() { return packInfo->buffer; };
};


class Data :
    virtual public IEmptyPack,
    virtual public IHasAddresFrom,
    virtual public IHasAddresTo,
    virtual public IHasAddresData {
public:
    Data() {
        msgOffset = 0;
        addressFromOffset = 1;
        addressToOffset = 3;
        DataOffset = 5;
    }
};