Managers.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include "stdafx.h"
#include "HardwareAdapter.h"
#include "Instrument.h"
#include "Module.h"
 
namespace DynExp
{
    template <typename PointerType>
    struct Resource
    {
        template <typename ResourcePointerT>
        Resource(ResourcePointerT&& ResourcePointer)
            : ResourcePointer(std::forward<ResourcePointerT>(ResourcePointer)) {}
 
        PointerType ResourcePointer;    
 
        mutable std::unique_ptr<QTreeWidgetItem> TreeWidgetItem;
    };
 
    class CommonResourceManagerBase
    {
    public:
        using FunctionToCallWhenObjectStartedType = const std::function<void(Object* const)>;
 
    protected:
        CommonResourceManagerBase() = default;
        ~CommonResourceManagerBase() = default;
 
        static std::thread::id GetOwnerThreadID(const DynExpCore& Core) noexcept;
    };
 
    template <typename PointerType>
    class ResourceManagerBase : public CommonResourceManagerBase
    {
        class LinkBaseOnlyType
        {
            friend class ResourceManagerBase;
            friend class LinkBase;
 
            constexpr LinkBaseOnlyType(ResourceManagerBase& Parent) noexcept : Parent(Parent) {}
 
            auto ShareResourceAsNonConst(ItemIDType ID) const { return Parent.ShareResource(ID); }
 
            ResourceManagerBase& Parent;                                
        };
 
    public:
        using ResourceType = Resource<PointerType>;                     
 
    private:
        template <typename T>
        using ShareResourceEnablerType = std::enable_if_t<std::is_same_v<std::shared_ptr<typename T::element_type>, PointerType>, int>;
 
        using MapType = std::unordered_map<ItemIDType, ResourceType>;   
 
    protected:
        ResourceManagerBase() : LinkBaseOnly(*this) { Reset(); }
        ~ResourceManagerBase() = default;
 
    public:
        ItemIDType GetNextID() const noexcept { return CurrentID; }
 
        const auto GetNumResources() const noexcept { return Map.size(); }
 
        const bool Empty() const noexcept { return Map.empty(); }
 
        const typename PointerType::element_type* GetResource(ItemIDType ID) const;
 
        typename PointerType::element_type* GetResource(ItemIDType ID);
 
        PointerType ExtractResource(ItemIDType ID);
 
        void RemoveResource(ItemIDType ID, const std::chrono::milliseconds Timeout = Util::ILockable::DefaultTimeout);
 
        void DeleteTreeWidgetItem(ItemIDType ID);
 
        void FocusTreeWidgetItem(ItemIDType ID);
 
        template <typename T = PointerType, ShareResourceEnablerType<T> = 0>
        auto ShareResource(ItemIDType ID) const;
 
        template <typename T = PointerType, ShareResourceEnablerType<T> = 0>
        auto ShareResource(ItemIDType ID);
 
        auto cbegin() const noexcept { return Map.cbegin(); }
 
        auto cend() const noexcept { return Map.cend(); }
 
        template <typename ElementType>
        ItemIDType InsertResource(ElementType&& Element);
 
        template <typename DerivedType>
        ItemIDListType Filter() const;
 
        void Startup(FunctionToCallWhenObjectStartedType FunctionToCallWhenObjectStarted) const { StartupChild(FunctionToCallWhenObjectStarted); }
 
        void Shutdown() const { ShutdownChild(); }
 
        void ClearResourcesWarnings() const;
 
        ItemIDListType GetFailedResourceIDs(bool OnlyResourcesBeingInUse = false) const;
 
        void ResetFailedResources() const;
 
        void PrepareReset() { PrepareResetChild(); }
 
        void Reset();
 
        QDomElement EntryConfigsToXML(QDomDocument& Document) const;
 
        void DeleteAllTreeWidgetItems();
 
        template <typename LibraryVectorT>
        void MakeEntriesFromXML(const QDomElement& XMLNode, const LibraryVectorT& Library, const DynExpCore& Core);
 
        LinkBaseOnlyType LinkBaseOnly;      // !< @copydoc LinkBaseOnlyType
 
