meshTables.h

Go to the documentation of this file.

 
#ifndef INC_MESHTABLES_H_
#define INC_MESHTABLES_H_
 
#include <meshPacket.h>
 
struct MeshMACTableRow {
    MeshMACTableRow() = default;
 
    MeshMACTableRow(MeshMAC mac);
 
    MeshMAC MAC;
 
    inline void clear() {
        MAC = 0;
    }
 
    static size_t printHeader(OSTREAM& stream);
 
    size_t printRow(OSTREAM& stream) const;
 
    bool operator==(const MeshMACTableRow& another) const {
        return another.MAC == MAC;
    }
 
#ifdef SIMULATION
    std::string printRowForChangeLog() const {
        return std::to_string((int)MAC);
    }
#endif //SIMULATION
};
 
struct MeshRouteTableRow {
    MeshRouteTableRow() = default;
 
    MeshRouteTableRow(uint8_t source, uint8_t neighbor, uint8_t hop);
 
    uint8_t Source = 0;
    uint8_t Neighbor = 0;
    uint8_t Hop = 0;
 
    inline bool isDirectNeighbor() const{
        return Neighbor == Source;
    }
 
    inline bool isGateway() const {
        return Source <= MESH_GATEWAY_MAX_ADDRESS;
    }
 
    inline void clear(){
        Source = 0;
        Neighbor = 0;
        Hop = 0;
    }
 
    static size_t printHeader(OSTREAM &stream);
 
    size_t printRow(OSTREAM &stream) const;
 
    bool operator==(const MeshRouteTableRow& another) const {
        return another.Source == Source && another.Neighbor == Neighbor && another.Hop == Hop;
    }
 
#ifdef SIMULATION
    std::string printRowForChangeLog() const {
        return std::to_string((int)Source) + "|" + std::to_string((int)Neighbor) + "|" + std::to_string((int)Hop);
    }
#endif //SIMULATION
};
 
struct MeshIDTableRow {
    MeshIDTableRow() = default;
 
    MeshIDTableRow(uint8_t id, uint8_t source);
 
    uint8_t ID = 0;
    uint8_t Source = 0;
 
    inline void clear(){
        Source = 0;
        ID = 0;
    }
 
    static size_t printHeader(OSTREAM &stream);
 
    size_t printRow(OSTREAM &stream) const;
 
    bool operator==(const MeshIDTableRow& another) const {
        return another.ID == ID && another.Source == Source;
    }
 
#ifdef SIMULATION
    std::string printRowForChangeLog() const {
        return std::to_string((int)ID) + "|" + std::to_string((int)Source);
    }
#endif //SIMULATION
};
 
struct MeshFIDTableRow {
    MeshFIDTableRow() = default;
 
    MeshFIDTableRow(uint8_t id, uint8_t source, MeshMAC bssid);
 
    uint8_t ID = 0;
    uint8_t Source = 0;
    MeshMAC BSSID;
 
    inline void clear() {
        Source = 0;
        ID = 0;
        BSSID = 0;
    }
 
    static size_t printHeader(OSTREAM& stream);
 
    size_t printRow(OSTREAM& stream) const;
 
    bool operator==(const MeshFIDTableRow& another) const {
        return another.ID == ID && another.Source == Source && another.BSSID == BSSID;
    }
 
#ifdef SIMULATION
    std::string printRowForChangeLog() const {
        return std::to_string((int)ID) + "|" + std::to_string((int)Source) + "|" + std::to_string(BSSID);
    }
#endif //SIMULATION
};
 
struct MeshOIDTableRow {
    MeshOIDTableRow() = default;
 
    MeshOIDTableRow(uint8_t id, uint8_t destination, SystemPacketType type);
 
    uint8_t ID = 0;
    uint8_t Destination = 0;
    
    SystemPacketType Type = SystemPacketType::SPT_DATA;
 
    inline void clear() {
        Type = SystemPacketType::SPT_DATA;
        Destination = 0;
        ID = 0;
    }
 
    static size_t printHeader(OSTREAM& stream);
 
    size_t printRow(OSTREAM& stream) const;
 
    bool operator==(const MeshOIDTableRow& another) const {
        return another.ID == ID && another.Destination == Destination && another.Type == another.Type;
    }
 
#ifdef SIMULATION
    std::string printRowForChangeLog() const {
        return std::to_string((int)ID) + "|" + std::to_string((int)Destination) + "|" + std::to_string((int)Type);
    }
#endif //SIMULATION
 
};
 
HAS_MEM_FUNC(printRowForChangeLog, has_printRowForChangeLog);
HAS_MEM_FUNC(printHeader, has_printHeader);
HAS_MEM_FUNC(printRow, has_printRow);
HAS_MEM_FUNC(clear, has_clear);
HAS_MEM_FUNC(operator==, has_equalityOperator);
 
 
template<typename RowT, int16_t RowsCount, bool IndexIsValue = false>
class MicroTable : public Printable
#ifdef SIMULATION
    , public MSHelper
