HardwareAdapterEthernet.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include <QTcpSocket>
 
#include "stdafx.h"
#include "HardwareAdapter.h"
 
namespace DynExp
{
    class HardwareAdapterTcpSocket;
 
    class NetworkException : public SerialCommunicationException
    {
    public:
        NetworkException(std::string Description, const int ErrorCode,
            const std::source_location Location = std::source_location::current()) noexcept
            : SerialCommunicationException(std::move(Description), ErrorCode, Location)
        {}
    };
 
    class NetworkParamsExtension
    {
    public:
        NetworkParamsExtension(DynExp::ParamsBase& Owner)
            : ServerName{ Owner, "ServerName", "Server name",
                "IP address or host name of the server to connect to", true, "localhost" },
            Port{ Owner, "Port", "Server port",
                "Port of the remote server to connect to", true, 1000, 1, std::numeric_limits<uint16_t>::max(), 1, 0 }
        {}
 
        std::string MakeAddress() const { return ServerName.Get() + ":" + Util::ToStr(Port.Get()); }
 
        DynExp::ParamsBase::Param<ParamsConfigDialog::TextType> ServerName;     
        DynExp::ParamsBase::Param<ParamsConfigDialog::NumberType> Port;         
    };
 
    class HardwareAdapterTcpSocketParams : public QSerialCommunicationHardwareAdapterParams
    {
    public:
        HardwareAdapterTcpSocketParams(ItemIDType ID, const DynExpCore& Core)
            : QSerialCommunicationHardwareAdapterParams(ID, Core), NetworkParams(*this) {}
 
        virtual ~HardwareAdapterTcpSocketParams() = default;
 
        virtual const char* GetParamClassTag() const noexcept override { return "HardwareAdapterTcpSocketParams"; }
 
        NetworkParamsExtension NetworkParams;                                               
 
    private:
        void ConfigureParamsImpl(dispatch_tag<QSerialCommunicationHardwareAdapterParams>) override final { ConfigureParamsImpl(dispatch_tag<HardwareAdapterTcpSocketParams>()); }
        virtual void ConfigureParamsImpl(dispatch_tag<HardwareAdapterTcpSocketParams>) {}   
    };
 
    class HardwareAdapterTcpSocketConfigurator : public QSerialCommunicationHardwareAdapterConfigurator
    {
    public:
        using ObjectType = HardwareAdapterTcpSocket;
        using ParamsType = HardwareAdapterTcpSocketParams;
 
        HardwareAdapterTcpSocketConfigurator() = default;
        virtual ~HardwareAdapterTcpSocketConfigurator() = default;
 
    private:
        virtual ParamsBasePtrType MakeParams(ItemIDType ID, const DynExpCore& Core) const override { return DynExp::MakeParams<HardwareAdapterTcpSocketConfigurator>(ID, Core); }
    };
 
    class HardwareAdapterTcpSocketWorker : public QSerialCommunicationHardwareAdapterWorker
    {
        Q_OBJECT
 
    public:
        HardwareAdapterTcpSocketWorker();
        virtual ~HardwareAdapterTcpSocketWorker() {}
 
    public slots:
        void Init(QString ServerName, quint16 Port);
 
    private slots:
        void OnConnected();
 
        void OnDisconnected();
 
        void OnErrorOccurred(QAbstractSocket::SocketError SocketError);
 
        void OnDataAvailable();
 
    private:
        bool IsOpen() const noexcept;
 
        bool IsOpening() const noexcept;
 
        virtual void OpenChild() override;
        virtual void CloseChild() override;
        virtual void ResetChild() override;
        virtual void ClearChild() override;
        virtual void FlushChild() override;
        virtual void ReadChild() override;
        virtual void WriteChild(const QString& String) override;
        virtual void Write_endl_Child() override;
 
        QString ServerName;                 
        quint16 Port;                       
 
        QTcpSocket Socket;                  
    };
 
    class HardwareAdapterTcpSocket : public QSerialCommunicationHardwareAdapter
    {
        Q_OBJECT
 
    public:
        using ParamsType = HardwareAdapterTcpSocketParams;                                          
        using ConfigType = HardwareAdapterTcpSocketConfigurator;                                    
 
        constexpr static auto Name() noexcept { return "TCP Socket"; }                              
 
        HardwareAdapterTcpSocket(const std::thread::id OwnerThreadID, ParamsBasePtrType&& Params);  
        virtual ~HardwareAdapterTcpSocket() = default;
 
        virtual std::string GetName() const override { return Name(); }
 
    private:
        QWorkerPtrType MakeWorker() override;
        void InitWorker() override { Init(); }
 
        void Init();
 
        void ResetImpl(dispatch_tag<QSerialCommunicationHardwareAdapter>) override final;
        virtual void ResetImpl(dispatch_tag<HardwareAdapterTcpSocket>) {}                           
 
    signals:
 
        void InitSig(QString ServerName, quint16 Port);
    };
}