Features 2581

DapRPCProtocol/DapRpcServiceRequest.h

@@ -8,24 +8,53 @@
 #include "DapRpcMessage.h"
 
 class DapRpcSocket;
+/**
+ * @brief The DapRpcServiceRequest class
+ * Class provides to operate with request message by socket interface
+ * @see DapRpcSocket
+ */
 class DapRpcServiceRequest
 {
+    /// Request message
     DapRpcMessage m_request;
+    /// RPC socket
     QPointer<DapRpcSocket> m_socket;
 
 public:
+    /// Standard constructor
     DapRpcServiceRequest();
+    /// Copy constructor
     DapRpcServiceRequest(const DapRpcServiceRequest &aDapRpcServiceRequest);
+    /// Overloaded constructor
+    /// @param aRequest Request message
+    /// @param apSocket Pointer to RPC socket
     DapRpcServiceRequest(const DapRpcMessage &aRequest, DapRpcSocket *apSocket);
+    /// Overloaded assignment operator
+    /// @param aDapRpcServiceRequest Other DapRpcServiceRequest object
+    /// @return Reference to this object
     DapRpcServiceRequest &operator=(const DapRpcServiceRequest &aDapRpcServiceRequest);
+    /// Standard destructor
     ~DapRpcServiceRequest();
 
+    /// Validation of request message
+    /// @return If request message is valid or socket is not null return true.
+    /// Otherwise return false
     bool isValid() const;
+    /// Get request message
+    /// @return Request message
     DapRpcMessage request() const;
+    /// Get current socket
+    /// @return Socket
     DapRpcSocket *socket() const;
 
-    bool respond(const DapRpcMessage &aResponse);
+    /// Create response to following respont by socket
+    /// @param aReturnValue Return value from service
+    /// @return False if socket is closed
     bool respond(QVariant aReturnValue);
+    /// Send response to socket
+    /// @param aResponse Response message
+    /// @return False if socket is closed
+    bool respond(const DapRpcMessage &aResponse);
 };
 
 #endif // DapRPCSERVICEREQUEST_H

DapRPCProtocol/DapRpcSocket.h

@@ -15,54 +15,136 @@
 
 #define DEFAULT_MSECS_REQUEST_TIMEOUT (30000)
 