    private:
        auto LookUpResource(ItemIDType ID) const;
 
        template <typename ElementType>
        ItemIDType InsertResource(ElementType&& Element, const ItemIDType ID);
 
        void RaiseID(const ItemIDType ConsumedID);
 
        void IncrementID();
 
        virtual void StartupChild(FunctionToCallWhenObjectStartedType FunctionToCallWhenObjectStarted) const = 0;   
        virtual void ShutdownChild() const {}                                                                       
        virtual void PrepareResetChild() {}                                                                         
        virtual void ResetChild() {}                                                                                
 
        virtual QDomElement MakeXMLConfigHeadNode(QDomDocument& Document) const = 0;
 
        MapType Map;                
 
        ItemIDType CurrentID;
    };
 
    template <typename PointerType>
    const typename PointerType::element_type* ResourceManagerBase<PointerType>::GetResource(ItemIDType ID) const
    {   
        return LookUpResource(ID)->second.ResourcePointer.get();
    }
 
    template <typename PointerType>
    typename PointerType::element_type* ResourceManagerBase<PointerType>::GetResource(ItemIDType ID)
    {
        return LookUpResource(ID)->second.ResourcePointer.get();
    }
 
    template <typename PointerType>
    PointerType ResourceManagerBase<PointerType>::ExtractResource(ItemIDType ID)
    {
        auto Res = Map.extract(ID);
 
        if (Res.empty())
            throw Util::NotFoundException(
                "Resource with ID " + Util::ToStr(ID) + " cannot be extracted from a resource manager since it cannot be found.");
 
        return std::move(Res.mapped().ResourcePointer);
    }
 
    template <typename PointerType>
    void ResourceManagerBase<PointerType>::RemoveResource(ItemIDType ID, const std::chrono::milliseconds Timeout)
    {
        GetResource(ID)->BlockIfUnused(Timeout);
 
        // Postpone calling destructor of managed resource to the end of this function and remove
        // from map first. Destructor of managed resource might cause iterating throup map (in
        // case of modules in DynExpManager::GetModuleByActiveUIWindow() when the module's
        // respective QMdiSubWindow is destroyed). An iteration must not happen while erasing
        // from the map is in progress.
        auto Resource = ExtractResource(ID);
    }
 
    template <typename PointerType>
    void ResourceManagerBase<PointerType>::DeleteTreeWidgetItem(ItemIDType ID)
    {
        LookUpResource(ID)->second.TreeWidgetItem.reset();
    }
 
    template <typename PointerType>
    void ResourceManagerBase<PointerType>::FocusTreeWidgetItem(ItemIDType ID)
    {
        try
        {
            auto const TreeWidgetItem = LookUpResource(ID)->second.TreeWidgetItem.get();
 
            // Assuming, all other items have already been deselectd. Now, select chosen one.
            if (TreeWidgetItem)
                TreeWidgetItem->setSelected(true);
        }
        catch (...) // Swallow especially Util::NotFoundException.
        {
        }
    }
 
    template <typename PointerType>
    template <typename T, ResourceManagerBase<PointerType>::ShareResourceEnablerType<T>>
    auto ResourceManagerBase<PointerType>::ShareResource(ItemIDType ID) const
    {
        return std::static_pointer_cast<const typename PointerType::element_type>(LookUpResource(ID)->second.ResourcePointer);
    }
 
    template <typename PointerType>
    template <typename T, ResourceManagerBase<PointerType>::ShareResourceEnablerType<T>>
    auto ResourceManagerBase<PointerType>::ShareResource(ItemIDType ID)
    {
        return LookUpResource(ID)->second.ResourcePointer;
    }
 
    template <typename PointerType>
    template <typename ElementType>
    ItemIDType ResourceManagerBase<PointerType>::InsertResource(ElementType&& Element)
    {
        return InsertResource(std::forward<ElementType>(Element), GetNextID());
    }
 