#endif //SIMULATION
{
public:
 
#ifdef SIMULATION
    static_assert(has_printRowForChangeLog<RowT, std::string(RowT::*)()const>::value || !std::is_class<RowT>::value, "RowT class does not have \"std::string printRowForChangeLog() const\" member function, which is needed when logging table change during simulation.");
#endif //SIMULATION
 
    static_assert(RowsCount != 0, "RowsCount has to be greather than 0.");
    static_assert(has_printRow<RowT, size_t(RowT::*)(OSTREAM&) const>::value || !std::is_class<RowT>::value || IndexIsValue, "RowT class has to contain \"size_t printRow(OSTREAM& stream) const\" member function.");
    static_assert(has_printRow<RowT, size_t(RowT::*)(OSTREAM&, int16_t) const>::value || !std::is_class<RowT>::value || !IndexIsValue, "RowT class has to contain \"size_t printRow(OSTREAM& stream, int16_t index) const\" member function.");
#ifdef SIMULATION
    //TODO make this work also when simulation is not defined
    static_assert(is_streamable<RowT>::value || std::is_class<RowT>::value, "Row type is not class and is not printable, it cannot be used.");
#endif //SIMULATION
    static_assert(has_equalityOperator<RowT, bool(RowT::*)(const RowT&)const>::value, "RowT has to contain basic const binary equality operator ==.");
 
    MicroTable(const uint32_t rowLife) :
        ValidationInterval(rowLife / 255),
        RowLife(rowLife) //rowLife have to be divided to get validation interval
    {
        clear(); //clear buffer
    }
 
    inline const RowT& get(int16_t index) const {
        return buffer[index];
    }
 
    inline RowT get(int16_t index) {
        return buffer[index];
    }
 
    const RowT& operator[](int16_t index) const {
        return get(index);
    }
 
    RowT operator[](int16_t index) {
        return get(index);
    }
 
    bool set(int16_t index, const RowT& row) {
        if (index < RowsCount && index >= 0) {
            if (lifeTime[index] == 0) {
                usedBufferSize++; //Item added
                if (realUsedSize <= index) {
                    realUsedSize = index + 1;
                }
                lifeTime[index] = 255;
                onCreate(index, row, 255);
            }
            else {
                uint8_t oldLifeTime = lifeTime[index];
                lifeTime[index] = 255;
                onSet(index, buffer[index], oldLifeTime, row, 255);
                if (oldLifeTime != lifeTime[index]) {
                    onRowLifeChanged(index, oldLifeTime, lifeTime[index]);
                }
            }
            buffer[index] = row;
            
#ifdef SIMULATION
            if constexpr (has_printRowForChangeLog<RowT, std::string(RowT::*)()const>::value) {
                NotifyTableChangeBegin(MST_SET) << (int)index << "|" << buffer[index].printRowForChangeLog() << "|" << (int)lifeTime[index];
            }
            else {
                NotifyTableChangeBegin(MST_SET) << (int)index << "|" << buffer[index] << "|" << (int)lifeTime[index];
            }
            NotifyTableChangeEnd();
#endif //SIMULATION
            return true;
        }
        return false;
    }
 
    bool set(int16_t index, const RowT& row, int16_t rawLifeTime_) {
        if (index < RowsCount && index >= 0 && rawLifeTime_ <= 255) {
            if (rawLifeTime_ < 0) rawLifeTime_ = lifeTime[index];
            bool lastValid = lifeTime[index] != 0;
 
            if (lastValid != (rawLifeTime_ != 0)) {
                if (lastValid) {
                    usedBufferSize--;   //Item removed
                    if (usedBufferSize == 0) {
                        realUsedSize = 0;
                    }
                    else if (realUsedSize - 1 == index) {
                        for (; realUsedSize > 0 && isRowBlank(realUsedSize - 1); realUsedSize--);
                    }
 
                    uint8_t oldLifeTime = lifeTime[index];
                    lifeTime[index] = 0;
                    onRemove(index, buffer[index], oldLifeTime);
                    onRowLifeChanged(index, oldLifeTime, 0);
                }
                else {
                    usedBufferSize++; //Item added
                    if (realUsedSize <= index) {
                        realUsedSize = index + 1;
                    }
                    lifeTime[index] = rawLifeTime_;
                    onCreate(index, row, rawLifeTime_);
                }
            }
            else {
                //Item set
                uint8_t oldLifeTime = lifeTime[index];
                lifeTime[index] = rawLifeTime_;
                onSet(index, buffer[index], oldLifeTime, row, rawLifeTime_);
                if (oldLifeTime != lifeTime[index]) {
                    onRowLifeChanged(index, oldLifeTime, rawLifeTime_);
                }
            }
 
            if (rawLifeTime_ == 0) {
                //Clear
                if constexpr (has_clear<RowT, void(RowT::*)()>::value) {
                    //Call clear method if exists
                    buffer[index].clear();
                }
            }
            else {
                buffer[index] = row;
            }
#ifdef SIMULATION
            if constexpr (has_printRowForChangeLog<RowT, std::string(RowT::*)()const>::value) {
                NotifyTableChangeBegin(MST_SET) << (int)index << "|" << buffer[index].printRowForChangeLog() << "|" << (int)lifeTime[index];
            }
            else {
                NotifyTableChangeBegin(MST_SET) << (int)index << "|" << buffer[index] << "|" << (int)lifeTime[index];
            }
            NotifyTableChangeEnd();
#endif //SIMULATION
            return true;
        }
        return false;
    }
 
    bool remove(const RowT& rowRef) {
        int16_t index = getIndexOf(rowRef);
        if (index >= 0) {
            return remove(index);
        }
        return false;
    }
 
    bool remove(int16_t index) {
        if (index < realUsedSize && index >= 0) {
            if (!isRowBlank(index)) {
                usedBufferSize--;   //Item removed
                if (usedBufferSize == 0) {
                    realUsedSize = 0;
                }
                else if (realUsedSize - 1 == index) {
                    for (; realUsedSize > 0 && isRowBlank(realUsedSize - 1); realUsedSize--);
                }
 
                uint8_t oldLifeTime = lifeTime[index];
                lifeTime[index] = 0;
                onRemove(index, buffer[index], oldLifeTime);
                onRowLifeChanged(index, oldLifeTime, 0);
            }
#ifdef SIMULATION
            if constexpr (has_printRowForChangeLog<RowT, std::string(RowT::*)()const>::value) {
                NotifyTableChangeBegin(MST_REMOVE) << (int)index << "|" << buffer[index].printRowForChangeLog() << "|" << (int)lifeTime[index];
            }
            else {
                NotifyTableChangeBegin(MST_REMOVE) << (int)index << "|" << buffer[index] << "|" << (int)lifeTime[index];
            }
            NotifyTableChangeEnd();
#endif //SIMULATION
 
            //Clear
            lifeTime[index] = 0;
            if constexpr (has_clear<RowT, void(RowT::*)()>::value) {
                //Call clear method if exists
                buffer[index].clear();
            }
            return true;
        }
        return false;
    }
 
    void clear() {
#ifdef SIMULATION
        if (count() != 0) {
            NotifyTableChangeBegin(MST_CLEAR);
            NotifyTableChangeEnd();
        }
#endif //SIMULATION
        for (int16_t i = 0; i < RowsCount; i++) {
            //Clear
            lifeTime[i] = 0;
            if constexpr (has_clear<RowT, void(RowT::*)()>::value) {
                //Call clear method if exists
                buffer[i].clear();
            }
        }
        realUsedSize = 0;
        usedBufferSize = 0;
        onClear();
    }
 
    void validate() {
        uint32_t sysTime = millis();
        if (usedBufferSize == 0) {
            lastValidationTime = sysTime;
            return;
        }
        uint32_t interval = (ValidationInterval == 0) ? 1 : ValidationInterval;
        uint32_t mil = sysTime;
        uint8_t step = (mil - lastValidationTime) / interval;
        if (step > 0) {
            for (int16_t i = 0; i < realUsedSize; i++) {
                if (lifeTime[i] <= step) { //Life of row ended, so we need to remove it
                    //Row removing
                    if (lifeTime[i] != 0) {
                        usedBufferSize--;   //Item removed
 
                        if (usedBufferSize == 0) {
                            realUsedSize = 0;
                        }
                        else if (realUsedSize - 1 == i) {
                            for (; realUsedSize > 0 && isRowBlank(realUsedSize - 1); realUsedSize--);
                        }
 
                        uint8_t oldLifeTime = lifeTime[i];
                        lifeTime[i] = 0;
                        onRemove(i, buffer[i], oldLifeTime, true);
                        onRowLifeChanged(i, oldLifeTime, 0);
 
                        if constexpr (has_clear<RowT, void(RowT::*)()>::value) {
                            //Call clear method if exists
                            buffer[i].clear();
                        }
#ifdef SIMULATION
                        if constexpr (has_printRowForChangeLog<RowT, std::string(RowT::*)()const>::value) {
                            NotifyTableChangeBegin(MST_REMOVE_VLD) << (int)i << "|" << buffer[i].printRowForChangeLog() << "|" << (int)lifeTime[i];
                        }
                        else {
                            NotifyTableChangeBegin(MST_REMOVE_VLD) << (int)i << "|" << buffer[i] << "|" << (int)lifeTime[i];
                        }
                        NotifyTableChangeEnd();
#endif //SIMULATION
                    }
                }
                else {
                    lifeTime[i] -= step;
                    if (step > 0) {
                        onRowLifeChanged(i, lifeTime[i] + step, lifeTime[i]);
                    }
                }
            }
 
            //lastValidation set and correction (lastValidation has to be increased by multiples of the interval value, when table is not empty)
            lastValidationTime += step * interval;
        }
    }
 
    bool setRawRemainingLifeTime(int16_t index, uint8_t rawLifeTime_ = 255) {
        if (index < realUsedSize && index >= 0 && !isRowBlank(index) && rawLifeTime_ > 0) {
            uint8_t old = lifeTime[index];
            lifeTime[index] = rawLifeTime_;
            if (old != rawLifeTime_) {
                onRowLifeChanged(index, old, rawLifeTime_);
            }
#ifdef SIMULATION
            NotifyTableChangeBegin(MST_PROLONG) << (int)index << "|" << (int)lifeTime[index];
            NotifyTableChangeEnd();
#endif //SIMULATION
            return true;
        }
        return false;
    }
 
    virtual int16_t getIndexOf(const RowT& rowRef) const {
        for (int16_t i = 0; i < realUsedSize; i++) {
            if (rowRef == buffer[i] && lifeTime[i] != 0) {
                return i;
            }
        }
        return -1;
    }
 
    int16_t getFirstBlankRowIndex(int16_t startPos = 0) const {
        if (count() == RowsCount || startPos >= RowsCount) return -1;
        if (startPos >= getRealUsedSize()) return startPos;
        if (!IndexIsValue && count() == getRealUsedSize()) return count();
        int16_t i = startPos;
        for (; i < RowsCount && lifeTime[i] != 0; i++);
        return i;
    }
 
    int16_t getOldestRowIndex() const {
        uint8_t oldestLifeTime = 255;
        int16_t index = -1;
        for (int16_t i = 0; i < realUsedSize; i++) {
            if (lifeTime[i] != 0) {
                if (oldestLifeTime > lifeTime[i]) {
                    index = i;
                    oldestLifeTime = lifeTime[i];
                }
            }
        }
        return index;
    }
 
    inline bool exists(int16_t index) const {
        return !isRowBlank(index);
    }
 
    bool exists(const RowT& rowRef) const {
        return getIndexOf(rowRef) >= 0;
    }
 
    inline bool isRowBlank(int16_t index) const {
        return index < 0 || index >= realUsedSize || lifeTime[index] == 0;
    }
 
    inline int16_t size() const {
        return RowsCount;
    }
 
    inline int16_t count() const {
        return usedBufferSize;
    }
 
    inline uint8_t getMaxRowLifeTime() const {
        return RowLife;
    }
 
    inline int16_t getRealUsedSize() const {
        return realUsedSize;
    }
 
    template <class = typename std::enable_if<!IndexIsValue>::type> uint8_t getFragmentation() const{
        if (getRealUsedSize() > 0) {
            return ((uint32_t)(getRealUsedSize() - count()) * 100UL) / getRealUsedSize();
        }
        else return 0;
    }
 
    template <class = typename std::enable_if<!IndexIsValue>::type> void defragment() {
        if (usedBufferSize == 0) return;
        int16_t writePos = 0;
        //Note: readPos has to be still higher than writePos.
        //Note 2: readPos can start from index 1, because first row cannot be moved.
 
        for (int16_t readPos = 1; readPos < realUsedSize; readPos++) { //Iterate through all rows
            if (lifeTime[readPos] != 0) { //Item was found
                for (; writePos < readPos && lifeTime[writePos] != 0; writePos++); //Trying to find blank row below readPos
                if (lifeTime[writePos] == 0) { //Blank row was found, so move row from readPos to this row (at writePos)
                    buffer[writePos] = buffer[readPos];
                    lifeTime[writePos] = lifeTime[readPos];
 
                    //Clear
                    lifeTime[readPos] = 0;
 
                    if constexpr (has_clear<RowT, void(RowT::*)()>::value) {
                        //Call clear method if exists
                        buffer[readPos].clear();
                    }
                }
            }
        }
        realUsedSize = usedBufferSize;
#ifdef SIMULATION
        NotifyTableChangeBegin(MST_DEFRAG);
        NotifyTableChangeEnd();
#endif // SIMULATION
    }
 
    uint32_t getRowRemainingLifeTime(int16_t index) const {
        if (index < realUsedSize && index >= 0 && !isRowBlank(index)) {
            uint32_t rawVal = lifeTime[index] * ValidationInterval;
            uint32_t timeDifference = (millis() - lastValidationTime);
            if (rawVal <= timeDifference) {
                //remove(index); //Remove invalid row
                return 0;
            }
            else {
                return rawVal - timeDifference;
            }
        }
        return 0;
    }
 
    uint8_t getRawRowRemainingLifeTime(int16_t index) const {
        if (index < realUsedSize && index >= 0) {
            return lifeTime[index];
        }
        return 0;
    }
 
    inline uint32_t getLifeTimeResolution() const {
        return ValidationInterval;
    }
 
    inline uint8_t convertLifeTimeToRaw(uint32_t lifeTime) const {
        uint32_t value = lifeTime / ValidationInterval + (lifeTime % ValidationInterval > 0);
        return ((value > 255) ? 255 : value);
    }
 
    inline uint32_t convertRawToLifeTime(uint8_t rawLifeTime) const {
        return rawLifeTime * ValidationInterval;
    }
 
    virtual size_t getRawDataSize() const{
        return 20 + (size_t)usedBufferSize * (sizeof(RowT) + 3);
    }
 
    virtual size_t printRaw(OSTREAM& stream, const char tableIdentifier[4]) const {
        crc.begin();
        crc.setInputReverse(true);
        crc.setOutputReverse(true);
        crc.setPolynomial32();
        crc.reset(0xFFFFFFFFUL);
 
        size_t ret = 0;
        ret = stream.print(tableIdentifier);
        ret = stream.print(':');
        union WTB {
            uint32_t word;
            uint8_t buffer[4];
        };
 
        int16_t row_cnt = RowsCount;
        ret += stream.write((uint8_t*)&row_cnt, 2);
        crc.append((uint8_t*)&row_cnt, 2);
 
        ret += stream.write((uint8_t*)&RowLife, 4);
        crc.append((uint8_t*)&RowLife, 4);
 
        WTB elapsedTimeFromLastValidation;
        elapsedTimeFromLastValidation.word = millis() - lastValidationTime;
        ret += stream.write(elapsedTimeFromLastValidation.buffer, 4);
        crc.append(elapsedTimeFromLastValidation.buffer, 4);
 
        ret += stream.write((uint8_t*)&usedBufferSize, 2);
        crc.append((uint8_t*)&usedBufferSize, 2);
 
        uint16_t sentCnt = 0;
        for (uint16_t i = 0; i < realUsedSize; i++) { //Printing all used rows
            if (!isRowBlank(i)) {                     //which are not blank
                ret += stream.write((uint8_t*)&i, 2); //Index
                crc.append((uint8_t*)&i, 2);          //Index
 
                ret += stream.write((uint8_t*)&buffer[i], sizeof(RowT)); //Value
                crc.append((uint8_t*)&buffer[i], sizeof(RowT));          //Value
 
                ret += stream.write(lifeTime[i]); //Raw life time
                crc.append(lifeTime[i]);          //Raw life time
 
                sentCnt++;
                if (sentCnt >= usedBufferSize) {
                    break;
                }
            }
        }
 
        uint32_t CRC_val = crc.getLastCRC(0xFFFFFFFFUL);
        ret += stream.write((uint8_t*)&CRC_val, 4); //Append CRC-32 at the end of message
 
        crc.end();
 
        return ret;
    }
 
    size_t print(OSTREAM& stream, bool showIndexes = true, bool doNotPrintBlank = true, bool showRemainingRowLifetime = true) const {
        size_t ret = 0;
        if (showIndexes) ret += stream.print("Index|");
        if constexpr (has_printHeader<RowT, size_t(*)(OSTREAM&)>::value) { //RowT contains printHeader static function
            ret += RowT::printHeader(stream);
        }
        else {
            ret += stream.print("Value");
        }
        if (showRemainingRowLifetime) ret += stream.print("|Remaining life time");
 
        size_t dashCnt = ret;
        ret += stream.println();
        for(size_t i = 0; i < dashCnt; i++) ret += stream.print('-');
        ret += stream.println();
 
        if (usedBufferSize == 0) {
            ret += stream.println("Empty");
        }
        else {
            for (uint8_t i = 0; i < realUsedSize; i++) {
                if (!(doNotPrintBlank && lifeTime[i] == 0)) {
                    if (showIndexes) { //Index
                        char txtBuffer[10] = { 0 };
                        ITOA(i, txtBuffer, sizeof(txtBuffer) / sizeof(char), 10);
                        alignText(txtBuffer, 5, ' ', T_LEFT);
                        ret += stream.print(txtBuffer);
                        ret += stream.print('|');
                    }
                    if constexpr (has_printRow<RowT, size_t(RowT::*)(OSTREAM&) const>::value && !IndexIsValue) { //printRow member function found
                        ret += buffer[i].printRow(stream);
                    }
                    else if constexpr (has_printRow<RowT, size_t(RowT::*)(OSTREAM&, int16_t) const>::value && IndexIsValue) { //printRow member function found
                        ret += buffer[i].printRow(stream, i);
                    }
                    else {
                        ret += stream.print(buffer[i]);
                    }
                    if (showRemainingRowLifetime) { //Life time
                        ret += stream.print('|');
                        uint32_t remLifeTime = getRowRemainingLifeTime(i)/1000UL;
                        char txtBuffer[3] = { 0 };
                        ret += stream.print("    ");
                        uint8_t sec = remLifeTime % 60;
                        remLifeTime /= 60;
                        uint8_t min = remLifeTime % 60;
                        remLifeTime /= 60;
                        uint8_t hrs = remLifeTime % 24;
                        remLifeTime /= 24;
 
                        //Days
                        ITOA(remLifeTime, txtBuffer, sizeof(txtBuffer) / sizeof(char), 10);
                        alignText(txtBuffer, 2, '0', T_RIGHT);
                        ret += stream.print(txtBuffer);
                        ret += stream.print("d ");
 
                        //Hours
                        ITOA(hrs, txtBuffer, sizeof(txtBuffer) / sizeof(char), 10);
                        alignText(txtBuffer, 2, '0', T_RIGHT);
                        ret += stream.print(txtBuffer);
                        ret += stream.print(':');
 
                        //Minutes
                        ITOA(min, txtBuffer, sizeof(txtBuffer) / sizeof(char), 10);
                        alignText(txtBuffer, 2, '0', T_RIGHT);
                        ret += stream.print(txtBuffer);
                        ret += stream.print(':');
 
                        //Seconds
                        ITOA(sec, txtBuffer, sizeof(txtBuffer) / sizeof(char), 10);
                        alignText(txtBuffer, 2, '0', T_RIGHT);
                        ret += stream.print(txtBuffer);
 
                        // xxd hh:mm:ss
                        ret += stream.print("   ");
                    }
                    ret += stream.println();
                }
            }
        }
        return ret;
    }
 
    size_t printTo(Print& p) const override
    {
        return print(p);
    }
 
protected:
 
    virtual void onCreate(int16_t index, const RowT& newValue, uint8_t newRawLifeTime) {}
 
    virtual void onSet(int16_t index, const RowT& oldValue, uint8_t oldRawLifeTime, const RowT& newValue, uint8_t newRawLifeTime) {}
 
    virtual void onRemove(int16_t index, const RowT& oldValue, uint8_t oldRawLifeTime, bool removedByValidation = false) {}
 
    virtual void onClear() {}
 
    virtual void onRowLifeChanged(int16_t index, uint8_t old_raw, uint8_t new_raw) {}
 
 
    RowT buffer[RowsCount];
    uint8_t lifeTime[RowsCount];
 
    uint32_t lastValidationTime = 0;
    int16_t usedBufferSize = 0;
    int16_t realUsedSize = 0;
    const uint32_t ValidationInterval = 0;  //Validation interval in ms
    const uint32_t RowLife = 0;             //Maximum row life time in ms
};
 
 
template <int16_t BufferSize>
class MeshMACTable :
    public MicroTable<MeshMACTableRow, BufferSize>
{
public:
    MeshMACTable(const uint32_t rowLife) :
        MicroTable<MeshMACTableRow, BufferSize>(rowLife)
    {
    }
 
    bool set(uint8_t address, MeshMAC MAC, int16_t valid = -1) {
        return MicroTable<MeshMACTableRow, BufferSize>::set((int16_t)address, MeshMACTableRow(MAC), valid);
    }
 
    int16_t add(MeshMAC mac, bool isGateway = false) {
        int16_t index = getFreeAddress((isGateway) ? 0 : (MESH_GATEWAY_MAX_ADDRESS + 1));
        if (index >= 0) {
            //Free address was found
            return MicroTable<MeshMACTableRow, BufferSize>::set(index, MeshMACTableRow(mac), 255) ? index : -1;
        }
        else {
            return -1;
        }
    }
 
    int16_t getAddressFromMAC(MeshMAC mac, int16_t startPos = 0) const{
        if (startPos < 0) return false;
        for (int16_t i = startPos; i < MicroTable<MeshMACTableRow, BufferSize>::realUsedSize; i++) {
            if (MicroTable<MeshMACTableRow, BufferSize>::buffer[i].MAC == mac && MicroTable<MeshMACTableRow, BufferSize>::lifeTime[i] != 0) {
                return i;
            }
        }
        return -1;
    }
 
    MeshMAC getMACFromAddress(uint8_t address) const{
        if (MicroTable<MeshMACTableRow, BufferSize>::exists((int16_t)address)) {
            return MicroTable<MeshMACTableRow, BufferSize>::get((int16_t)address); //Valid address from table
        }
        else {
            return MeshMAC(); //Invalid mesh MAC address
        }
    }
 
    inline bool addressExists(uint8_t address) const {
        return MicroTable<MeshMACTableRow, BufferSize>::exists((int16_t)address);
    }
 
    inline bool MACExists(MeshMAC mac) const {
        return MicroTable<MeshMACTableRow, BufferSize>::exists(MeshMACTableRow(mac));
    }
 
    int16_t getFreeAddress(uint8_t startFrom = MESH_GATEWAY_MAX_ADDRESS + 1) {
        return MicroTable<MeshMACTableRow, BufferSize>::getFirstBlankRowIndex(startFrom);
    }
 
    inline void setValidityChangeCallback(void(*callback)(MeshMACTable<BufferSize>*, int16_t, const MeshMACTableRow&, bool, bool)) {
        onValidityChangeCallback = callback;
    }
 
protected:
    
    void onRowLifeChanged(int16_t index, uint8_t old_raw, uint8_t new_raw) override {
        bool valid = new_raw > DHCPTABLE_ROW_RAW_LIFETIME_RESERVED;
        bool removed = new_raw == 0;
        bool old_valid = old_raw > DHCPTABLE_ROW_RAW_LIFETIME_RESERVED;
        bool old_removed = old_raw == 0;
        if (onValidityChangeCallback != NULL && (valid != old_valid || removed != old_removed)) {
            onValidityChangeCallback(this, index, MicroTable<MeshMACTableRow, BufferSize>::buffer[index], valid, removed);
        }
        
    }
 
    void(*onValidityChangeCallback)(MeshMACTable<BufferSize>*, int16_t, const MeshMACTableRow&, bool, bool) = NULL;
};
 
 
template <int16_t BufferSize>
class MeshRouteTable :
    public MicroTable<MeshRouteTableRow, BufferSize>
{
public:
 
    MeshRouteTable(const uint32_t rowLife) :
        MicroTable<MeshRouteTableRow, BufferSize>(rowLife)
    {
    }
 
    bool set(int16_t index, uint8_t source, uint8_t neighbor, uint8_t hop, int16_t valid = -1) {
        return MicroTable<MeshRouteTableRow, BufferSize>::set(index, MeshRouteTableRow(source, neighbor, hop), valid);
    }
 
    int16_t set(uint8_t source, uint8_t neighbor, uint8_t hop, int16_t valid = -1) {
        int16_t index = getIndexOfSource(source);
        if (index >= 0) {
            return MicroTable<MeshRouteTableRow, BufferSize>::set(index, MeshRouteTableRow(source, neighbor, hop), valid) ? index : -1;
        }
        else {
            //Searching first blank row
            index = MicroTable<MeshRouteTableRow, BufferSize>::getFirstBlankRowIndex();
            if (index >= 0) {
                return MicroTable<MeshRouteTableRow, BufferSize>::set(index, MeshRouteTableRow(source, neighbor, hop), valid) ? index : -1;
            }
            return -1;
        }
    }
 
    int16_t set(const MeshRouteTableRow& row, int16_t valid = -1) {
        int16_t index = getIndexOfSource(row.Source);
        if (index >= 0) {
            return MicroTable<MeshRouteTableRow, BufferSize>::set(index, row, valid) ? index : -1;
        }
        else {
            //Searching first blank row
            index = MicroTable<MeshRouteTableRow, BufferSize>::getFirstBlankRowIndex();
            if (index >= 0) {
                return MicroTable<MeshRouteTableRow, BufferSize>::set(index, row, valid) ? index : -1;
            }
            return -1;
        }
    }
 
    inline bool add(uint8_t source, uint8_t neighbor, uint8_t hop) {
        return add(MeshRouteTableRow(source, neighbor, hop));
    }
 
    bool add(const MeshRouteTableRow& val) {
        int16_t index = getIndexOfSource(val.Source);
        if (index >= 0) { //Row with same source was found
            //TODO do not check only hops, but also metric
            //Path with better metric found
            if (MicroTable<MeshRouteTableRow, BufferSize>::buffer[index].Hop > val.Hop) { 
                return MicroTable<MeshRouteTableRow, BufferSize>::set(index, val, 255);
            }
            if (MicroTable<MeshRouteTableRow, BufferSize>::buffer[index].Neighbor == val.Neighbor && val.isDirectNeighbor()) { //Neighbor
                MicroTable<MeshRouteTableRow, BufferSize>::buffer[index].Hop = 1;
                MicroTable<MeshRouteTableRow, BufferSize>::setRawRemainingLifeTime(index, 255); //We have received some message from neighbor, we need to prolong it's life time
                return true;
            }
        }
        else {
            //Creating new row
            //Searching first blank row
            index = MicroTable<MeshRouteTableRow, BufferSize>::getFirstBlankRowIndex();
            if (index >= 0) {
                return MicroTable<MeshRouteTableRow, BufferSize>::set(index, val, 255);
            }
            //Buffer is full, so we need to overwrite the oldest row which is not gateway.
            index = getOldestRowIndexNotGW();
            if (index >= 0) {
                return MicroTable<MeshRouteTableRow, BufferSize>::set(index, val, 255);
            }
        }
        return false;
    }
 
    void operator += (const MeshRouteTableRow& val) {
        add(val);
    }
 
    bool removeBySource(uint8_t source) {
        int16_t index = getIndexOfSource(source);
        return MicroTable<MeshRouteTableRow, BufferSize>::remove(index);
    }
 
    int16_t removeByNeighbor(uint8_t neighbor) {
        int16_t removedCnt = 0;
        for (int16_t i = 0; i < MicroTable<MeshRouteTableRow, BufferSize>::realUsedSize; i++) {
            if (MicroTable<MeshRouteTableRow, BufferSize>::buffer[i].Neighbor == neighbor) {
                removedCnt += MicroTable<MeshRouteTableRow, BufferSize>::remove(i);
            }
        }
        return removedCnt;
    }
 
    int16_t removeByAddress(uint8_t address) {
        int16_t removedCnt = 0;
        for (int16_t i = 0; i < MicroTable<MeshRouteTableRow, BufferSize>::realUsedSize; i++) {
            if (MicroTable<MeshRouteTableRow, BufferSize>::buffer[i].Neighbor == address || MicroTable<MeshRouteTableRow, BufferSize>::buffer[i].Source == address) {
                removedCnt += MicroTable<MeshRouteTableRow, BufferSize>::remove(i);
            }
        }
        return removedCnt;
    }
 
    inline bool isRowDirectNeighbor(int16_t index) const{
        return MicroTable<MeshRouteTableRow, BufferSize>::exists(index) && MicroTable<MeshRouteTableRow, BufferSize>::buffer[index].isDirectNeighbor();
    }
 
    bool sourceExists(uint8_t source) const {
        if (MicroTable<MeshRouteTableRow, BufferSize>::usedBufferSize == 0) return false;
        for (int16_t i = 0; i < MicroTable<MeshRouteTableRow, BufferSize>::realUsedSize; i++) {
            if (MicroTable<MeshRouteTableRow, BufferSize>::buffer[i].Source == source && MicroTable<MeshRouteTableRow, BufferSize>::lifeTime[i] != 0) {
                return true;
            }
        }
        return false;
    }
 
    bool neighborExists(uint8_t neighbor) const{
        if(MicroTable<MeshRouteTableRow, BufferSize>::usedBufferSize == 0) return false;
        for (int16_t i = 0; i < MicroTable<MeshRouteTableRow, BufferSize>::realUsedSize; i++) {
            if (MicroTable<MeshRouteTableRow, BufferSize>::buffer[i].Neighbor == neighbor && MicroTable<MeshRouteTableRow, BufferSize>::lifeTime[i] != 0) {
                return true;
            }
        }
        return false;
    }
 
    int16_t getIndexOfSource(uint8_t source) const {
        for (int16_t i = 0; i < MicroTable<MeshRouteTableRow, BufferSize>::realUsedSize; i++) {
            if (source == MicroTable<MeshRouteTableRow, BufferSize>::buffer[i].Source && MicroTable<MeshRouteTableRow, BufferSize>::lifeTime[i] != 0) {
                return i;
            }
        }
        return -1;
    }
 
    int16_t getNeighborFromSource(int8_t source) const{
        int16_t index = getIndexOfSource(source);
        if (index >= 0) {
            return MicroTable<MeshRouteTableRow, BufferSize>::buffer[index].Neighbor;
        }
        else {
            return -1;
        }
    }
 
    inline uint8_t getDirectNeighborCount() const{
        return directNeighborCount;
    }
 
    inline void setNewCallback(void(*callback)(MeshRouteTable<BufferSize>*, int16_t, const MeshRouteTableRow&, uint8_t)) {
        onNewCallback = callback;
    }
 
protected:
 
    void onCreate(int16_t index, const MeshRouteTableRow& newValue, uint8_t newRawLifeTime) override {
        if (newValue.isDirectNeighbor()) {
            directNeighborCount++;
        }
        if (onNewCallback != NULL) {
            onNewCallback(this, index, newValue, newRawLifeTime);
        }
    }
 
    /*void onSet(int16_t index, const MeshRouteTableRow& oldValue, uint8_t oldRawLifeTime, const MeshRouteTableRow& newValue, uint8_t newRawLifeTime) override {
        
    }*/
 
    void onRemove(int16_t index, const MeshRouteTableRow& oldValue, uint8_t oldRawLifeTime, bool removedByValidation = false) override {
        if (oldValue.isDirectNeighbor()) {
            directNeighborCount--;
        }
    }
 
    void onClear() override {
        directNeighborCount = 0;
    }
 
    int16_t getOldestRowIndexNotGW() const {
        uint8_t oldestLifeTime = 255;
        int16_t index = -1;
        for (int16_t i = 0; i < MicroTable<MeshRouteTableRow, BufferSize>::realUsedSize; i++) {
            if (MicroTable<MeshRouteTableRow, BufferSize>::lifeTime[i] != 0 && MicroTable<MeshRouteTableRow, BufferSize>::buffer[i].Source > MESH_GATEWAY_MAX_ADDRESS) {
                if (oldestLifeTime > MicroTable<MeshRouteTableRow, BufferSize>::lifeTime[i]) {
                    index = i;
                    oldestLifeTime = MicroTable<MeshRouteTableRow, BufferSize>::lifeTime[i];
                }
            }
        }
        return index;
    }
 
    uint8_t directNeighborCount = 0;
    void(*onNewCallback)(MeshRouteTable<BufferSize>*, int16_t, const MeshRouteTableRow&, uint8_t) = NULL;
};
 
 
template <int16_t BufferSize>
class MeshIDTable:
    public MicroTable<MeshIDTableRow, BufferSize>
{
 
public:
 
    MeshIDTable(const uint32_t rowLife) :
        MicroTable< MeshIDTableRow, BufferSize>(rowLife)
    {
    }
 
    bool set(uint16_t index, uint8_t id, uint8_t source, int16_t valid = -1) {
        return MicroTable< MeshIDTableRow, BufferSize>::set(index, MeshIDTableRow(id, source), valid);
    }
 
    bool add(uint8_t id, uint8_t source) {
        int16_t index = getIndexOfIDAndSource(id, source); //Searching, if same row does not exists yet
        if (index >= 0) {
            return set(index, id, source, 255);
        }
        else {
            //Creating new row, because it does not exists
            index = MicroTable<MeshIDTableRow, BufferSize>::getFirstBlankRowIndex();
            if (index >= 0) {
                return set(index, id, source, 255);
            }
            //Buffer is full, so we need to overwrite the oldest row.
            index = MicroTable<MeshIDTableRow, BufferSize>::getOldestRowIndex();
            return set(index, id, source, 255);
        }
    }
 
    inline bool add(const MeshIDTableRow& val) {
        return add(val.ID, val.Source);
    }
 
    void operator += (const MeshIDTableRow& val) {
        add(val);
    }
 
    bool removeByIDAndSource(uint8_t ID, uint8_t source) {
        int16_t index = getIndexOfIDAndSource(ID, source);
        if(index >= 0){
            return MicroTable<MeshIDTableRow, BufferSize>::remove(index);
        }
        return false;
    }
 
    int16_t getIndexOfIDAndSource(uint8_t id, uint8_t source) const{
        return MicroTable<MeshIDTableRow, BufferSize>::getIndexOf(MeshIDTableRow(id,source));
    }
 
    bool exists(uint8_t id, uint8_t source) const{
        return MicroTable<MeshIDTableRow, BufferSize>::exists(MeshIDTableRow(id, source));
    }
 
};
 
