HardwareAdapter.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include "stdafx.h"
#include "Object.h"
 
namespace DynExp
{
    class HardwareAdapterBase;
    class SerialCommunicationHardwareAdapter;
    class QSerialCommunicationHardwareAdapter;
 
    using HardwareAdapterPtrType = std::shared_ptr<HardwareAdapterBase>;
 
    template <typename HardwareAdapterT>
    ConfiguratorBasePtrType MakeHardwareAdapterConfig()
    {
        return std::make_shared<typename HardwareAdapterT::ConfigType>();
    }
 
    template <typename HardwareAdapterT>
    HardwareAdapterPtrType MakeHardwareAdapter(const std::thread::id OwnerThreadID, ParamsBasePtrType&& Params)
    {
        return std::make_shared<HardwareAdapterT>(OwnerThreadID, std::move(Params));
    }
 
    class HardwareAdapterParamsBase : public ParamsBase
    {
    public:
        HardwareAdapterParamsBase(ItemIDType ID, const DynExpCore& Core) : ParamsBase(ID, Core) {}
 
        virtual ~HardwareAdapterParamsBase() = 0;
 
        virtual const char* GetParamClassTag() const noexcept override { return "HardwareAdapterParamsBase"; }
 
    private:
        void ConfigureParamsImpl(dispatch_tag<ParamsBase>) override final { ConfigureParamsImpl(dispatch_tag<HardwareAdapterParamsBase>()); }
        virtual void ConfigureParamsImpl(dispatch_tag<HardwareAdapterParamsBase>) {}    
 
        DummyParam Dummy = { *this };                                                   
    };
 
    class HardwareAdapterConfiguratorBase : public ConfiguratorBase
    {
    public:
        using ObjectType = HardwareAdapterBase;
        using ParamsType = HardwareAdapterParamsBase;
 
        HardwareAdapterConfiguratorBase() = default;
        virtual ~HardwareAdapterConfiguratorBase() = 0;
    };
 
    class HardwareAdapterBase : public Util::ILockable, public Object
    {
    public:
        using ParamsType = HardwareAdapterParamsBase;           
        using ConfigType = HardwareAdapterConfiguratorBase;     
 
        static constexpr auto ShortTimeoutDefault = std::chrono::milliseconds(10);
 
        static constexpr auto HardwareOperationTimeout = std::chrono::milliseconds(100);
 
        constexpr static auto Category() noexcept { return ""; }
 
        HardwareAdapterBase(const std::thread::id OwnerThreadID, ParamsBasePtrType&& Params)
            : Object(OwnerThreadID, std::move(Params)) {}
 
        virtual ~HardwareAdapterBase() = 0;
 
        virtual std::string GetCategory() const override { return Category(); }
 
        void ResetException() const;
 
        bool IsConnected() const noexcept { return IsConnectedChild(); }
 
    protected:
        void ThrowException(std::exception_ptr Exception) const;
 
 
        void ThrowExceptionUnsafe(std::exception_ptr Exception) const;
 
        void SetExceptionUnsafe(std::exception_ptr Exception) const;
 
        auto GetExceptionUnsafe() const { return LastException; }
 
    private:
        void ResetImpl(dispatch_tag<Object>) override final;
        virtual void ResetImpl(dispatch_tag<HardwareAdapterBase>) = 0;  
 
        void EnsureReadyStateChild([[maybe_unused]] bool IsAutomaticStartup) override final;
 
        virtual void EnsureReadyStateChild() = 0;                       
        std::exception_ptr GetExceptionChild(const std::chrono::milliseconds Timeout) const override final;
 
        virtual bool IsConnectedChild() const noexcept = 0;             
 
        mutable std::exception_ptr LastException;                       
    };
 
    class SerialCommunicationException : public Util::Exception
    {
    public:
        SerialCommunicationException(std::string Description, const int ErrorCode,
            const std::source_location Location = std::source_location::current()) noexcept
            : Exception(std::move(Description), Util::ErrorType::Error, ErrorCode, Location)
        {}
    };
 
    class SerialCommunicationHardwareAdapterParams : public HardwareAdapterParamsBase
    {
    public:
        enum LineEndingType { None, Zero, LF, CRLF, CR };
 
