abstractnodeinfo.h

Go to the documentation of this file.

/*
 * Copyright (C) 2018-2025 QuasarApp.
 * Distributed under the lgplv3 software license, see the accompanying
 * Everyone is permitted to copy and distribute verbatim copies
 * of this license document, but changing it is not allowed.
*/
 
#ifndef ABSTRACTNODEINFO_H
#define ABSTRACTNODEINFO_H
 
#include "hostaddress.h"
#include "distversion.h"
#include "heart_global.h"
#include "iparser.h"
#include <QMutex>
#include <hostaddress.h>
 
 
class QAbstractSocket;
class QHostInfo;
 
namespace QH {
 
enum class TrustNode: unsigned char {
    Undefined = 0xFF,
 
    Default = 100,
 
    Restore = 20,
 
    Baned = 0
};
 
enum class NodeCoonectionStatus: int {
    NotConnected,
    Connected,
    Confirmed,
};
 
uint qHash(NodeCoonectionStatus status);
 
class HEARTSHARED_EXPORT AbstractNodeInfo: public QObject
{
    Q_OBJECT
public:
 
    AbstractNodeInfo(QAbstractSocket *sct = nullptr,
                     const HostAddress* address = nullptr);
    virtual ~AbstractNodeInfo();
 
    QAbstractSocket *sct() const;
 
    virtual void ban();
 
    virtual bool isBanned() const;
 
    virtual void unBan();
 
    virtual int trust() const;
 
    virtual void setTrust(int trust);
 
    virtual bool isValid() const;
 
    virtual bool isConnected() const;
 
    virtual void reset();
 
    QHostInfo *info() const;
 
    void setInfo(const QHostInfo &info);
 
    HostAddress networkAddress() const;
 
    void setNetworkAddress(const HostAddress &networkAddress);
 
    NodeCoonectionStatus status() const;
 
    void setStatus(const NodeCoonectionStatus &status);
 
    void updateConfirmStatus();
 
    bool isLocal() const;
 
    void setIsLocal(bool isLocal);
 
    void setSct(QAbstractSocket *sct);
 
    const VersionData &version() const;
 
    void setVersion(const VersionData &newVersion);
 
    bool fVersionReceived() const;
 
    void setFVersionReceived(bool newFVersionReceived);
 
    bool fVersionDelivered() const;
 
    void setFVersionDelivered(bool newFVersionDelivered);
 
    QSharedPointer<QH::iParser> getParser(unsigned short cmd);
 
    QSharedPointer<QH::iParser> getParser(const QString& type);
 
    void addParser(unsigned short cmd, QSharedPointer<QH::iParser> parser);
 
    void addParser(QSharedPointer<QH::iParser> parser);
 
    const PackagesVersionData &multiVersionPackages() const;
 
    void setMultiVersionPackages(const PackagesVersionData &newMultiVersionPackages);
 
public slots:
    virtual void removeSocket();
 
signals:
 
    void sigConnected(QH::AbstractNodeInfo* thisNode);
 
    void sigDisconnected(QH::AbstractNodeInfo* thisNode);
 
    void sigReadyRead(QH::AbstractNodeInfo* thisNode);
 
    void sigErrorOccurred(QH::AbstractNodeInfo* thisNode,
                          QAbstractSocket::SocketError socketError,
                          QString message);
 
    void sigConfirmed(QH::AbstractNodeInfo* thisNode);
 
    void statusChaned(QH::AbstractNodeInfo* thisNode, QH::NodeCoonectionStatus status);
 
protected:
 
    virtual bool confirmData() const;
 
 
private:
 
    QHostInfo *_info = nullptr;
    HostAddress _networkAddress;
 
    QAbstractSocket *_sct = nullptr;
    int _trust = static_cast<int>(TrustNode::Default);
    NodeCoonectionStatus _status = NodeCoonectionStatus::NotConnected;
    bool _isLocal = false;
 
    QHash<unsigned short, QSharedPointer<iParser>> _parsersMap;
    QHash<QString, QSharedPointer<iParser>> _parsersKeysMap;
    QMutex _parsersListMutex;
 
    PackagesVersionData _multiVersionPackages;
    VersionData _version;
    bool _fVersionReceived = false;
    bool _fVersionDelivered = false;
 
};
 
}
 
Q_DECLARE_METATYPE(QH::NodeCoonectionStatus)
 
#endif // ABSTRACTNODEINFO_H