template <int16_t BufferSize>
class MeshFIDTable :
    public MicroTable<MeshFIDTableRow, BufferSize>
{
 
public:
 
    MeshFIDTable(const uint32_t rowLife) :
        MicroTable< MeshFIDTableRow, BufferSize>(rowLife)
    {
    }
 
    bool set(uint16_t index, uint8_t id, uint8_t source, MeshMAC bssid, int16_t valid = -1) {
        return MicroTable< MeshFIDTableRow, BufferSize>::set(index, MeshFIDTableRow(id, source, bssid), valid);
    }
 
    bool add(uint8_t id, uint8_t source, MeshMAC bssid) {
        int16_t index = getIndexOfIDSourceAndBSSID(id, source, bssid); //Searching, if same row does not exists yet
        if (index >= 0) {
            return set(index, id, source, bssid, 255);
        }
        else {
            //Creating new row, because it does not exists
            index = MicroTable<MeshFIDTableRow, BufferSize>::getFirstBlankRowIndex();
            if (index >= 0) {
                return set(index, id, source, bssid, 255);
            }
            //Buffer is full, so we need to overwrite the oldest row.
            index = MicroTable<MeshFIDTableRow, BufferSize>::getOldestRowIndex();
            return set(index, id, source, bssid, 255);
        }
    }
 
    inline bool add(const MeshFIDTableRow& val) {
        return add(val.ID, val.Source, val.BSSID);
    }
 
    void operator += (const MeshFIDTableRow& val) {
        add(val);
    }
 
    bool removeByIDSourceAndBSSID(uint8_t ID, uint8_t source, MeshMAC bssid) {
        int16_t index = getIndexOfIDSourceAndBSSID(ID, source, bssid);
        if (index >= 0) {
            return MicroTable<MeshFIDTableRow, BufferSize>::remove(index);
        }
        return false;
    }
 
    int16_t getIndexOfIDSourceAndBSSID(uint8_t id, uint8_t source, MeshMAC bssid) const {
        return MicroTable<MeshFIDTableRow, BufferSize>::getIndexOf(MeshFIDTableRow(id, source, bssid));
    }
 
    bool exists(uint8_t id, uint8_t source, MeshMAC bssid) const {
        return MicroTable<MeshFIDTableRow, BufferSize>::exists(MeshFIDTableRow(id, source, bssid));
    }
 
};
 
 
typedef enum {
    OIDTR_Removed,    //Removed by calling any remove method or calling set method with 0 raw life time
    OIDTR_Set,        //Removed by calling set or add method, data was overwritten. OIDTR_Set is also when MeshOIDTable is full and old item was overwritten.
    OIDTR_Validation, //Removed by validation.
}MeshOIDTableRemoveReason;
 