        SerialCommunicationHardwareAdapterParams(ItemIDType ID, const DynExpCore& Core) : HardwareAdapterParamsBase(ID, Core) {}
 
        virtual ~SerialCommunicationHardwareAdapterParams() = 0;
 
        virtual const char* GetParamClassTag() const noexcept override { return "SerialCommunicationHardwareAdapterParams"; }
 
        static Util::TextValueListType<LineEndingType> AvlblLineEndingsStrList();
 
        Param<LineEndingType> LineEnding = { *this, AvlblLineEndingsStrList(), "LineEnding", "Line ending",
            "Characters which terminate a single line", true, LineEndingType::LF };
 
    private:
        void ConfigureParamsImpl(dispatch_tag<HardwareAdapterParamsBase>) override final { ConfigureParamsImpl(dispatch_tag<SerialCommunicationHardwareAdapterParams>()); }
        virtual void ConfigureParamsImpl(dispatch_tag<SerialCommunicationHardwareAdapterParams>) {}     
    };
 
    class SerialCommunicationHardwareAdapterConfigurator : public HardwareAdapterConfiguratorBase
    {
    public:
        using ObjectType = SerialCommunicationHardwareAdapter;
        using ParamsType = SerialCommunicationHardwareAdapterParams;
 
        SerialCommunicationHardwareAdapterConfigurator() = default;
        virtual ~SerialCommunicationHardwareAdapterConfigurator() = 0;
    };
 
    class SerialCommunicationHardwareAdapter : public HardwareAdapterBase
    {
    public:
        using ParamsType = SerialCommunicationHardwareAdapterParams;                
        using ConfigType = SerialCommunicationHardwareAdapterConfigurator;          
 
        struct endl {};
 
        constexpr static auto Name() noexcept { return "< any >"; }
        
        constexpr static auto Category() noexcept { return "Communication"; }       
 
        constexpr static std::array<char, 2> LineEndingToChar(SerialCommunicationHardwareAdapterParams::LineEndingType LineEnding) noexcept;
 
        constexpr static unsigned int GetLineEndingLength(SerialCommunicationHardwareAdapterParams::LineEndingType LineEnding) noexcept;
 
        constexpr static auto GetMaxBufferSize() noexcept { return 104857600; }
 
        SerialCommunicationHardwareAdapter(const std::thread::id OwnerThreadID, ParamsBasePtrType&& Params);
 
        virtual ~SerialCommunicationHardwareAdapter() = 0;
 
        virtual std::string GetName() const override { return Name(); }
        virtual std::string GetCategory() const override { return Category(); }
 
        auto GetLineEnding() const { return LineEnding.load(); }
 
        std::string ReadLine() const;
 
        std::string ReadAll() const;
 
        std::string WaitForLine(unsigned int NumTries = 10, std::chrono::milliseconds DelayBetweenTries = std::chrono::milliseconds(10)) const;
        
        void Clear() const;
 
        void Flush() const;
 
        const SerialCommunicationHardwareAdapter& operator>>(std::stringstream& OutStream) const;
 
        const SerialCommunicationHardwareAdapter& operator<<(endl) const;
 
        const SerialCommunicationHardwareAdapter& operator<<(const std::stringstream& InStream) const;
 
        const SerialCommunicationHardwareAdapter& operator<<(const std::string& Text) const;
 
        const SerialCommunicationHardwareAdapter& operator<<(const std::string_view Text) const;
 
        const SerialCommunicationHardwareAdapter& operator<<(const char* Text) const;
 
        const SerialCommunicationHardwareAdapter& operator<<(const char Char) const;
 
        template <typename T>
        auto& operator<<(const T& Value) const
        {
            auto lock = AcquireLock(HardwareOperationTimeout);
 
            Write(Util::ToStr(Value));
            Write_endl();
 
            return *this;
        }
 
    protected:
        void InsertIntoBuffer(const std::string& String) const;
 
    private:
        void Init();    
 
        void ResetImpl(dispatch_tag<HardwareAdapterBase>) override final;
        virtual void ResetImpl(dispatch_tag<SerialCommunicationHardwareAdapter>) {}     
 
 
        void ReadIntoBuffer() const;
 
        void ClearReadBuffer() const;
 
        bool CheckOverflow() const;
 
        virtual void ClearChild() const {}      
        virtual void FlushChild() const {}      
 
