DynExpCore.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include "stdafx.h"
#include "Libraries.h"
#include "Managers.h"
 
namespace DynExp
{
    class ProjectParams final : public ParamsBase
    {
        friend class DynExpCore;
 
    public:
        enum StoreWindowStatesType { ApplyStoredWindowStates, ApplyDefaultWindowStates };
        static Util::TextValueListType<StoreWindowStatesType> AvlblStoreWindowStatesTypeStrList();
 
        ProjectParams(const DynExpCore& Core) : ParamsBase(0, Core),
            MainWindowStyleParams(*this, "Main"), CircuitWindowStyleParams(*this, "Circuit") {}
 
        ~ProjectParams() {}
 
        const char* GetParamClassTag() const noexcept override final { return "ProjectParams"; }
 
        Param<ParamsConfigDialog::TextType> Authors = { *this, "Authors", "Authors", "Name of the project's authors.", false };     
        Param<ParamsConfigDialog::TextType> Version = { *this, "Version", "Version", "Current version of the project.", false };    
        Param<ParamsConfigDialog::TextType> Comment = { *this, "Comment", "Comment", "Comments related to the project.", false };   
 
        Param<StoreWindowStatesType> StoreWindowStates = { *this, AvlblStoreWindowStatesTypeStrList(), "StoreWindowStates", "Remember window states",
            "Determines whether module windows' geometries and states are to be remembered when loading the project from file.",
            false, StoreWindowStatesType::ApplyStoredWindowStates };
 
        WindowStyleParamsExtension MainWindowStyleParams;
 
        WindowStyleParamsExtension CircuitWindowStyleParams;
 
        ListParam<int> HSplitterWidgetWidths = { *this, "HSplitterWidgetWidths", {}, 0 };
 
        ListParam<int> VSplitterWidgetHeights = { *this, "VSplitterWidgetHeights", {}, 0 };
 
    private:
        void ConfigureParamsImpl(dispatch_tag<ParamsBase>) override final;
 
 
        std::filesystem::path ProjectFilename;
 
        std::filesystem::path LastDataSaveDirectory;
    };
 
    class DynExpCore final : public Util::INonCopyable
    {
    public:
        using ParamsTypeSyncPtrType = Util::SynchronizedPointer<ProjectParams>;
 
        using ParamsConstTypeSyncPtrType = Util::SynchronizedPointer<const ProjectParams>;
 
        static constexpr std::chrono::milliseconds GetParamsTimeoutDefault = std::chrono::milliseconds(100);
 
        DynExpCore(HardwareAdapterLibraryVectorType HardwareAdapterLib, InstrumentLibraryVectorType InstrumentLib,
            ModuleLibraryVectorType ModuleLib, std::string ProjectFileToOpen = "");
        ~DynExpCore();
 
        void Shutdown();
 
        void Reset(bool Force = false);
 
        void SaveProject(std::string_view Filename, const QMainWindow& MainWindow, const QDialog& CircuitDiagramDlg, QSplitter& HSplitter, QSplitter& VSplitter);
 
        void OpenProject(std::string_view Filename);
        
        void EditProjectSettings(QWidget* const DialogParent);
 
        auto ConnectHardwareAdapters(CommonResourceManagerBase::FunctionToCallWhenObjectStartedType FunctionToCallWhenHardwareAdapterConnecting = nullptr)
        {
            return std::async(std::launch::async, &HardwareAdapterManager::Startup, &HardwareAdapterMgr, FunctionToCallWhenHardwareAdapterConnecting);
        }
 
        bool AllHardwareAdaptersConnected() const;
 
        bool AllInstrumentsInitialized() const;
 
        void RunInstruments(CommonResourceManagerBase::FunctionToCallWhenObjectStartedType FunctionToCallWhenInstrumentStarted = nullptr);
 
        void RunModules(CommonResourceManagerBase::FunctionToCallWhenObjectStartedType FunctionToCallWhenModuleStarted = nullptr);
 
        void ShutdownProject();
 
        void ResetFailedItems(QWidget& ParentWindow);
 
        void RestoreWindowStatesFromParams(QMainWindow& MainWindow, QDialog& CircuitDiagramDlg, QSplitter& HSplitter, QSplitter& VSplitter,
            bool OnlyMainWindow = false);
 
        auto& GetHardwareAdapterLib() const noexcept { return HardwareAdapterLib; }
 
        auto& GetInstrumentLib() const noexcept { return InstrumentLib; }
 