template <int16_t BufferSize>
class MeshOIDTable:
    public MicroTable<MeshOIDTableRow, BufferSize>
{
public:
 
    MeshOIDTable(const uint32_t rowLife) :
        MicroTable<MeshOIDTableRow, BufferSize>(rowLife)
    {
 
    }
 
    bool set(uint8_t index, uint8_t id, uint8_t destination, SystemPacketType type, int16_t valid = -1) {
        return MicroTable<MeshOIDTableRow, BufferSize>::set(index, MeshOIDTableRow(id, destination, type), valid);
    }
 
    bool add(uint8_t id, uint8_t destination, SystemPacketType type, uint8_t rawLifeTime = 255) {
        int16_t index = getIndexOfID(id); //Searching, if same row does not exists yet
        if (index >= 0) {
            return set(index, id, destination, type, rawLifeTime);
        }
        else {
            //Creating new row, because it does not exists
            index = MicroTable<MeshOIDTableRow, BufferSize>::getFirstBlankRowIndex();
            if (index >= 0) {
                return set(index, id, destination, type, rawLifeTime);
            }
            //Buffer is full, so we need to overwrite the oldest row.
            index = MicroTable<MeshOIDTableRow, BufferSize>::getOldestRowIndex();
            return set(index, id, destination, type, rawLifeTime);
        }
    }
 
    inline bool add(const MeshOIDTableRow& val, uint8_t rawLifeTime = 255) {
        return add(val.ID, val.Destination, val.Type);
    }
 
    bool removeID(uint8_t ID) {
        int16_t index = getIndexOfID(ID);
        if (index >= 0) {
            return MicroTable<MeshOIDTableRow, BufferSize>::remove(index);
        }
        return false;
    }
 
    int16_t removeByDestination(uint8_t destination) {
        int16_t cnt = 0;
        for (int16_t i = MicroTable<MeshOIDTableRow, BufferSize>::realUsedSize - 1; i >= 0; i--) {
            if (MicroTable<MeshOIDTableRow, BufferSize>::buffer[i].Destination == destination && MicroTable<MeshOIDTableRow, BufferSize>::lifeTime[i] >= 0) {
                cnt += MicroTable<MeshOIDTableRow, BufferSize>::remove(i);
            }
        }
        return cnt;
    }
 
    int16_t getIndexOfID(uint8_t id) const {
        for (int16_t i = 0; i < MicroTable<MeshOIDTableRow, BufferSize>::realUsedSize; i++) {
            if (MicroTable<MeshOIDTableRow, BufferSize>::buffer[i].ID == id && MicroTable<MeshOIDTableRow, BufferSize>::exists(i)) {
                return i;
            }
        }
        return -1;
    }
 
 
    bool existsID(uint8_t id) const {
        for (int16_t i = 0; i < MicroTable<MeshOIDTableRow, BufferSize>::realUsedSize; i++) {
            if (MicroTable<MeshOIDTableRow, BufferSize>::buffer[i].ID == id && MicroTable<MeshOIDTableRow, BufferSize>::exists(i)) {
                return true;
            }
        }
        return false;
    }
 
    bool existsDestAndSysPacketType(uint8_t destination, SystemPacketType type) const {
        for (int16_t i = 0; i < MicroTable<MeshOIDTableRow, BufferSize>::realUsedSize; i++) {
            if (MicroTable<MeshOIDTableRow, BufferSize>::buffer[i].Destination == destination
                && MicroTable<MeshOIDTableRow, BufferSize>::buffer[i].Type == type
                && MicroTable<MeshOIDTableRow, BufferSize>::exists(i)) {
                return true;
            }
        }
        return false;
    }
 
    inline void setOnRemoveCallback(void(*callback)(MeshOIDTable<BufferSize>*, int16_t, const MeshOIDTableRow&, uint8_t, MeshOIDTableRemoveReason)) {
        onRemoveCallback = callback;
    }
 
protected:
    void onSet(int16_t index, const MeshOIDTableRow& oldValue, uint8_t oldRawLifeTime, const MeshOIDTableRow& newValue, uint8_t newRawLifeTime) override {
        if (onRemoveCallback != NULL && oldValue.ID != newValue.ID) {
            onRemoveCallback(this, index, oldValue, oldRawLifeTime, OIDTR_Set);
        }
    }
 
    void onRemove(int16_t index, const MeshOIDTableRow& oldValue, uint8_t oldRawLifeTime, bool removedByValidation = false) override {
        if (onRemoveCallback != NULL) {
            onRemoveCallback(this, index, oldValue, oldRawLifeTime, ((removedByValidation)?OIDTR_Validation:OIDTR_Removed));
        }
    }
 
    void(*onRemoveCallback)(MeshOIDTable<BufferSize>*, int16_t, const MeshOIDTableRow&, uint8_t, MeshOIDTableRemoveReason) = NULL;
};
 
 
 
 
#endif /* INC_MESHTABLES_H_ */