ArnRpc.hpp

Go to the documentation of this file.

// Copyright (C) 2010-2022 Michael Wiklund.
// All rights reserved.
// Contact: arnlib@wiklunden.se
//
// This file is part of the ArnLib - Active Registry Network.
// Parts of ArnLib depend on Qt and/or other libraries that have their own
// licenses. Usage of these other libraries is subject to their respective
// license agreements.
//
// GNU Lesser General Public License Usage
// This file may be used under the terms of the GNU Lesser General Public
// License version 2.1 as published by the Free Software Foundation and
// appearing in the file LICENSE_LGPL.txt included in the packaging of this
// file. In addition, as a special exception, you may use the rights described
// in the Nokia Qt LGPL Exception version 1.1, included in the file
// LGPL_EXCEPTION.txt in this package.
//
// GNU General Public License Usage
// Alternatively, this file may be used under the terms of the GNU General Public
// License version 3.0 as published by the Free Software Foundation and appearing
// in the file LICENSE_GPL.txt included in the packaging of this file.
//
// Other Usage
// Alternatively, this file may be used in accordance with the terms and conditions
// contained in a signed written agreement between you and Michael Wiklund.
//
// This program is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
// PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
//

#ifndef ARNRPC_HPP
#define ARNRPC_HPP

#define no_queue  // MetaObject tag to give Invoke::NoQueue

#include "ArnLib_global.hpp"
#include "Arn.hpp"
#include "ArnError.hpp"
#include "MQFlags.hpp"
#include "ArnCompat.hpp"
#include <QGenericArgument>
#include <QString>
#include <QByteArray>
#include <QObject>
#include <QMetaType>

#define MQ_ARG(type, label, data) MQArgument<type >(#type, #label, data)

class ArnRpcPrivate;
class ArnRpcReceiverStorage;
class ArnDynamicSignals;
class ArnPipe;
class QMetaMethod;
class QTimer;

class ARNLIBSHARED_EXPORT MQGenericArgument : public QGenericArgument
{
public:
    inline  MQGenericArgument( const char* aName =  arnNullptr, const char* aLabel =  arnNullptr,
                               const void* aData =  arnNullptr)
        : QGenericArgument( aName, aData), _label(aLabel) {}
    inline  MQGenericArgument( const QGenericArgument& qgenArg)
        : QGenericArgument( qgenArg), _label("") {}
    inline const char*  label()  const {return _label;}

private:
    const char* _label;
};


template <class T>
class MQArgument: public MQGenericArgument
{
public:
    inline MQArgument( const char* aName, const char* aLabel, const T &aData)
        : MQGenericArgument( aName, aLabel, static_cast<const void*>(&aData))
        {}
};


class ArnRpcMode {
    Q_GADGET
    Q_ENUMS(E)
public:
    enum E {
        Provider        = 0x0001,
        AutoDestroy     = 0x0002,
        UuidPipe        = 0x0004,
        NoDefaultArgs   = 0x0008,
        SendSequence    = 0x0010,
        CheckSequence   = 0x0020,
        OnlyPosArgIn    = 0x0040,
        NamedArg        = 0x0080,
        NamedTypedArg   = 0x0100,
        UseDefaultCall  = 0x0200,
        Debug           = 0x8000,
        UuidAutoDestroy = UuidPipe | AutoDestroy,
        AnyNamedArg     = NamedArg | NamedTypedArg
    };
    MQ_DECLARE_FLAGSTXT( ArnRpcMode)
};



class ARNLIBSHARED_EXPORT ArnRpc : public QObject
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(ArnRpc)

public:
    typedef ArnRpcMode  Mode;

    struct Invoke {
        enum E {
            NoQueue = 0x01
        };
        MQ_DECLARE_FLAGS( Invoke)
    };

    explicit  ArnRpc( QObject* parent = arnNullptr);
    ~ArnRpc();


    QString  pipePath() const;

    bool  open( const QString& pipePath);


    void  setPipe( ArnPipe* pipe);


    ArnPipe*  pipe()  const;

    bool  setReceiver( QObject* receiver, bool useTrackRpcSender = true);
    QObject*  receiver()  const;

    void  setMethodPrefix( const QString& prefix);
    QString  methodPrefix()  const;


    void  setIncludeSender( bool v);

    void  setMode( Mode mode);


    Mode  mode()  const;


    void  setHeartBeatSend( int time);


    int  getHeartBeatSend()  const;


    void  setHeartBeatCheck( int time);


    int  getHeartBeatCheck()  const;


    bool  isHeartBeatOk()  const;

    void  addSenderSignals( QObject* sender, const QString& prefix);


    bool invoke( const QString& funcName,
                 MQGenericArgument val0 = MQGenericArgument(0),
                 MQGenericArgument val1 = MQGenericArgument(),
                 MQGenericArgument val2 = MQGenericArgument(),
                 MQGenericArgument val3 = MQGenericArgument(),
                 MQGenericArgument val4 = MQGenericArgument(),
                 MQGenericArgument val5 = MQGenericArgument(),
                 MQGenericArgument val6 = MQGenericArgument(),
                 MQGenericArgument val7 = MQGenericArgument());


    bool invoke( const QString& funcName,
                 Invoke  invokeFlags,
                 MQGenericArgument val0 = MQGenericArgument(0),
                 MQGenericArgument val1 = MQGenericArgument(),
                 MQGenericArgument val2 = MQGenericArgument(),
                 MQGenericArgument val3 = MQGenericArgument(),
                 MQGenericArgument val4 = MQGenericArgument(),
                 MQGenericArgument val5 = MQGenericArgument(),
                 MQGenericArgument val6 = MQGenericArgument(),
                 MQGenericArgument val7 = MQGenericArgument());

    ArnRpc*  rpcSender();
    static ArnRpc*  rpcSender( QObject* receiver);


    static void  batchConnect( const QObject* sender, const ARN_RegExp& rgx,
                               const QObject* receiver, const QString& replace,
                               Mode mode = Mode());


    void  batchConnect( const ARN_RegExp& rgx,
                        const QObject* receiver, const QString& replace,
                        Mode mode = Mode()) {
        batchConnect( this, rgx, receiver, replace, mode);
    }


    void  batchConnect( const QObject* sender, const ARN_RegExp& rgx,
                        const QString& replace,
                        Mode mode = Mode()) {
        batchConnect( sender, rgx, this, replace, mode);
    }

    bool  isConvVariantPar()  const;
    void  setConvVariantPar( bool convVariantPar);

