node.h

#ifndef DECONZ_NODE_H
#define DECONZ_NODE_H
 
/*
 * Copyright (c) 2012-2023 dresden elektronik ingenieurtechnik gmbh.
 * All rights reserved.
 *
 * The software in this package is published under the terms of the BSD
 * style license a copy of which has been included with this distribution in
 * the LICENSE.txt file.
 *
 */
 
#include <vector>
#include <deconz/types.h>
#include <deconz/aps.h>
#include <deconz/binding_table.h>
#include <deconz/zdp_descriptors.h>
 
namespace deCONZ
{
 
class DECONZ_DLLSPEC NodeNeighbor
{
public:
    NodeNeighbor() : m_lqi(0) {}
    NodeNeighbor(const Address &addr, quint8 lqi): m_address(addr), m_lqi(lqi) { }
    const Address &address() const { return m_address; }
    quint8 lqi() const { return m_lqi; }
 
private:
    Address m_address;
    quint8 m_lqi;
};
 
inline uint SR_HashUuid(const QString &uuid)
{
    return qHash(uuid);
}
 
class DECONZ_DLLSPEC SourceRoute
{
public:
    enum Constants { MaxHops = 9 };
    enum State { StateIdle, StateWorking, StateSleep };
 
    SourceRoute(const QString &uuid, const int order, const std::vector<Address> &hops) :
        m_uuid(uuid),
        m_order(order),
        m_hops(hops)
       {
           m_srHash = qHash(uuid);
       }
 
    bool operator==(const SourceRoute &other) const
    {
        bool eqLqi = true;
        for (size_t i = 0; i < MaxHops && i < m_hops.size(); i++)
        {
            if (m_hopLqi[i] != other.m_hopLqi[i])
            {
                eqLqi = false;
                break;
            }
        }
        return m_srHash == other.uuidHash() &&
                m_txOk == other.txOk() &&
                m_errors == other.errors() &&
                m_hops == other.hops() &&
                eqLqi;
    }
 
    bool operator!=(const SourceRoute &other) const
    {
        return !(*this == other);
    }
 
    bool isValid() const { return m_srHash != 0 && !m_hops.empty(); }
    bool isOperational() const;
    const QString &uuid() const { return m_uuid; }
    uint uuidHash() const { return m_srHash; }
    const std::vector<Address> &hops() const { return m_hops; }
    int order() const { return m_order; }
    void addHop(const deCONZ::Address &hop, quint8 lqi);
    bool hasHop(const deCONZ::Address &hop) const;
    void updateHopAddress(const deCONZ::Address &hop);
    size_t errors() const { return m_errors; }
    void incrementErrors();
    size_t txOk() const { return m_txOk; }
    void incrementTxOk();
    State state() const { return m_state; }
    void setState(State state) { m_state = state; }
    bool needSave() const { return m_needSave; }
    void saved() { m_needSave = false; }
 
    quint8 m_hopLqi[MaxHops] = { };
 
private:
    bool m_needSave = false;
    State m_state = StateIdle;
    QString m_uuid;
    int m_order = 0;
    size_t m_txOk = 0;
    size_t m_errors = 0;
    uint m_srHash = 0;
    std::vector<Address> m_hops;
};
 
class NodePrivate;
 
class DECONZ_DLLSPEC Node
{
public:
    Node();
    Node(const Node &other);
    Node& operator=(const Node &other);
    virtual ~Node();
    virtual CommonState state() const = 0;
    const deCONZ::Address &address() const;
    bool isCoordinator() const;
    bool isRouter() const;
    bool isEndDevice() const;
    bool isZombie() const;
    void setIsZombie(bool isZombie);
    const QString &userDescriptor() const;
    void setUserDescriptor(const QString &userDescriptor);
    QString deviceTypeString();
    const std::vector<uint8_t> &endpoints() const;
    void setActiveEndpoints(const std::vector<uint8_t> &ep);
    SimpleDescriptor *getSimpleDescriptor(uint8_t endpoint);
    bool setSimpleDescriptor(const SimpleDescriptor &descr);
    std::vector<SimpleDescriptor> &simpleDescriptors();
    const std::vector<SimpleDescriptor> &simpleDescriptors() const;
    int copySimpleDescriptor(uint8_t endpoint, SimpleDescriptor *descr) const;
    const NodeDescriptor & nodeDescriptor() const;
    void setNodeDescriptor(const NodeDescriptor &descr);
    const PowerDescriptor &powerDescriptor() const;
    void setPowerDescriptor(const PowerDescriptor &descr);
    const MacCapabilities &macCapabilities() const;
    void setMacCapabilities(MacCapabilities cap);
    void resetAll();
    virtual const std::vector<NodeNeighbor> &neighbors() const = 0;
    const std::vector<SourceRoute> &sourceRoutes() const;
    int addSourceRoute(const SourceRoute &sourceRoute);
    bool updateSourceRoute(const SourceRoute &sourceRoute);
    int removeSourceRoute(uint srHash);
    virtual const BindingTable &bindingTable() const = 0;
 
    void pushEdScan(int ed);
    int edScanValue() const;
    bool needRedraw() const;
    void setNeedRedraw(bool redraw);
 
protected:
    NodePrivate *d_ptr = nullptr;
    Q_DECLARE_PRIVATE(Node)
};
 
}
 
#endif // DECONZ_NODE_H