    template <typename PointerType>
    template <typename DerivedType>
    ItemIDListType ResourceManagerBase<PointerType>::Filter() const
    {
        ItemIDListType FoundIDs;
 
        for (const auto& ResourceEntry : Map)
            if (dynamic_cast<DerivedType*>(ResourceEntry.second.ResourcePointer.get()))
                FoundIDs.push_back(ResourceEntry.first);
 
        return FoundIDs;
    }
 
    template <typename PointerType>
    void ResourceManagerBase<PointerType>::ClearResourcesWarnings() const
    {
        std::for_each(cbegin(), cend(), [](const auto& i) {
            i.second.ResourcePointer->ClearWarning();
        });
    }
 
    template <typename PointerType>
    ItemIDListType ResourceManagerBase<PointerType>::GetFailedResourceIDs(bool OnlyResourcesBeingInUse) const
    {
        ItemIDListType FoundIDs;
 
        std::for_each(cbegin(), cend(), [&FoundIDs, OnlyResourcesBeingInUse](const auto& i) {
            if (i.second.ResourcePointer->GetException() && (!OnlyResourcesBeingInUse || !i.second.ResourcePointer->IsUnused()))
                FoundIDs.push_back(i.first);
        });
 
        return FoundIDs;
    }
 
    template <typename PointerType>
    void ResourceManagerBase<PointerType>::ResetFailedResources() const
    {
        std::for_each(cbegin(), cend(), [](const auto& i) {
            if (i.second.ResourcePointer->GetException())
                i.second.ResourcePointer->Reset();
        });
    }
 
    template <typename PointerType>
    void ResourceManagerBase<PointerType>::Reset()
    {
        ResetChild();
 
        Map.clear();
        CurrentID = 1;  // Start with 1, so that 0 can have a special meaning (e.g. "not set").
    }
 
    template <typename PointerType>
    QDomElement ResourceManagerBase<PointerType>::EntryConfigsToXML(QDomDocument& Document) const
    {
        auto XMLNode = MakeXMLConfigHeadNode(Document);
 
        std::for_each(cbegin(), cend(), [&XMLNode, &Document](const auto& i) {
            QDomElement ItemNode = Document.createElement("Item");
            ItemNode.setAttribute(QString("Name"), QString::fromStdString(i.second.ResourcePointer->GetName()));
            ItemNode.setAttribute(QString("Category"), QString::fromStdString(i.second.ResourcePointer->GetCategory()));
            ItemNode.setAttribute(QString("ID"), static_cast<qulonglong>(i.first));
 
            // GetParams() locks the parameters to save. So this is thread-safe.
            QDomElement ParamsNode = Document.createElement("Params");
            ParamsNode.appendChild(i.second.ResourcePointer->GetParams()->ConfigToXML(Document));
            ItemNode.appendChild(ParamsNode);
 
            XMLNode.appendChild(ItemNode);
        });
        
        return XMLNode;
    }
 
    template <typename PointerType>
    void ResourceManagerBase<PointerType>::DeleteAllTreeWidgetItems()
    {
        std::for_each(cbegin(), cend(), [](const auto& i) { i.second.TreeWidgetItem.reset(); });
    }
 
    template <typename PointerType>
    template <typename LibraryVectorT>
    void ResourceManagerBase<PointerType>::MakeEntriesFromXML(const QDomElement& XMLNode, const LibraryVectorT& Library, const DynExpCore& Core)
    {
        auto ItemNodeList = XMLNode.elementsByTagName("Item");
        for (int i = 0; i < ItemNodeList.length(); ++i)
        {
            auto ItemNode = ItemNodeList.item(i).toElement();
            if (ItemNode.isNull())
                throw Util::InvalidDataException(
                    "Error parsing the specified project file. An item node contains invalid data.");
 
            auto ItemCategory = Util::GetStringFromDOMAttribute(ItemNode, "Category");
            auto ItemName = Util::GetStringFromDOMAttribute(ItemNode, "Name");
            auto ItemID = Util::GetTFromDOMAttribute<ItemIDType>(ItemNode, "ID");
            auto ParamsNode = Util::GetSingleChildDOMElement(ItemNode, "Params");
 
            auto LibEntry = FindInLibraryVector(Library, ItemCategory, ItemName);
            auto Params = LibEntry.ConfigFactoryPtr()->MakeConfigFromXML(ItemID, Core, ParamsNode);
            auto Item = LibEntry.ObjectFactoryPtr(GetOwnerThreadID(Core), std::move(Params));
 
            InsertResource(std::move(Item), ItemID);
        }
    }
 