        virtual std::string Read() const = 0;
 
        virtual void Write(const std::string& String) const = 0;
 
        virtual void Write_endl() const = 0;
 
        std::atomic<SerialCommunicationHardwareAdapterParams::LineEndingType> LineEnding = SerialCommunicationHardwareAdapterParams::LineEndingType::LF;
        
        std::string LineEndingString;           
        mutable std::stringstream ReadBuffer;   
    };
 
    constexpr std::array<char, 2> SerialCommunicationHardwareAdapter::LineEndingToChar(SerialCommunicationHardwareAdapterParams::LineEndingType LineEnding) noexcept
    {
        switch (LineEnding)
        {
        case SerialCommunicationHardwareAdapterParams::LineEndingType::LF: return { '\n', '\0' };
        case SerialCommunicationHardwareAdapterParams::LineEndingType::CRLF: return { '\r', '\n' };
        case SerialCommunicationHardwareAdapterParams::LineEndingType::CR: return { '\r', '\0' };
        default: return { '\0', '\0' };
        }
    }
 
    constexpr unsigned int SerialCommunicationHardwareAdapter::GetLineEndingLength(SerialCommunicationHardwareAdapterParams::LineEndingType LineEnding) noexcept
    {
        if (LineEnding == SerialCommunicationHardwareAdapterParams::LineEndingType::None)
            return 0;
        if (LineEnding == SerialCommunicationHardwareAdapterParams::LineEndingType::CRLF)
            return 2;
 
        return 1;
    }
 
    class QSerialCommunicationHardwareAdapterParams : public SerialCommunicationHardwareAdapterParams
    {
    public:
        QSerialCommunicationHardwareAdapterParams(ItemIDType ID, const DynExpCore& Core) : SerialCommunicationHardwareAdapterParams(ID, Core) {}
        
        virtual ~QSerialCommunicationHardwareAdapterParams() = 0;
 
        virtual const char* GetParamClassTag() const noexcept override { return "QSerialCommunicationHardwareAdapterParams"; }
 
    private:
        void ConfigureParamsImpl(dispatch_tag<SerialCommunicationHardwareAdapterParams>) override final { ConfigureParamsImpl(dispatch_tag<QSerialCommunicationHardwareAdapterParams>()); }
        virtual void ConfigureParamsImpl(dispatch_tag<QSerialCommunicationHardwareAdapterParams>) {}    
 
        DummyParam Dummy = { *this };                                                                   
    };
 
    class QSerialCommunicationHardwareAdapterConfigurator : public SerialCommunicationHardwareAdapterConfigurator
    {
    public:
        using ObjectType = QSerialCommunicationHardwareAdapter;
        using ParamsType = QSerialCommunicationHardwareAdapterParams;
 
        QSerialCommunicationHardwareAdapterConfigurator() = default;
        virtual ~QSerialCommunicationHardwareAdapterConfigurator() = 0;
    };
 
    class QSerialCommunicationHardwareAdapterWorker : public Util::QWorker
    {
        Q_OBJECT
 
    public:
        QSerialCommunicationHardwareAdapterWorker() = default;
        virtual ~QSerialCommunicationHardwareAdapterWorker() = 0;
 
    public slots:
        void Open() { OpenChild(); }                                
        void Close() { CloseChild(); }                              
        void Reset() { ResetChild(); }                              
        void Clear() { ClearChild(); }                              
        void Flush() { FlushChild(); }                              
        void Read() { ReadChild(); }                                
        void Write(const QString String) { WriteChild(String); }    
        void Write_endl() { Write_endl_Child(); }                   
 
    protected:
        void SetCommunicationChannelOpened() const noexcept;
 
        void SetCommunicationChannelClosed() const noexcept;
 
        void DataRead(const std::string& String) const;
 
        template <typename ExceptionType>
        void SetException(const ExceptionType& Exception) const;
 
    private:
        virtual void OpenChild() = 0;                               
        virtual void CloseChild() = 0;                              
        virtual void ResetChild() = 0;                              
        virtual void ClearChild() = 0;                              
        virtual void FlushChild() = 0;                              
        virtual void ReadChild() = 0;                               
        virtual void WriteChild(const QString& String) = 0;         
        virtual void Write_endl_Child() = 0;                        
    };
 
