meshHelper.h

Go to the documentation of this file.

 
#ifndef INC_MESHHELPER_H_
#define INC_MESHHELPER_H_
 
#include "meshConfig.h"
 
#define HAS_MEM_FUNC(func, name)                                                \
    template<typename T, typename Sign>                                         \
    struct name {                                                               \
        typedef char yes[1];                                                    \
        typedef char no [2];                                                    \
        template <typename U, U> struct type_check;                             \
        template <typename _1> static yes &chk(type_check<Sign, &_1::func> *);  \
        template <typename   > static no  &chk(...);                            \
        static bool const value = sizeof(chk<T>(0)) == sizeof(yes);             \
    }
 
 
#ifdef SIMULATION
typedef enum {
    //Prolonging row
    MST_PROLONG,
    //Removing from table
    MST_REMOVE,
    //Setting or adding item to table
    MST_SET,
    //Removed by validation
    MST_REMOVE_VLD,
    //Cleared table
    MST_CLEAR,
    //Defragmented
    MST_DEFRAG,
 
}TableChangeType;
 
class MeshNet;
class MSHelper {
public:
    //Descriptor of table that is used to identify table
    std::string descriptor;
    MeshNet* mn = NULL;
    uint32_t millis() const;
    uint32_t micros() const;
    void delay(uint32_t time) const;
    void delayMicroseconds(uint32_t time) const;
    std::stringstream& NotifyTableChangeBegin(TableChangeType changeType);
    void NotifyTableChangeEnd();
 
protected:
    std::stringstream tableChangeStream;
    TableChangeType lastChangeType = MST_CLEAR;
};
 
#endif // SIMULATION
 
 
#ifdef NO_ITOA_S
char* _itoa_s( int32_t value, char * buffer, size_t size, int radix);
#endif //NO_ITOA_S
 
typedef enum {
    T_LEFT,
    T_CENTER,
    T_RIGHT
}TextAlignment;
 
void alignText(char *text, int size, char fill, TextAlignment alignment);
 
class InlinePrintable : public Printable {
public:
    virtual size_t printHeader(OSTREAM* stream) const {
        return 0;
    }
 
    virtual size_t printLine(OSTREAM * stream) const {
        return 0;
    }
};
 
class RawPrintable : public InlinePrintable {
public:
    
    virtual size_t sizeOf() const {
        return sizeof(*this);
    }
 
    virtual size_t printRaw(OSTREAM* stream, void(* CRC_calculation)(uint8_t*, size_t)) const {
        return 0;
    }
 
    virtual size_t getRawSize() const {
        return 0;
    }
};
 
typedef enum {
    MPS_Unknown = 0,        
    MPS_Sent,               
    MPS_Waiting,            
    MPS_WaitingForPath      
}MeshPacketStatus;
 
struct MeshMAC {
    uint8_t octet4 = 0;
 
    uint8_t octet3 = 0;
 
    uint8_t octet2 = 0;
 
    uint8_t octet1 = 0;
 
    MeshMAC() = default;
 
    MeshMAC(uint8_t octet1, uint8_t octet2, uint8_t octet3, uint8_t octet4);
 
    MeshMAC(uint32_t mac);
 
    MeshMAC(const MeshMAC &mac) = default;
 
    inline bool isValid() const {
        return getRaw() != 0;
    }
 
    inline uint32_t getRaw() const {
        return *(reinterpret_cast<const uint32_t*>(this));
        //return (uint32_t)octet4 | ((uint32_t)octet3 << 8) | ((uint32_t)octet2 << 16) | ((uint32_t)octet1 << 24);
    }
 
    inline void setRaw(const uint32_t mac) {
        const MeshMAC* tmp = reinterpret_cast<const MeshMAC*>(&mac);
        *this = *tmp;
        /*octet4 = mac;
        octet3 = mac >> 8;
        octet2 = mac >> 16;
        octet1 = mac >> 24;*/
    }
 
    size_t printTo(Print& p) const;
 
    static char digitToHex(uint8_t digit, bool low = true);
 
    void operator=(const uint32_t& val) {
        setRaw(val);
    }
 
    operator uint32_t() const { return getRaw(); }
    operator uint32_t() { return getRaw(); }
};
 
struct MeshVersion {
    
    uint16_t Patch : 5;
 
    uint16_t Minor : 5;
    
    uint16_t Major : 6;
 
    MeshVersion():
        Patch(0),
        Minor(0),
        Major(0)
    { }
 
    MeshVersion(uint8_t major, uint8_t minor, uint8_t patch);
 
    MeshVersion(uint16_t raw);
 
    MeshVersion(const MeshVersion &mac) = default;
 
    inline uint16_t getRaw() const {
        return *(reinterpret_cast<const uint16_t*>(this));
    }
 
    inline void setRaw(const uint16_t version) {
        const MeshVersion *tmp = reinterpret_cast<const MeshVersion*>(&version);
        *this = *tmp;
        /*Major = tmp->Major;
        Minor = tmp->Minor;
        Patch = tmp->Patch;*/
    }
 
    size_t printTo(Print& p) const;
 
    //Casting operators
    void operator=(const uint16_t& val) {
        setRaw(val);
    }
 
    operator uint16_t() const { return getRaw(); }
    operator uint16_t() { return getRaw(); }
 
    //Equality operators
    bool operator==(const uint16_t& val){ return getRaw() == val;}
    bool operator==(const MeshVersion& val){ return getRaw() == val.getRaw();}
 
    bool operator!=(const uint16_t& val){ return getRaw() != val;}
    bool operator!=(const MeshVersion& val){ return getRaw() != val.getRaw();}
 
    bool operator>=(const uint16_t& val){ return getRaw() >= val;}
    bool operator>=(const MeshVersion& val){ return getRaw() >= val.getRaw();}
 
    bool operator<=(const uint16_t& val){ return getRaw() <= val;}
    bool operator<=(const MeshVersion& val){ return getRaw() <= val.getRaw();}
 
    bool operator>(const uint16_t& val){ return getRaw() > val;}
    bool operator>(const MeshVersion& val){ return getRaw() > val.getRaw();}
 
    bool operator<(const uint16_t& val){ return getRaw() < val;}
    bool operator<(const MeshVersion& val){ return getRaw() < val.getRaw();}
};
 
 
#endif /* INC_MESHHELPER_H_ */