+/**
+ * @brief The DapRpcSocket class
+ * Realization socket interface:
+ *  - Store information about device and data
+ *  - Sending/receiving messages
+ *  - Control sending request by timeout
+ */
 class DapRpcSocket : public QObject
 {
     Q_OBJECT
     Q_DISABLE_COPY(DapRpcSocket)
 
+    /// Pointer to IO device
     QPointer<QIODevice> m_pDevice;
+    /// Buffer
     QByteArray m_aBuffer;
+    /// Storage to replies by id
     QHash<int, QPointer<DapRpcServiceReply>> m_replies;
+    /// Default request timeout
     int m_defaultRequestTimeout;
 
 protected:
+    /// TODO: not implement
+    /// @param asMessage Request message
     virtual void processRequestMessage(const DapRpcMessage &asMessage);
 
 public:
+    /// Standard constructor
     explicit DapRpcSocket(QObject *apParent = nullptr);
+    /// Overloaded constructor
+    /// @param apDevice Device whick provides both a common implementation and
+    /// an abstract interface for devices that support reading and writing of blocks of data
     explicit DapRpcSocket(QIODevice *apDevice, QObject *apParent = nullptr);
+    /// Virtual destructor
     virtual ~DapRpcSocket();
 
+    /// Validation initialization and open device
+    /// @return True if device initilized and opened. Otherwise return false
     virtual bool isValid() const;
+    /// Set default request timeout
+    /// @param aiMsecs Miliseconds
     void setDefaultRequestTimeout(int aiMsecs);
+    /// Get default request timeout
+    /// @return Default request timeout
     int getDefaultRequestTimeout() const;
-
+    /// Set IO Device
+    /// @param Pointer to IO device
     void setIODevice(QIODevice *pDevice);
 
 signals:
+    /// The signal emitted when message was received
+    /// @param asMessage Request message
     void messageReceived(const DapRpcMessage &asMessage);
 
 private slots:
+    /// Read data from device and prepare reply
     virtual void processIncomingData();
+    /// Find end of Json document
+    /// @param aJsonData Json data where need to find end
+    /// @return Index of end json document. If file empty return -1
     int findJsonDocumentEnd(const QByteArray &aJsonData);
+    /// Write data from message to device
+    /// @param asMessage Request message
     void writeData(const DapRpcMessage &asMessage);
 
 public slots:
+    /// Notify to new request message and try to send to device
+    /// @param asMessage Request message
     virtual void notify(const DapRpcMessage &asMessage);
+    /// Send message with delay for sending message
+    /// @param asMessage Request message
+    /// @param aMsecs Delay request timeout. If not pass parameter uses default value
+    /// @return Response from reply
     virtual DapRpcMessage sendMessageBlocking(const DapRpcMessage &asMessage, int aMsecs = DEFAULT_MSECS_REQUEST_TIMEOUT);
+    /// Send request message to device
+    /// @param asMessage Request message
+    /// @return Pointer of service reply
     virtual DapRpcServiceReply *sendMessage(const DapRpcMessage &asMessage);
+    /// Invoke remote method and create response to send to IO device with delay
+    /// @param asMethod Method's name
+    /// @param aMsecs Delay time for send
+    /// @param arg1 First argument
+    /// @param arg2 Second argument
+    /// @param arg3 Third argument
+    /// @param arg4 Fourth argument
+    /// @param arg5 Fifth argument
+    /// @param arg6 Six argument
+    /// @param arg7 Seven argument
+    /// @param arg8 Eight argument
+    /// @param arg9 Nine argument
+    /// @param arg10 Ten argument
+    /// @return Response from reply
     DapRpcMessage invokeRemoteMethodBlocking(const QString &asMethod, int aMsecs, const QVariant &arg1 = QVariant(),
                                                const QVariant &arg2 = QVariant(), const QVariant &arg3 = QVariant(),
                                                const QVariant &arg4 = QVariant(), const QVariant &arg5 = QVariant(),
                                                const QVariant &arg6 = QVariant(), const QVariant &arg7 = QVariant(),
                                                const QVariant &arg8 = QVariant(), const QVariant &arg9 = QVariant(),
                                                const QVariant &arg10 = QVariant());
+    /// Invoke remote method and create response to send to IO device with default delay time
+    /// @param asMethod Method's name
+    /// @param arg1 First argument
+    /// @param arg2 Second argument
+    /// @param arg3 Third argument
+    /// @param arg4 Fourth argument
+    /// @param arg5 Fifth argument
+    /// @param arg6 Six argument
+    /// @param arg7 Seven argument
+    /// @param arg8 Eight argument
+    /// @param arg9 Nine argument
+    /// @param arg10 Ten argument
+    /// @return Response from reply
     DapRpcMessage invokeRemoteMethodBlocking(const QString &asMethod, const QVariant &arg1 = QVariant(),
                                                const QVariant &arg2 = QVariant(), const QVariant &arg3 = QVariant(),
                                                const QVariant &arg4 = QVariant(), const QVariant &arg5 = QVariant(),
                                                const QVariant &arg6 = QVariant(), const QVariant &arg7 = QVariant(),
                                                const QVariant &arg8 = QVariant(), const QVariant &arg9 = QVariant(),
                                                const QVariant &arg10 = QVariant());
+    /// Invoke remote method and create response to send to IO device
+    /// @param asMethod Method's name
+    /// @param arg1 First argument
+    /// @param arg2 Second argument
+    /// @param arg3 Third argument
+    /// @param arg4 Fourth argument
+    /// @param arg5 Fifth argument
+    /// @param arg6 Six argument
+    /// @param arg7 Seven argument
+    /// @param arg8 Eight argument
+    /// @param arg9 Nine argument
+    /// @param arg10 Ten argument
+    /// @return Pointer to service reply
     DapRpcServiceReply *invokeRemoteMethod(const QString &asMethod, const QVariant &arg1 = QVariant(),
                                              const QVariant &arg2 = QVariant(), const QVariant &arg3 = QVariant(),
                                              const QVariant &arg4 = QVariant(), const QVariant &arg5 = QVariant(),

DapRPCProtocol/DapRpcTCPServer.h

@@ -8,36 +8,68 @@
 #include "DapRpcSocket.h"
 #include "DapRpcAbstractServer.h"
 
+/**
+ * @brief The DapRpcTCPServer class
+ * TCP server class realize interface DapRpcAbstractServer
+ * @see DapRpcAbstractServer
+ * @see QTcpServer
+ */
 class DapRpcTCPServer : public QTcpServer, public DapRpcAbstractServer
 {
     Q_OBJECT
     Q_DISABLE_COPY(DapRpcTCPServer)
-
+    /// Lookup's tcp sockets witj Rpc sockets
     QHash<QTcpSocket*, DapRpcSocket*> m_socketLookup;
 
 protected:
+    /// This virtual function is called by QTcpServer when a new connection is available
+    /// @param aSocketDescriptor The socketDescriptor argument is the native socket
+    /// descriptor for the accepted connection
     virtual void incomingConnection(qintptr aSocketDescriptor);
 
 public:
+    /// Standard constructor
     explicit DapRpcTCPServer(QObject *apParent = nullptr);
+    /// Virtual destructor
     virtual ~DapRpcTCPServer();
 
+    /// Tells the server to listen for incoming connections on address
+    /// @param asAddress Address
+    /// @param aPort Port. If port is 0, a port is chosen automatically
+    /// @param If address is QHostAddress::Any, the server will listen on all network interfaces
+    /// @return Returns true on success; otherwise returns false.
+    /// @see isListening()
     virtual bool listen(const QString &asAddress = QString(), quint16 aPort = 0);
-
+    /// Add new service
+    /// @param apService New service
+    /// @return If service add successfully return true. Otherwise return false
     bool addService(DapRpcService *apService);
+    /// Remove service
+    /// @param apService Service for removing
+    /// @return If service add successfully return true. Otherwise return false
     bool removeService(DapRpcService *apService);
 
 signals:
+    /// The signal is emitted when client was connected
     void onClientConnected();
+    /// The signal is emitted when client was disconnected
     void onClientDisconnected();
 
 protected slots:
+    /// Calls when client disconnected
     void clientDisconnected();
+    /// When receive message from client prepare message by type of message
+    /// @param asMessage Message
     void messageProcessing(const DapRpcMessage &asMessage);
 
     // DapRpcAbstractServer interface
 public slots:
+    /// Notify connected clients. Send all message
+    /// @param message Message to client
     void notifyConnectedClients(const DapRpcMessage &message);
+    /// Notify connected clients. Send all message
+    /// @param method Method which clients were notified
+    /// @param params Parameters of message in JSON format
     void notifyConnectedClients(const QString &method, const QJsonArray &params);
 };