signals:

    void  pipeClosed();


    void  textReceived( const QString& text);


    void  defaultCall( const QByteArray& data);

    void  outOfSequence();


    void  heartBeatChanged( bool isOk);

    void  heartBeatReceived();

public slots:

    void  sendText( const QString& txt);

private slots:
    void  pipeInput( const QByteArray& data);
    void  destroyPipe();
    void  timeoutHeartBeatSend();
    void  timeoutHeartBeatCheck();

protected:
    void  errorLog( const QString& errText, ArnError err = ArnError::Undef, void* reference = arnNullptr);

    ArnRpc( ArnRpcPrivate& dd, QObject* parent);
    ArnRpcPrivate* const  d_ptr;

private:
    struct RpcTypeInfo {
        const char*  rpcTypeName;
        const char*  qtTypeName;
        int  typeId;
    };
    struct ArgInfo {
        QGenericArgument  arg;
        QByteArray  name;
        QByteArray  qtType;
        int  typeId;
        const void*  data;
        bool  hasName;
        bool  hasType;
        bool  dataAsArg;
        bool  isPositional;
        bool  isBinary;
        bool  isDataAlloc;
        bool  isArgAlloc;
        ArgInfo() {
            typeId       = 0;
            data         = arnNullptr;
            hasName      = false;
            hasType      = false;
            dataAsArg    = false;
            isPositional = false;
            isBinary     = false;
            isDataAlloc  = false;
            isArgAlloc   = false;
        }
    };
    struct MethodsParam {
        QList<QByteArray>  methodNames;
        struct Params {
            QList<QByteArray>  paramNames;
            QList< QList<int> >  methodIdsTab;
            QList<int>  allMethodIds;
        };
        QList<Params>  paramTab;
    };

    void  init();
    bool  xsmAddArg( Arn::XStringMap& xsm, const MQGenericArgument& arg, uint index, int& nArg);
    bool  xsmLoadArg( const Arn::XStringMap& xsm, ArgInfo& argInfo, int& index, const QByteArray& methodName);
    bool  argLogic( ArgInfo* argInfo, char* argOrder, int& argc, const QByteArray& methodName);
    int  argLogicFindMethod( const ArgInfo* argInfo, int argc, const QByteArray& methodName);
    bool  checkConvVarPar( const QByteArray& methodName, int argc);
    bool  importArgData( ArgInfo& argInfo, const QByteArray& methodName, bool useVarPar);
    void  funcHeartBeat( const Arn::XStringMap& xsm);
    void  funcHelp( const Arn::XStringMap& xsm);
    void  funcHelpMethod( const QMetaMethod& method, const QByteArray& name, int parNumMin, int flags);
    void  funcArg( const Arn::XStringMap& xsm);

    void  setupReceiverMethodsParam();
    void  deleteReceiverMethodsParam();
    static bool  hasSameParamNames( const QMetaMethod& method1, const QMetaMethod& method2);
    static QByteArray  methodSignature( const QMetaMethod& method);
    static const RpcTypeInfo&  typeInfoFromRpc( const QByteArray& rpcTypeName);
    static const RpcTypeInfo&  typeInfoFromQt( const QByteArray& qtTypeName);
    static const RpcTypeInfo&  typeInfoFromId( int typeId);
    static const RpcTypeInfo&  typeInfoNull();

    static RpcTypeInfo _rpcTypeInfoTab[];
};

MQ_DECLARE_OPERATORS_FOR_FLAGS( ArnRpcMode)
MQ_DECLARE_OPERATORS_FOR_FLAGS( ArnRpc::Invoke)
Q_DECLARE_METATYPE(ArnRpc*)

#endif // ARNRPC_HPP