    template <typename PointerType>
    auto ResourceManagerBase<PointerType>::LookUpResource(ItemIDType ID) const
    {
        auto Iter = Map.find(ID);
 
        if (Iter == Map.cend())
            throw Util::NotFoundException("Resource with ID " + Util::ToStr(ID) + " cannot be found.");
 
        return Iter;
    }
 
    template <typename PointerType>
    template <typename ElementType>
    ItemIDType ResourceManagerBase<PointerType>::InsertResource(ElementType&& Element, const ItemIDType ID)
    {
        if (!ID)
            throw Util::InvalidArgException(
                "Resource cannot be inserted into a resource manager since 0 is not a valid ID.");
 
        auto Result = Map.try_emplace(ID, ResourceType(std::forward<ElementType>(Element)));
        if (!Result.second)
            throw Util::InvalidStateException(
                "Resource cannot be inserted into a resource manager since the chosen ID already exists.");
 
        RaiseID(ID);
 
        return ID;
    }
 
    template <typename PointerType>
    void ResourceManagerBase<PointerType>::RaiseID(const ItemIDType ConsumedID)
    {
        if (CurrentID < ConsumedID)
            CurrentID = ConsumedID;
 
        if (CurrentID == ConsumedID)
            IncrementID();
    }
 
    template <typename PointerType>
    void ResourceManagerBase<PointerType>::IncrementID()
    {
        if (CurrentID == std::numeric_limits<ItemIDType>::max())
            throw Util::OverflowException("No ID left to insert a resource into a resource manager.");
 
        ++CurrentID;
    }
 
    class HardwareAdapterManager : public ResourceManagerBase<HardwareAdapterPtrType>
    {
    public:
        using ResourceType = Resource<HardwareAdapterPtrType>;      
 
        HardwareAdapterManager() = default;
        ~HardwareAdapterManager() = default;
 
        bool AllConnected() const;
 
    private:
        virtual void StartupChild(FunctionToCallWhenObjectStartedType FunctionToCallWhenObjectStarted) const override;
        virtual QDomElement MakeXMLConfigHeadNode(QDomDocument& Document) const override;
    };
 
    class InstrumentManager : public ResourceManagerBase<InstrumentPtrType>
    {
    public:
        using ResourceType = Resource<InstrumentPtrType>;           
 
        InstrumentManager() = default;
        ~InstrumentManager() = default;
 
        size_t GetNumRunningInstruments() const;
 
        bool AllInitialized() const;
 
        void TerminateAll() const;
 
    private:
        virtual void StartupChild(FunctionToCallWhenObjectStartedType FunctionToCallWhenObjectStarted) const override;
        virtual void ShutdownChild() const override { TerminateAll(); }
        virtual void PrepareResetChild() override { TerminateAll(); }
        virtual QDomElement MakeXMLConfigHeadNode(QDomDocument& Document) const override;
    };
 
    class ModuleManager : public ResourceManagerBase<ModulePtrType>
    {
    public:
        using ResourceType = Resource<ModulePtrType>;               
 
        ModuleManager() = default;
        ~ModuleManager() = default;
 
        size_t GetNumRunningModules() const;
 
        void TerminateAll() const;
 
        void RestoreWindowStatesFromParams() const;
 
        void UpdateParamsFromWindowStates() const;
 
    private:
        virtual void StartupChild(FunctionToCallWhenObjectStartedType FunctionToCallWhenObjectStarted) const override;
        virtual void ShutdownChild() const override { TerminateAll(); }
        virtual void PrepareResetChild() override { TerminateAll(); }
        virtual QDomElement MakeXMLConfigHeadNode(QDomDocument& Document) const override;
    };
}