    class QSerialCommunicationHardwareAdapter : public QObject, public SerialCommunicationHardwareAdapter
    {
        Q_OBJECT
 
    private:
        class QSerialCommunicationHardwareAdapterWorkerOnlyType
        {
            friend class QSerialCommunicationHardwareAdapter;
            friend class QSerialCommunicationHardwareAdapterWorker;
 
            constexpr QSerialCommunicationHardwareAdapterWorkerOnlyType(QSerialCommunicationHardwareAdapter& Parent) noexcept : Parent(Parent) {}
 
            void SetCommunicationChannelOpened() const noexcept { Parent.SetCommunicationChannelOpened(); }     
            void SetCommunicationChannelClosed() const noexcept { Parent.SetCommunicationChannelClosed(); }     
            void DataRead(const std::string& String) const { Parent.DataRead(String); }                         
 
            template <typename ExceptionType>
            void SetException(const ExceptionType& Exception) const { Parent.SetException(Exception); }
 
            QSerialCommunicationHardwareAdapter& Parent;            
        };
 
    public:
        using ParamsType = QSerialCommunicationHardwareAdapterParams;                                           
        using ConfigType = QSerialCommunicationHardwareAdapterConfigurator;                                     
        using QWorkerPtrType = std::unique_ptr<QSerialCommunicationHardwareAdapterWorker>;                      
 
        QSerialCommunicationHardwareAdapter(const std::thread::id OwnerThreadID, ParamsBasePtrType&& Params);   
        virtual ~QSerialCommunicationHardwareAdapter() = 0;
 
        QSerialCommunicationHardwareAdapterWorkerOnlyType QSerialCommunicationHardwareAdapterWorkerOnly;        
 
    private:
 
        virtual QWorkerPtrType MakeWorker() = 0;
 
        virtual void InitWorker() {}
 
        void ResetImpl(dispatch_tag<SerialCommunicationHardwareAdapter>) override final;
        virtual void ResetImpl(dispatch_tag<QSerialCommunicationHardwareAdapter>) {}                            
 
        void EnsureReadyStateChild() override final;
 
        bool IsReadyChild() const override final;
        bool IsConnectedChild() const noexcept override final;
 
        void SetCommunicationChannelOpened() const noexcept { CommunicationChannelOpened = true; }              
        void SetCommunicationChannelClosed() const noexcept { CommunicationChannelOpened = false; }             
 
        void DataRead(const std::string& String) const;
 
        template <typename ExceptionType>
        void SetException(const ExceptionType& Exception) const noexcept
        {
            try
            {
                auto lock = AcquireLock(HardwareOperationTimeout);
 
                auto ExceptionPtr = std::make_exception_ptr(Exception);
                SetExceptionUnsafe(ExceptionPtr);
                PendingException = ExceptionPtr;
            }
            catch (...)
            {
                // Swallow exception if an error occurs setting it. This is not optimal but there
                // is no other way since exceptions are not allowed to leave Qt's slots.
            }
        }
 
        void ClearChild() const override final;
        void FlushChild() const override final;
        std::string Read() const override final;
        void Write(const std::string& String) const override final;
        void Write_endl() const override final;
 
        void ThrowPendingException() const;
 
    signals:
        void OpenSig();                                             
        void CloseSig();                                            
        void ResetSig();                                            
        void ClearSig() const;                                      
        void FlushSig() const;                                      
        void ReadSig() const;                                       
        void WriteSig(const QString String) const;                  
        void Write_endl_Sig() const;                                
 
    private:
        QSerialCommunicationHardwareAdapterWorker* Worker;          
        mutable std::atomic<bool> CommunicationChannelOpened;       
        mutable std::exception_ptr PendingException;                
    };
 
    // Needs to be defined after declaration of class QSerialCommunicationHardwareAdapter.
    template <typename ExceptionType>
    void QSerialCommunicationHardwareAdapterWorker::SetException(const ExceptionType& Exception) const
    {
        auto Owner = std::dynamic_pointer_cast<const QSerialCommunicationHardwareAdapter>(GetOwner());
        if (!Owner)
            return;
 
        Owner->QSerialCommunicationHardwareAdapterWorkerOnly.SetException(Exception);
    }
}
 
namespace DynExpHardware {};