        auto& GetModuleLib() const noexcept { return ModuleLib; }
 
        auto& GetHardwareAdapterManager() noexcept { return HardwareAdapterMgr; }
 
        auto& GetInstrumentManager() noexcept { return InstrumentMgr; }
 
        auto& GetModuleManager() noexcept { return ModuleMgr; }
 
        auto& GetHardwareAdapterManager() const noexcept { return HardwareAdapterMgr; }     
        auto& GetInstrumentManager() const noexcept { return InstrumentMgr; }               
        auto& GetModuleManager() const noexcept { return ModuleMgr; }                       
 
        ItemIDType MakeItem(const LibraryEntry<HardwareAdapterPtrType>& LibEntry, ParamsBasePtrType&& Params);
        
        ItemIDType MakeItem(const LibraryEntry<InstrumentPtrType>& LibEntry, ParamsBasePtrType&& Params);
        
        ItemIDType MakeItem(const LibraryEntry<ModulePtrType>& LibEntry, ParamsBasePtrType&& Params);
 
        bool HasLoadedProjectFromCommandlineParams() noexcept;
 
 
        auto GetProjectFilename(const std::chrono::milliseconds Timeout = GetParamsTimeoutDefault) const { return GetParams(Timeout)->ProjectFilename; }
 
        auto GetLastDataSaveDirectory(const std::chrono::milliseconds Timeout = GetParamsTimeoutDefault) const { return GetParams(Timeout)->LastDataSaveDirectory; }
 
        bool IsProjectOpened(const std::chrono::milliseconds Timeout = GetParamsTimeoutDefault) const noexcept { return !GetProjectFilename(Timeout).empty(); }
 
        std::filesystem::path ToAbsolutePath(const std::filesystem::path& Path) const;
 
        ParamsConstTypeSyncPtrType GetParams(const std::chrono::milliseconds Timeout = GetParamsTimeoutDefault) const;
 
        const auto GetOwnerThreadID() const noexcept { return OwnerThreadID; }
 
        void MoveQWorkerToWorkerThread(Util::QWorker& Worker, ItemIDType ID) const;
 
        std::string GetDataSaveDirectory(const std::chrono::milliseconds Timeout = GetParamsTimeoutDefault) const;
 
        void SetDataSaveDirectory(const std::filesystem::path& Directory, const std::chrono::milliseconds Timeout = GetParamsTimeoutDefault);
 
    private:
        bool OpenProjectSafe(const std::string& Filename) noexcept;
 
        template <typename LibEntryT, typename ParamsT, typename ManagerT>
        ItemIDType MakeItem(const LibraryEntry<LibEntryT>& LibEntry, ParamsT&& Params, ManagerT& ResourceManager, const std::string ItemTypeName);
 
        ParamsTypeSyncPtrType GetParams(const std::chrono::milliseconds Timeout = GetParamsTimeoutDefault);
 
        void UpdateParamsFromWindowStates(const QMainWindow& MainWindow, const QDialog& CircuitDiagramDlg, QSplitter& HSplitter, QSplitter& VSplitter);
 
        const HardwareAdapterLibraryVectorType HardwareAdapterLib;  
        const InstrumentLibraryVectorType InstrumentLib;            
        const ModuleLibraryVectorType ModuleLib;                    
 
        HardwareAdapterManager HardwareAdapterMgr;                  
        InstrumentManager InstrumentMgr;                            
        ModuleManager ModuleMgr;                                    
 
        bool LoadedProjectFromCommandlineParams;
 
        std::unique_ptr<ProjectParams> Params;
 
        const std::thread::id OwnerThreadID;
 
        mutable QThread WorkerThread;
    };
 
    template <typename LibEntryT, typename ParamsT, typename ManagerT>
    ItemIDType DynExpCore::MakeItem(const LibraryEntry<LibEntryT>& LibEntry, ParamsT&& Params, ManagerT& ResourceManager, const std::string ItemTypeName)
    {
        auto Item = LibEntry.ObjectFactoryPtr(GetOwnerThreadID(), std::move(Params));
        auto ID = ResourceManager.InsertResource(std::move(Item));
        auto Res = ResourceManager.GetResource(ID);
 
        Util::EventLog().Log(ItemTypeName + " \"" + Res->GetParams()->ObjectName.Get()
            + "\" (" + Res->GetCategoryAndName() + ") has been created successfully.");
 
        return ID;
    }
}