iparser.h

Go to the documentation of this file.

/*
 * Copyright (C) 2022-2024 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 IPARSER_H
#define IPARSER_H
 
#include "distversion.h"
#include "hostaddress.h"
#include <QSharedPointer>
#include <multiversiondata.h>
 
namespace QH {
 
class AbstractNodeInfo;
class AbstractNode;
 
 
using PacksMap = QHash<unsigned short, std::function<PKG::AbstractData *()>>;
 
 
enum class ParserResult {
    Error = 0,
    NotProcessed = 1,
    Processed = 2
};
 
class HEARTSHARED_EXPORT iParser: public QObject, public QuasarAppUtils::iHRO
{
    Q_OBJECT
public:
    iParser(AbstractNode* parentNode);
    virtual ~iParser() = default;
    template<class T>
    void registerPackageType() {
        _registeredTypes[T::command()] = [](){
            return new T();
        };
 
        if constexpr(std::is_base_of_v<PKG::MultiversionData, T>) {
            T tmp;
            if (const DistVersion &distVersion = tmp.packageVersion()) {
                _multiVersionPackages[tmp.cmd()] = distVersion;
            }
        }
    };
 
    virtual ParserResult parsePackage(const QSharedPointer<PKG::AbstractData> &pkg,
                                      const Header& pkgHeader, AbstractNodeInfo* sender) = 0;
 
    static QString pareseResultToString(const ParserResult& parseResult);
 
    virtual int version() const = 0;
 
    template<class PackageClass,class HandlerType, class HandlerMethod>
 
    inline ParserResult commandHandler(HandlerType handlerObject, HandlerMethod method,
                                       const QSharedPointer<QH::PKG::AbstractData> &pkg,
                                       QH::AbstractNodeInfo *sender,
                                       const QH::Header &pkgHeader) {
 
        if (PackageClass::command() == pkg->cmd()) {
            auto data = pkg.staticCast<PackageClass>();
 
            if (!data->isValid()) {
                return QH::ParserResult::Error;
            }
 
            if(!(handlerObject->*method)(data, sender, pkgHeader)) {
                return QH::ParserResult::Error;
            }
 
            return QH::ParserResult::Processed;
        }
 
        return QH::ParserResult::NotProcessed;
    }
 
    const PacksMap &registeredTypes() const;
 
    QSharedPointer<PKG::AbstractData> genPackage(unsigned short cmd) const;
 
    bool checkCommand(unsigned short cmd) const;
 
    virtual QString parserId() const = 0;
 
    virtual void initSupportedCommands();
 
    QString toString() const override;
 
    const PackagesVersionData &multiVersionPackages() const;
protected:
    AbstractNode *node() const;
 
    virtual unsigned int sendData(const PKG::AbstractData *resp,  const HostAddress& address,
                                  const Header *req = nullptr) const;
 
    virtual unsigned int sendData(const PKG::AbstractData *resp, const AbstractNodeInfo *node,
                                  const Header *req = nullptr) const;
 
private:
    // command - {version - factory}
    PacksMap _registeredTypes;
    PackagesVersionData _multiVersionPackages;
 
    AbstractNode *_node;
 
    friend class BigDataParserOld;
    friend class AbstractNodeParserOld;
    friend class AbstractNode;
 
};
 
 
}
#endif // IPARSER_H