Object.h

Go to the documentation of this file.

// This file is part of DynExp.
 
#pragma once
 
#include "stdafx.h"
#include "BusyDialog.h"
#include "ParamsConfig.h"
 
class DynExpManager;
 
namespace DynExp
{
    class DynExpCore;
    class Object;
    class RunnableObject;
    class LinkedObjectWrapperContainerBase;
    class ObjectLinkBase;
    class RunnableInstance;
    class HardwareAdapterBase;
    class InstrumentBase;
    class ModuleBase;
    class CommonResourceManagerBase;
    class HardwareAdapterManager;
    class InstrumentManager;
    class ModuleManager;
    class NetworkParamsExtension;
 
    template <typename>
    class ObjectLink;
 
    using ItemIDListType = std::vector<ItemIDType>;
 
    template <
        typename ObjectType,
        std::enable_if_t<
            std::is_base_of_v<HardwareAdapterBase, ObjectType> || std::is_base_of_v<InstrumentBase, ObjectType>,
        int> = 0
    >
    struct ManagerTypeOfObjectType
    {
        using type = std::conditional_t<
            std::is_base_of_v<HardwareAdapterBase, ObjectType>,
            HardwareAdapterManager,
            InstrumentManager
        >;
    };
 
    template <typename ObjectType>
    using ManagerTypeOfObjectType_t = typename ManagerTypeOfObjectType<ObjectType>::type;
 
    class ObjectUserList : public Util::ILockable
    {
    public:
        ObjectUserList() = default;
        virtual ~ObjectUserList() = default;
 
        [[nodiscard]] Util::ILockable::LockType AcquireLock(const std::chrono::milliseconds Timeout = DefaultTimeout) const;
 
        void Register(const Object& User, const std::chrono::milliseconds Timeout = std::chrono::milliseconds(0));
 
        LockType Register(const Object& User, LockType&& Lock);
        
        void Deregister(const Object& User, const std::chrono::milliseconds Timeout = std::chrono::milliseconds(0));
 
        size_t CountUsers(std::chrono::milliseconds Timeout = std::chrono::milliseconds(0)) const;
 
        ItemIDListType GetUserIDs(std::chrono::milliseconds Timeout = std::chrono::milliseconds(0)) const;
 
        std::string GetUserNamesString(std::chrono::milliseconds Timeout = std::chrono::milliseconds(0)) const;
 
 
        void DeregisterAllUnsafe();
 
        size_t CountUsersUnsafe() const;
        ItemIDListType GetUserIDsUnsafe() const;
        std::string GetUserNamesStringUnsafe() const;
 
    private:
 
        void RegisterUnsafe(const Object& User);
 
        void DeregisterUnsafe(const Object& User);
 
        std::unordered_map<const Object*, size_t> UserList;
    };
 
    class LinkBase
    {
    public:
        LinkBase(std::string_view IconResourcePath = {}, bool Optional = false)
            : IconResourcePath(IconResourcePath), Optional(Optional) {}
 
    protected:
        virtual ~LinkBase() {}
 
        template <typename ResourceManagerType>
        auto ShareResource(const ResourceManagerType& Manager, ItemIDType ID) { return Manager.LinkBaseOnly.ShareResourceAsNonConst(ID); }
 
        template <typename ObjectType>
        auto MakeObjectIDsWithLabels(const ManagerTypeOfObjectType_t<ObjectType>& Manager) const
        {
            // template disambiguator (see ISO C++03 14.2/4)
            auto FoundIDs = Manager.template Filter<ObjectType>();
            if (FoundIDs.empty() && !IsOptional())
            {
                constexpr auto FilterTypeBaseName = std::is_base_of_v<HardwareAdapterBase, ObjectType> ? "hardware adapter" :
                    (std::is_base_of_v<InstrumentBase, ObjectType> ? "instrument" : "< error-type >");
 
                throw Util::EmptyException("At least one " + std::string(FilterTypeBaseName) + " of type " +
                    ObjectType::CategoryAndNameToStr(ObjectType::Category(), ObjectType::Name()) + " is needed before this item can be created.");
            }
 
            std::sort(FoundIDs.begin(), FoundIDs.end(), [&Manager](const auto& a, const auto& b) {
                return Manager.GetResource(a)->GetObjectName() < Manager.GetResource(b)->GetObjectName();
            });
 
            Util::TextValueListType<typename ParamsConfigDialog::IndexType> FoundIDsWithLabels;
            for (const auto& ID : FoundIDs)
            {
                const auto Resource = Manager.GetResource(ID);
                std::string Label = Resource->GetObjectName() + " (" + Resource->GetCategoryAndName() + ")";
 
                FoundIDsWithLabels.emplace_back(std::move(Label), ID);
            }
 
            return FoundIDsWithLabels;
        }
 
    public:
        std::string_view GetIconResourcePath() const noexcept { return IconResourcePath; }
        bool IsOptional() const noexcept { return Optional; }
 
        void EnsureReadyState() { EnsureReadyStateChild(); }
 
        bool IsReady() { return IsReadyChild(); }
 
        std::string_view GetLinkTitle() const noexcept { return GetLinkTitleChild(); }
 
        ItemIDListType GetLinkedIDs() const { return GetLinkedIDsChild(); }
 
        const CommonResourceManagerBase* GetCommonManager() const noexcept { return GetCommonManagerChild(); }
 
    private:
        virtual void EnsureReadyStateChild() = 0;                                               
        virtual bool IsReadyChild() = 0;                                                        
 
        virtual std::string_view GetLinkTitleChild() const noexcept = 0;                        
        virtual ItemIDListType GetLinkedIDsChild() const = 0;                                   
        virtual const CommonResourceManagerBase* GetCommonManagerChild() const noexcept = 0;    
 
        const std::string_view IconResourcePath;
 
        const bool Optional;
    };
 
    class ParamsBase : public Util::ISynchronizedPointerLockable
    {
    private:
        struct OwnedParamInfo;
 
        using OwnedParamsType = std::vector<OwnedParamInfo>;
 
    protected:
        template <typename>
        struct dispatch_tag {};
 
    public:
        using ObjectLinkParamsType = std::vector<std::reference_wrapper<LinkBase>>; 
        using EnumParamSignedIntegerType = intmax_t;                                
        using EnumParamUnsignedIntegerType = uintmax_t;                             
 
        template <typename EnumType>
        using LargestEnumUnderlyingType = std::conditional_t<
            std::is_signed_v<std::underlying_type_t<EnumType>>,
            EnumParamSignedIntegerType,
            EnumParamUnsignedIntegerType
        >;
 
        using Text = Util::TextType;    
        class TextList {};              
        class IndexedTextList {};       
 
        class ParamBase
        {
        private:
            class ParamsBaseOnlyType
            {
                friend class ParamsBase;
 
                constexpr ParamsBaseOnlyType(ParamBase& Parent) noexcept : Parent(Parent) {}
 
                void DisableUserEditable() noexcept { Parent.DisableUserEditable(); }           
                void AddToDialog(ParamsConfigDialog& Dialog) { Parent.AddToDialog(Dialog); }    
 
                ParamBase& Parent;                                                              
            };
 
        protected:
            ParamBase(ParamsBase& Owner, std::string ParamName, std::string_view ParamTitle, std::string_view ParamDescription, bool NeedsResetToApplyChange);
 
            ParamBase(ParamsBase& Owner, std::string ParamName);
            
            virtual ~ParamBase() = 0;
 
        public:
            ParamBase(const ParamBase&) = delete;
            ParamBase& operator=(const ParamBase&) = delete;
 
            bool IsUserEditable() const noexcept { return UserEditable; }                           
            std::string_view GetParamName() const noexcept { return ParamName; }                    
            std::string_view GetParamTitle() const noexcept { return ParamTitle; }                  
            std::string_view GetParamDescription() const noexcept { return ParamDescription; }      
            bool GetNeedsResetToApplyChange() const noexcept { return NeedsResetToApplyChange; }    
 
            QDomElement ToXMLNode(QDomDocument& Document) const;
 
            void FromXMLNode(const QDomElement& XMLElement);
 
            bool Validate();
            
            void Reset() { ResetChild(); }
 
            ParamsBaseOnlyType ParamsBaseOnly;                      
 
        protected:
            const auto& GetOwner() const noexcept { return Owner; } 
            auto& GetOwner() noexcept { return Owner; }             
 
        private:
            void DisableUserEditable() noexcept { UserEditable = false; }
 
            void AddToDialog(ParamsConfigDialog& Dialog) { AddToDialogChild(Dialog); }
 
 
            virtual void ToXMLNodeChild(QDomDocument& Document, QDomElement& XMLElement) const = 0;
 
            virtual void FromXMLNodeChild(const QDomElement& XMLElement) = 0;                       
            virtual void AddToDialogChild(ParamsConfigDialog& Dialog) = 0;                          
            virtual bool ValidateChild() const { return true; }                                     
            virtual void ResetChild() = 0;                                                          
 
            ParamsBase& Owner;
 
            bool UserEditable;
 
            const std::string ParamName;                
            const std::string_view ParamTitle;          
            const std::string_view ParamDescription;    
 
            const bool NeedsResetToApplyChange;
        };
 
        class DummyParam : public ParamBase
        {
        public:
            DummyParam(ParamsBase& Owner) : ParamBase(Owner, "") {}
 
        private:
            virtual void ToXMLNodeChild(QDomDocument& Document, QDomElement& XMLElement) const override {}
            virtual void FromXMLNodeChild(const QDomElement& XMLElement) override {}
            virtual void AddToDialogChild(ParamsConfigDialog& Dialog) override {}
            virtual void ResetChild() override {}
        };
 
        template <typename ParamType>
        class TypedParamBase : public ParamBase
        {
        public:
            using UnderlyingType = ParamType;
 
        protected:
            TypedParamBase(ParamsBase& Owner, std::string ParamName, std::string_view ParamTitle, std::string_view ParamDescription,
                bool NeedsResetToApplyChange = true, ParamType DefaultValue = ParamType())
                : ParamBase(Owner, ParamName, ParamTitle, ParamDescription, NeedsResetToApplyChange),
                DefaultValue(std::move(DefaultValue)), Value(this->DefaultValue) {}
 
            TypedParamBase(ParamsBase& Owner, std::string ParamName, ParamType DefaultValue = ParamType())
                : ParamBase(Owner, ParamName),
                DefaultValue(std::move(DefaultValue)), Value(this->DefaultValue) {}
 
        public:
            ParamType GetDefaultValue() const noexcept { return DefaultValue; }
 
            operator ParamType() const noexcept { return Value; }
 
            const ParamType& Get() const noexcept { return Value; }
 
            const ParamType& operator=(const ParamType& NewValue)
            {
                if (!ValidateValue(NewValue))
                    throw Util::InvalidArgException(
                        "An assignment to a parameter cannot be executed since the given value is considered invalid.");
 
                Value = NewValue;
                return Get();
            }
 
        protected:
            virtual void ToXMLNodeChild(QDomDocument& Document, QDomElement& XMLElement) const override
            {
                QDomText NodeValue = Document.createTextNode(QString::fromStdString(Util::ToStr(Value)));
                XMLElement.appendChild(NodeValue);
            }
 
            virtual void FromXMLNodeChild(const QDomElement& XMLElement) override
            {
                Value = Util::GetTFromDOMElement<ParamType>(XMLElement, GetParamName().data());
            }
 
        private:
            virtual bool ValidateChild() const override final { return ValidateValue(Value); }
            
            virtual bool ValidateValue(const ParamType& NewValue) const { return true; }
            
            virtual void ResetChild() override { Value = DefaultValue; }
 
            const ParamType DefaultValue;   
            ParamType Value;                
        };
 
        template <typename ParamType>
        class TypedListParamBase : public ParamBase
        {
        public:
            using UnderlyingType = std::vector<ParamType>;
 
        protected:
            TypedListParamBase(ParamsBase& Owner, std::string ParamName, std::string_view ParamTitle, std::string_view ParamDescription,
                bool NeedsResetToApplyChange = true, UnderlyingType DefaultValues = {})
                : ParamBase(Owner, ParamName, ParamTitle, ParamDescription, NeedsResetToApplyChange),
                DefaultValues(std::move(DefaultValues)), Values(this->DefaultValues) {}
 
            TypedListParamBase(ParamsBase& Owner, std::string ParamName, UnderlyingType DefaultValues = {})
                : ParamBase(Owner, ParamName),
                DefaultValues(std::move(DefaultValues)), Values(this->DefaultValues) {}
 
        public:
            const auto& GetDefaultValue() const noexcept { return DefaultValues; }
 
            const auto& Get() const noexcept { return Values; }
 
            auto& operator=(const UnderlyingType& NewValues)
            {
                if (!ValidateValues(NewValues))
                    throw Util::InvalidArgException(
                        "An assignment to a list parameter cannot be executed since the given value vector is considered invalid.");
 
                Values = NewValues;
                return Get();
            }
 
        protected:
            virtual void ToXMLNodeChild(QDomDocument& Document, QDomElement& XMLElement) const override
            {
                QDomElement ValuesNode = Document.createElement("Values");
 
                for (const auto& value : Values)
                {
                    QDomElement ValueNode = Document.createElement("v");
                    QDomText NodeValue = Document.createTextNode(QString::fromStdString(Util::ToStr(value)));
 
                    ValueNode.appendChild(NodeValue);
                    ValuesNode.appendChild(ValueNode);
                }
 
                XMLElement.appendChild(ValuesNode);
            }
 
            virtual void FromXMLNodeChild(const QDomElement& XMLElement) override
            {
                QDomElement ValuesNode;
 
                try
                {
                    auto ParamNode = Util::GetSingleChildDOMElement(XMLElement, GetParamName().data());
                    ValuesNode = Util::GetSingleChildDOMElement(ParamNode, "Values");
                }
                catch ([[maybe_unused]] const Util::NotFoundException& e)
                {
                    // Assume that a single value is assigned to the parameter (if it has been converted to a list parameter later on).
                    const auto Value = Util::GetTFromDOMElement<ParamType>(XMLElement, GetParamName().data());
 
                    Values.clear();
                    Values.push_back(Value);
 
                    return;
                }
 
                auto ValueNodes = Util::GetChildDOMNodes(ValuesNode, "v");
 
                Values.clear();
                for (const auto& value : ValueNodes)
                    Values.push_back(Util::StrToT<ParamType>(value.toElement().text().toStdString()));
            }
 
        private:
            virtual bool ValidateChild() const override final { return ValidateValues(Values); }
 
            virtual bool ValidateValues(const UnderlyingType& NewValues) const { return true; }
            
            virtual void ResetChild() override { Values = DefaultValues; }
 
            const UnderlyingType DefaultValues;     
            UnderlyingType Values;                  
        };
 
        template <typename ParamType, typename = void>
        class Param;
 
        template <typename ParamType>
        class Param<ParamType,
            std::enable_if_t<
                !std::is_arithmetic_v<ParamType> &&
                !std::is_base_of_v<Text, ParamType> &&
                !std::is_base_of_v<TextList, ParamType> &&
                !std::is_base_of_v<IndexedTextList, ParamType> &&
                !std::is_enum_v<ParamType> &&
                !std::is_base_of_v<ObjectLinkBase, ParamType>
            >>
            : public TypedParamBase<ParamType>
        {
        public:
            using TypedParamBase<ParamType>::operator=;
 
            Param(ParamsBase& Owner, std::string ParamName, std::string_view ParamTitle, std::string_view ParamDescription, bool NeedsResetToApplyChange = true,
                ParamType DefaultValue = ParamType())
                : TypedParamBase<ParamType>(Owner, ParamName, ParamTitle, ParamDescription, NeedsResetToApplyChange, std::move(DefaultValue)) {}
            
            Param(ParamsBase& Owner, std::string ParamName, ParamType DefaultValue = ParamType())
                : TypedParamBase<ParamType>(Owner, ParamName, std::move(DefaultValue)) {}
 
        private:
            virtual void AddToDialogChild(ParamsConfigDialog& Dialog) override final
            {
                throw Util::NotImplementedException(
                    "A general (unspecified) parameter cannot be added to a settings dialog.");
            }
        };
 
        template <typename ArithmeticType>
        using UnderlyingArithmeticParamType = TypedParamBase<ArithmeticType>;
 
        template <typename ArithmeticType>
        class Param<ArithmeticType, std::enable_if_t<std::is_arithmetic_v<ArithmeticType>>> : public UnderlyingArithmeticParamType<ArithmeticType>
        {
        public:
            using PrecisionType = unsigned short;
            using UnderlyingArithmeticParamType<ArithmeticType>::operator=;
 
            Param(ParamsBase& Owner, std::string ParamName, std::string_view ParamTitle, std::string_view ParamDescription, bool NeedsResetToApplyChange = true,
                ArithmeticType DefaultValue = ArithmeticType(),
                ArithmeticType MinValue = std::numeric_limits<ArithmeticType>::lowest(), ArithmeticType MaxValue = std::numeric_limits<ArithmeticType>::max(),
                ArithmeticType Increment = 1, PrecisionType Precision = 0)
                : UnderlyingArithmeticParamType<ArithmeticType>(Owner, ParamName, ParamTitle, ParamDescription, NeedsResetToApplyChange, std::move(DefaultValue)),
                MinValue(MinValue), MaxValue(MaxValue), Increment(Increment), Precision(Precision) {}
            
            Param(ParamsBase& Owner, std::string ParamName, ArithmeticType DefaultValue = ArithmeticType(),
                ArithmeticType MinValue = std::numeric_limits<ArithmeticType>::lowest(), ArithmeticType MaxValue = std::numeric_limits<ArithmeticType>::max(),
                ArithmeticType Increment = 1, PrecisionType Precision = 0)
                : UnderlyingArithmeticParamType<ArithmeticType>(Owner, ParamName, std::move(DefaultValue)),
                MinValue(MinValue), MaxValue(MaxValue), Increment(Increment), Precision(Precision) {}
 
            ArithmeticType GetMinValue() const noexcept { return MinValue; }    
            ArithmeticType GetMaxValue() const noexcept { return MaxValue; }    
            ArithmeticType GetIncrement() const noexcept { return Increment; }  
            PrecisionType GetPrecision() const noexcept { return Precision; }   
 
            explicit operator bool() const { return UnderlyingArithmeticParamType<ArithmeticType>::Get() != 0; }
 
        private:
            virtual void AddToDialogChild(ParamsConfigDialog& Dialog) override final
            {
                Dialog.AddParam({ ParamBase::GetParamTitle(), ParamBase::GetParamDescription() }, std::ref(*static_cast<UnderlyingArithmeticParamType<ArithmeticType>*>(this)),
                    UnderlyingArithmeticParamType<ArithmeticType>::Get(), MinValue, MaxValue, Precision, Increment);
            }
 
            virtual bool ValidateValue(const ArithmeticType& Value) const override
            {
                return Value >= MinValue && Value <= MaxValue;
            }
 
            const ArithmeticType MinValue;  
            const ArithmeticType MaxValue;  
            const ArithmeticType Increment; 
            const PrecisionType Precision;  
        };
 
        using UnderlyingTextParamType = TypedParamBase<Util::TextType>;
 
        template <typename ParamType>
        class Param<ParamType, std::enable_if_t<std::is_base_of_v<Text, ParamType>>> : public UnderlyingTextParamType
        {
        public:
            using UnderlyingTextParamType::operator=;
 
            Param(ParamsBase& Owner, std::string ParamName, std::string_view ParamTitle,
                std::string_view ParamDescription, bool NeedsResetToApplyChange = true, UnderlyingTextParamType::UnderlyingType DefaultValue = "",
                TextUsageType TextUsage = TextUsageType::Standard)
                : UnderlyingTextParamType(Owner, ParamName, ParamTitle, ParamDescription, NeedsResetToApplyChange, DefaultValue), TextUsage(TextUsage) {}
            
            Param(ParamsBase& Owner, std::string ParamName, UnderlyingTextParamType::UnderlyingType DefaultValue = "")
                : UnderlyingTextParamType(Owner, ParamName, DefaultValue), TextUsage(TextUsageType::Standard) {}
 
            std::filesystem::path GetPath() const { return GetOwner().ToAbsolutePath(Get()); }
 
            auto GetTextUsage() const noexcept { return TextUsage; }    
 
        private:
            TextUsageType TextUsage;                                    
 
            virtual void AddToDialogChild(ParamsConfigDialog& Dialog) override final
            {
                Dialog.AddParam({ ParamBase::GetParamTitle(), ParamBase::GetParamDescription() }, std::ref(*static_cast<UnderlyingTextParamType*>(this)), Get(), TextUsage);
            }
        };
 
        using UnderlyingTextListParamType = TypedParamBase<Util::TextType>;
 
        template <typename ParamType>
        class Param<ParamType, std::enable_if_t<std::is_base_of_v<TextList, ParamType>>> : public UnderlyingTextListParamType
        {
        public:
            using UnderlyingTextListParamType::operator=;
 
            Param(ParamsBase& Owner, Util::TextListType&& TextList, std::string ParamName, std::string_view ParamTitle,
                std::string_view ParamDescription, bool NeedsResetToApplyChange = true, UnderlyingTextListParamType::UnderlyingType DefaultValue = "")
                : UnderlyingTextListParamType(Owner, ParamName, ParamTitle, ParamDescription, NeedsResetToApplyChange, DefaultValue),
                TextList(std::move(TextList)) {}
            
            Param(ParamsBase& Owner, Util::TextListType&& TextList, std::string ParamName,
                UnderlyingTextListParamType::UnderlyingType DefaultValue = "")
                : UnderlyingTextListParamType(Owner, ParamName, DefaultValue),
                TextList(std::move(TextList)) {}
 
            const auto& GetTextList() const noexcept { return TextList; }   
    
 
            void SetTextList(Util::TextListType&& NewTextList) { TextList = std::move(NewTextList); }
 
        private:
            virtual void AddToDialogChild(ParamsConfigDialog& Dialog) override final
            {
                Dialog.AddParam({ ParamBase::GetParamTitle(), ParamBase::GetParamDescription() }, std::ref(*static_cast<UnderlyingTextListParamType*>(this)),
                    Get(), TextList, !GetDefaultValue().empty());
            }
 
            Util::TextListType TextList;
        };
 
        using UnderlyingIndexedTextListParamType = TypedParamBase<Util::TextListIndexType>;
 
        template <typename ParamType>
        class Param<ParamType, std::enable_if_t<std::is_base_of_v<IndexedTextList, ParamType>>> : public UnderlyingIndexedTextListParamType
        {
        public:
            using UnderlyingIndexedTextListParamType::operator=;
 
            Param(ParamsBase& Owner, Util::TextListType&& TextList, std::string ParamName, std::string_view ParamTitle,
                std::string_view ParamDescription, bool NeedsResetToApplyChange = true, UnderlyingIndexedTextListParamType::UnderlyingType DefaultValue = 0)
                : UnderlyingIndexedTextListParamType(Owner, ParamName, ParamTitle, ParamDescription, NeedsResetToApplyChange, DefaultValue),
                TextList(std::move(TextList)) {}
            
            Param(ParamsBase& Owner, Util::TextListType&& TextList, std::string ParamName,
                UnderlyingIndexedTextListParamType::UnderlyingType DefaultValue = 0)
                : UnderlyingIndexedTextListParamType(Owner, ParamName, DefaultValue),
                TextList(std::move(TextList)) {}
 
            const auto& GetTextList() const noexcept { return TextList; }   
 
        private:
            virtual void AddToDialogChild(ParamsConfigDialog& Dialog) override final
            {
                Dialog.AddParam({ ParamBase::GetParamTitle(), ParamBase::GetParamDescription() }, std::ref(*static_cast<UnderlyingIndexedTextListParamType*>(this)),
                    Get(), GetDefaultValue(), TextList);
            }
 
            virtual bool ValidateValue(const ParamType& Value) const override { return Value < TextList.size(); }
 
            const Util::TextListType TextList;                              
        };
 
        template <typename EnumType>
        using UnderlyingEnumParamType = TypedParamBase<LargestEnumUnderlyingType<EnumType>>;
 
        template <typename EnumType>
        class Param<EnumType, std::enable_if_t<std::is_enum_v<EnumType>>> : public UnderlyingEnumParamType<EnumType>
        {
        public:
            Param(ParamsBase& Owner, Util::TextValueListType<EnumType>&& TextValueList, std::string ParamName, std::string_view ParamTitle,
                std::string_view ParamDescription, bool NeedsResetToApplyChange = true, EnumType DefaultValue = EnumType())
                : UnderlyingEnumParamType<EnumType>(Owner, ParamName, ParamTitle, ParamDescription, NeedsResetToApplyChange, DefaultValue),
                TextValueList(std::move(TextValueList)) {}
            
            Param(ParamsBase& Owner, std::string ParamName, EnumType DefaultValue = EnumType())
                : UnderlyingEnumParamType<EnumType>(Owner, ParamName, DefaultValue) {}
 
            
            EnumType GetDefaultValue() const noexcept { return static_cast<EnumType>(UnderlyingEnumParamType<EnumType>::GetDefaultValue()); }
            
            const auto& GetTextValueList() const noexcept { return TextValueList; }     
 
            operator EnumType() const noexcept { return static_cast<EnumType>(UnderlyingEnumParamType<EnumType>::Get()); }
            
            const EnumType Get() const noexcept { return static_cast<EnumType>(UnderlyingEnumParamType<EnumType>::Get()); }
 
            const EnumType operator=(const EnumType& NewValue)
            {
                UnderlyingEnumParamType<EnumType>::operator=(NewValue);
 
                return Get();
            }
 
        private:
            virtual void AddToDialogChild(ParamsConfigDialog& Dialog) override final
            {
                Dialog.AddParam<EnumType>({ ParamBase::GetParamTitle(), ParamBase::GetParamDescription() }, std::ref(*static_cast<UnderlyingEnumParamType<EnumType>*>(this)),
                    Get(), GetDefaultValue(), TextValueList);
            }
 
            const Util::TextValueListType<EnumType> TextValueList;                      
        };
 
        using UnderlyingLinkParamType = TypedParamBase<ItemIDType>;
 
        class LinkParamBase : public DynExp::LinkBase, public UnderlyingLinkParamType
        {
        protected:
            LinkParamBase(ParamsBase& Owner, std::string ParamName, std::string_view ParamTitle, std::string_view ParamDescription,
                bool NeedsResetToApplyChange = true, std::string_view IconResourcePath = {}, bool Optional = false)
                : LinkBase(IconResourcePath, Optional),
                UnderlyingLinkParamType(Owner, ParamName, ParamTitle, ParamDescription, NeedsResetToApplyChange, ItemIDNotSet) {}
 
        public:
            using UnderlyingLinkParamType::operator=;
 
        private:
            virtual std::string_view GetLinkTitleChild() const noexcept override { return GetParamTitle(); }
            virtual ItemIDListType GetLinkedIDsChild() const override { return Get() != ItemIDNotSet ? ItemIDListType{ Get() } : ItemIDListType{}; }
        };
 
        template <typename LinkType>
        class Param<LinkType, std::enable_if_t<std::is_base_of_v<ObjectLinkBase, LinkType>>> : public LinkParamBase
        {
        public:
            using ObjectType = typename LinkType::ObjectType;           
            using ManagerType = ManagerTypeOfObjectType_t<ObjectType>;  
            using LinkParamBase::operator=;
 
            Param(ParamsBase& Owner, const ManagerType& Manager,
                std::string ParamName, std::string_view ParamTitle, std::string_view ParamDescription,
                std::string_view IconResourcePath = {}, bool Optional = false, bool NeedsResetToApplyChange = true)
                : LinkParamBase(Owner, ParamName, ParamTitle, ParamDescription, NeedsResetToApplyChange, IconResourcePath, Optional),
                Manager(Manager)
            {
                // Since classes derived from ParamBase are declared within the scope of class ParamsBase, this is allowed.
                // This is safe since ObjectLinkParams is declared before any Param<LinkType> within the inheritance hierarchy.
                GetOwner().ObjectLinkParams.emplace_back(std::ref(*this));
            }
 
            const auto& GetManager() const noexcept { return Manager; }
 
            bool ContainsID() const noexcept { return Get() != ItemIDNotSet; }
 
            const LinkType& GetLink() const noexcept { return Link; }
 
            void MakeLink()
            {
                if (!ContainsID())
                    Link.Reset();
                else
                {
                    auto Resource = std::dynamic_pointer_cast<ObjectType>(ShareResource(Manager, Get()));
                    if (!Resource)
                        throw Util::InvalidStateException(
                            "A resource assigned to a param does not match the expected type.");
 
                    Link = Resource;
                }
            }
 
        private:
            virtual const CommonResourceManagerBase* GetCommonManagerChild() const noexcept override { return &Manager; }
 
            virtual void FromXMLNodeChild(const QDomElement& XMLElement) override
            {
                UnderlyingLinkParamType::FromXMLNodeChild(XMLElement);
                MakeLink();
            }
 
            virtual void AddToDialogChild(ParamsConfigDialog& Dialog) override final
            {
                // Call MakeLink() after "OK" (accept) has been clicked to really link the parameter to the chosen object by creating pointers.
                auto FunctionToCallIfAccepted = std::bind_front(&Param::MakeLink, this);
 
                Dialog.AddParam({ ParamBase::GetParamTitle(), ParamBase::GetParamDescription() }, std::ref(*static_cast<LinkParamBase*>(this)),
                    Get(), IsOptional(), GetIconResourcePath(), FunctionToCallIfAccepted, MakeObjectIDsWithLabels<ObjectType>(GetManager()));
            }
 
            void EnsureReadyStateChild() override final
            {
                if (!ContainsID())
                    return;
 
                auto LinkedObj = Link.TryLockDestinyRaw();
                if (LinkedObj)
                    LinkedObj->EnsureReadyState(true);
            }
 
            bool IsReadyChild() override final
            {
                if (!ContainsID())
                    return true;
 
                auto LinkedObj = Link.TryLockDestinyRaw();
                if (LinkedObj)
                {
                    try
                    {
                        return LinkedObj->IsReady();
                    }
                    catch ([[maybe_unused]] const Util::TimeoutException& e)
                    {
                        // Swallow TimeoutException since this is thrown if IsReady() cannot check the object's exception state
                        // because the object is busy and locked its data. This is considered not ready.
                        return false;
                    }
                }
                else
                    return true;
            }
 
            const ManagerType& Manager;
 
            LinkType Link;
        };
 
        template <typename ParamType, typename = void>
        class ListParam;
 
        template <typename ParamType>
        class ListParam<ParamType,
            std::enable_if_t<
                !std::is_arithmetic_v<ParamType> &&
                !std::is_base_of_v<ObjectLinkBase, ParamType>
            >>
            : public TypedListParamBase<ParamType>
        {
        public:
            using TypedListParamBase<ParamType>::operator=;
 
            ListParam(ParamsBase& Owner, std::string ParamName, std::string_view ParamTitle, std::string_view ParamDescription, bool NeedsResetToApplyChange = true,
                typename TypedListParamBase<ParamType>::UnderlyingType DefaultValues = {})
                : TypedListParamBase<ParamType>(Owner, ParamName, ParamTitle, ParamDescription, NeedsResetToApplyChange, std::move(DefaultValues)) {}
            
            ListParam(ParamsBase& Owner, std::string ParamName, typename TypedListParamBase<ParamType>::UnderlyingType DefaultValues = {})
                : TypedListParamBase<ParamType>(Owner, ParamName, std::move(DefaultValues)) {}
 
        private:
            virtual void AddToDialogChild(ParamsConfigDialog& Dialog) override final
            {
                throw Util::NotImplementedException(
                    "A general (unspecified) list parameter cannot be added to a settings dialog.");
            }
        };
 
        template <typename ArithmeticType>
        using UnderlyingArithmeticListParamType = TypedListParamBase<ArithmeticType>;
 
        template <typename ArithmeticType>
        class ListParam<ArithmeticType, std::enable_if_t<std::is_arithmetic_v<ArithmeticType>>> : public UnderlyingArithmeticListParamType<ArithmeticType>
        {
        public:
            using PrecisionType = unsigned short;
            using UnderlyingArithmeticListParamType<ArithmeticType>::operator=;
 
            ListParam(ParamsBase& Owner, std::string ParamName, std::string_view ParamTitle, std::string_view ParamDescription, bool NeedsResetToApplyChange = true,
                typename TypedListParamBase<ArithmeticType>::UnderlyingType DefaultValues = {},
                ArithmeticType MinValue = std::numeric_limits<ArithmeticType>::lowest(), ArithmeticType MaxValue = std::numeric_limits<ArithmeticType>::max(),
                ArithmeticType Increment = 1, PrecisionType Precision = 0)
                : UnderlyingArithmeticListParamType<ArithmeticType>(Owner, ParamName, ParamTitle, ParamDescription, NeedsResetToApplyChange, std::move(DefaultValues)),
                MinValue(MinValue), MaxValue(MaxValue), Increment(Increment), Precision(Precision) {}
            
            ListParam(ParamsBase& Owner, std::string ParamName, typename TypedListParamBase<ArithmeticType>::UnderlyingType DefaultValues = {},
                ArithmeticType MinValue = std::numeric_limits<ArithmeticType>::lowest(), ArithmeticType MaxValue = std::numeric_limits<ArithmeticType>::max(),
                ArithmeticType Increment = 1, PrecisionType Precision = 0)
                : UnderlyingArithmeticListParamType<ArithmeticType>(Owner, ParamName, std::move(DefaultValues)),
                MinValue(MinValue), MaxValue(MaxValue), Increment(Increment), Precision(Precision) {}
 
            ArithmeticType GetMinValue() const noexcept { return MinValue; }    
            ArithmeticType GetMaxValue() const noexcept { return MaxValue; }    
            ArithmeticType GetIncrement() const noexcept { return Increment; }  
            PrecisionType GetPrecision() const noexcept { return Precision; }   
 
        private:
            virtual void AddToDialogChild(ParamsConfigDialog& Dialog) override final
            {
                throw Util::NotImplementedException(
                    "An arithmetic list parameter cannot be added to a settings dialog currently.");
            }
 
            bool ValidateValues(const typename TypedListParamBase<ArithmeticType>::UnderlyingType& NewValues) const override
            {
                for (const auto value : NewValues)
                    if (value < MinValue || value > MaxValue)
                        return false;
 
                return true;
            }
 
            const ArithmeticType MinValue;  
            const ArithmeticType MaxValue;  
            const ArithmeticType Increment; 
            const PrecisionType Precision;  
        };
 
        using UnderlyingLinkListParamType = TypedListParamBase<ItemIDType>;
 
        class LinkListParamBase : public DynExp::LinkBase, public UnderlyingLinkListParamType
        {
        protected:
            LinkListParamBase(ParamsBase& Owner, std::string ParamName, std::string_view ParamTitle, std::string_view ParamDescription,
                bool NeedsResetToApplyChange = true, std::string_view IconResourcePath = {}, bool Optional = false)
                : LinkBase(IconResourcePath, Optional),
                UnderlyingLinkListParamType(Owner, ParamName, ParamTitle, ParamDescription, NeedsResetToApplyChange) {}
 
        public:
            using UnderlyingLinkListParamType::operator=;
 
        private:
            virtual std::string_view GetLinkTitleChild() const noexcept override { return GetParamTitle(); }
            virtual ItemIDListType GetLinkedIDsChild() const override { return Get(); }
        };
 
        template <typename LinkType>
        class ListParam<LinkType, std::enable_if_t<std::is_base_of_v<ObjectLinkBase, LinkType>>> : public LinkListParamBase
        {
        public:
            using ObjectType = typename LinkType::ObjectType;           
            using ManagerType = ManagerTypeOfObjectType_t<ObjectType>;  
            using LinkListParamBase::operator=;
 
            ListParam(ParamsBase& Owner, const ManagerType& Manager,
                std::string ParamName, std::string_view ParamTitle, std::string_view ParamDescription,
                std::string_view IconResourcePath = {}, bool Optional = false, bool NeedsResetToApplyChange = true)
                : LinkListParamBase(Owner, ParamName, ParamTitle, ParamDescription, NeedsResetToApplyChange, IconResourcePath, Optional),
                Manager(Manager)
            {
                // Since classes derived from ParamBase are declared within the scope of class ParamsBase, this is allowed.
                // This is safe since ObjectLinkParams is declared before any Param<LinkType> within the inheritance hierarchy.
                GetOwner().ObjectLinkParams.emplace_back(std::ref(*this));
            }
 
            const auto& GetManager() const noexcept { return Manager; }
 
            bool ContainsID() const noexcept { return !Get().empty(); }
 
            const auto& GetLinks() const noexcept { return Links; }
 
            void MakeLinks()
            {
                Links.clear();
 
                if (ContainsID())
                {
                    for (auto ID : Get())
                    {
                        auto Resource = std::dynamic_pointer_cast<ObjectType>(ShareResource(Manager, ID));
                        if (!Resource)
                            throw Util::InvalidStateException(
                                "A resource assigned to a list parameter does not match the expected type.");
 
                        Links.emplace_back(Resource);
                    }
                }
            }
 
        private:
            virtual const CommonResourceManagerBase* GetCommonManagerChild() const noexcept override { return &Manager; }
 
            virtual void FromXMLNodeChild(const QDomElement& XMLElement) override
            {
                UnderlyingLinkListParamType::FromXMLNodeChild(XMLElement);
                MakeLinks();
            }
 
            virtual void AddToDialogChild(ParamsConfigDialog& Dialog) override final
            {
                // Call MakeLink() after "OK" (accept) has been clicked to really link the parameter to the chosen object by creating pointers.
                auto FunctionToCallIfAccepted = std::bind_front(&ListParam::MakeLinks, this);
 
                Dialog.AddParam({ ParamBase::GetParamTitle(), ParamBase::GetParamDescription() }, std::ref(*static_cast<LinkListParamBase*>(this)),
                    Get(), IsOptional(), GetIconResourcePath(), FunctionToCallIfAccepted, MakeObjectIDsWithLabels<ObjectType>(GetManager()));
            }
 
            bool ValidateValues(const typename LinkListParamBase::UnderlyingType& NewValues) const override
            {
                for (const auto value : NewValues)
                    if (value == ItemIDNotSet)
                        return false;
 
                return true;
            }
 
            void EnsureReadyStateChild() override final
            {
                if (!ContainsID())
                    return;
 
                for (auto& Link : Links)
                {
                    auto LinkedObj = Link.TryLockDestinyRaw();
                    if (LinkedObj)
                        LinkedObj->EnsureReadyState(true);
                }
            }
 
            bool IsReadyChild() override final
            {
                if (!ContainsID())
                    return true;
 
                for (auto& Link : Links)
                {
                    auto LinkedObj = Link.TryLockDestinyRaw();
                    if (!LinkedObj)
                        continue;
 
                    try
                    {
                        if (!LinkedObj->IsReady())
                            return false;
                    }
                    catch ([[maybe_unused]] const Util::TimeoutException& e)
                    {
                        // Swallow TimeoutException since this is thrown if IsReady() cannot check the object's exception state
                        // because the object is busy and locked its data. This is considered not ready.
                        return false;
                    }
                }
 
                return true;
            }
 
            const ManagerType& Manager;
 
            std::vector<LinkType> Links;
        };
 
        class LinkParamStarter
        {
        public:
            LinkParamStarter(const ParamsBase& Params) noexcept
                : Params(Params), CurrentParam(Params.ObjectLinkParams.cbegin()), EnsureReadyStateCalledForCurrentParam(false) {}
 
            bool operator()();
 
        private:
            const ParamsBase& Params;                                       
            ParamsBase::ObjectLinkParamsType::const_iterator CurrentParam;  
            bool EnsureReadyStateCalledForCurrentParam;                     
        };
 
        enum UsageType { Unique, Shared };
        ParamsBase(ItemIDType ID, const DynExpCore& Core) : ID(ID), Core(Core) {}
 
        virtual ~ParamsBase() = 0;
 
        virtual const char* GetParamClassTag() const noexcept { return "ParamsBase"; }
 
        QDomElement ConfigToXML(QDomDocument& Document) const;
 
        void ConfigFromXML(const QDomElement& XMLElement) const;
 
        void ConfigFromDialog(ParamsConfigDialog& Dialog);
 
        bool Validate() const;
 
        ItemIDType GetID() const noexcept { return ID; }                                
        const auto& GetCore() const noexcept { return Core; }                           
        const auto& GetObjectLinkParams() const noexcept { return ObjectLinkParams; }   
 
        static Util::TextValueListType<UsageType> AvlblUsageTypeStrList();
 
    private:
        struct OwnedParamInfo
        {
            const char* const ClassTag;
 
            const std::reference_wrapper<ParamBase> OwnedParam;
        };
 
        OwnedParamsType OwnedParams;            
        ObjectLinkParamsType ObjectLinkParams;  
 
    public:
        Param<ParamsConfigDialog::TextType> ObjectName = { *this, "ObjectName", "Name", "Name to identify this item", false };
 
        Param<UsageType> Usage = { *this, AvlblUsageTypeStrList(), "Usage", "Usage type",
            "Determines how this item can be used by other items", false, UsageType::Shared };
 
        bool ConfigureUsageType() const noexcept { return ConfigureUsageTypeChild(); }
 
        const NetworkParamsExtension* GetNetworkAddressParams() const noexcept { return GetNetworkAddressParamsChild(); }
 
        static void DisableUserEditable(ParamBase& Param) noexcept;
 
    private:
        void ConfigureParams();
 
        virtual void ConfigureParamsImpl(dispatch_tag<ParamsBase>) {};
 
        virtual bool ConfigureUsageTypeChild() const noexcept { return true; }
 
        virtual const NetworkParamsExtension* GetNetworkAddressParamsChild() const noexcept { return nullptr; }
 
        std::filesystem::path ToAbsolutePath(const std::filesystem::path& Path) const;
 
        const ItemIDType ID;        
        const DynExpCore& Core;     
    };
 
    template <typename ParamType>
    auto operator==(const ParamsBase::TypedParamBase<ParamType>& lhs, const ParamType& rhs) { return lhs.Get() == rhs; }
 
    template <typename ParamType>
    auto operator<=>(const ParamsBase::TypedParamBase<ParamType>& lhs, const ParamType& rhs) { return lhs.Get() <=> rhs; }
 
    using ParamsBasePtrType = std::unique_ptr<ParamsBase>;
 
    template <typename ConfiguratorT>
    ParamsBasePtrType MakeParams(ItemIDType ID, const DynExpCore& Core)
    {
        auto Params = std::make_unique<typename ConfiguratorT::ParamsType>(ID, Core);
 
        Params->ObjectName = ConfiguratorT::ObjectType::Name();
 
        return Params;
    }
 
    template <typename T>
    typename T::ParamsType* dynamic_Params_cast(ParamsBasePtrType::element_type* Params)
    {
        if (!Params)
            return nullptr;
 
        auto DerivedParams = dynamic_cast<typename T::ParamsType*>(Params);
        if (!DerivedParams)
            throw Util::TypeErrorException();
 
        return DerivedParams;
    }
 
    template <typename To, typename From, std::enable_if_t<
        std::is_same_v<ParamsBase, std::remove_cv_t<From>>, int> = 0
    >
    auto dynamic_Params_cast(Util::SynchronizedPointer<From>&& ParamsPtr)
    {
        if (!ParamsPtr)
            throw Util::InvalidArgException("ParamsPtr must not be nullptr.");
 
        return Util::SynchronizedPointer<
            std::conditional_t<std::is_const_v<From>, std::add_const_t<typename To::ParamsType>, typename To::ParamsType>
        >(std::move(ParamsPtr));
    }
 
    class ConfiguratorBase
    {
    public:
        using ObjectType = Object;
        using ParamsType = ParamsBase;
 
        struct UpdateConfigFromDialogResult
        {
            constexpr UpdateConfigFromDialogResult(bool Accepted, bool ResetRequired) noexcept
                : Accepted(Accepted), ResetRequired(ResetRequired) {}
 
            constexpr bool IsAccepted() const noexcept { return Accepted; }     
 
            constexpr bool IsResetRequired() const noexcept { return IsAccepted() && ResetRequired; }
 
        private:
            const bool Accepted;        
            const bool ResetRequired;   
        };
 
        ConfiguratorBase() = default;
        virtual ~ConfiguratorBase() = 0;
 
        ParamsBasePtrType MakeConfigFromDialog(ItemIDType ID, const DynExpCore& Core, QWidget* const DialogParent) const;
 
        ParamsBasePtrType MakeConfigFromXML(ItemIDType ID, const DynExpCore& Core, const QDomElement& XMLElement) const;
 
        UpdateConfigFromDialogResult UpdateConfigFromDialog(Object* Obj, const DynExpCore& Core, QWidget* const DialogParent) const;
 
    private:
        virtual ParamsBasePtrType MakeParams(ItemIDType ID, const DynExpCore& Core) const = 0;
    };
 
    using ConfiguratorBasePtrType = std::shared_ptr<ConfiguratorBase>;
 
    class Object
    {
    public:
        using ParamsType = ParamsBase;
 
        using ParamsTypeSyncPtrType = Util::SynchronizedPointer<ParamsType>;
 
        using ParamsConstTypeSyncPtrType = Util::SynchronizedPointer<const ParamsType>;
 
        using ConfigType = ConfiguratorBase;
 
        static std::string CategoryAndNameToStr(const std::string& Category, const std::string& Name);
 
        static constexpr std::chrono::milliseconds GetParamsTimeoutDefault = std::chrono::milliseconds(100);
 
    protected:
        template <typename>
        struct dispatch_tag {};
 
        Object(const std::thread::id OwnerThreadID, ParamsBasePtrType&& Params);
 
        virtual ~Object() = 0;
 
    private:
        class LinkedObjectWrapperOnlyType
        {
            friend class Object;
 
            template <typename>
            friend class LinkedObjectWrapper;
 
            constexpr LinkedObjectWrapperOnlyType(Object& Parent) noexcept : Parent(Parent) {}
 
 
            void RegisterUser(const Object& User, const std::chrono::milliseconds Timeout) const;
 
            void DeregisterUser(const Object& User, const std::chrono::milliseconds Timeout) const;
 
            Object& Parent;     
        };
 
    public:
 
        void Reset();
 
        void BlockIfUnused(const std::chrono::milliseconds Timeout = Util::ILockable::DefaultTimeout);
 
 
        ParamsConstTypeSyncPtrType GetParams(const std::chrono::milliseconds Timeout = GetParamsTimeoutDefault) const;
 
        using ParamsGetterType = Util::CallableMemberWrapper<Object, decltype(&Object::GetParams)>;
 
        ParamsTypeSyncPtrType GetParams(const std::chrono::milliseconds Timeout = GetParamsTimeoutDefault);
 
        auto GetObjectName(const std::chrono::milliseconds Timeout = GetParamsTimeoutDefault) const { return GetParams(Timeout)->ObjectName.Get(); }
 
        bool IsSharedUsageEnabled(const std::chrono::milliseconds Timeout = GetParamsTimeoutDefault) const { return GetParams(Timeout)->Usage == ParamsType::UsageType::Shared; }
 
        ItemIDType GetID() const noexcept { return Params->GetID(); }
 
        virtual std::string GetName() const = 0;        
        virtual std::string GetCategory() const = 0;    
 
        std::string GetCategoryAndName() const { return CategoryAndNameToStr(GetCategory(), GetName()); }
 
        void EnsureReadyState(bool IsAutomaticStartup);
 
 
        void SetWarning(std::string Description, int ErrorCode) const;
 
        void SetWarning(const Util::Exception& e) const;
 
        void ClearWarning() const { Warning.Reset(); }
 
        auto GetWarning() const { return Warning.Get(); }
 
        std::exception_ptr GetException(const std::chrono::milliseconds Timeout = Util::ILockable::DefaultTimeout) const { return GetExceptionChild(Timeout); }
 
        bool IsReady() const { return !IsBlocked && IsReadyChild(); }
 
        auto GetUseCount(const std::chrono::milliseconds Timeout = Util::ILockable::DefaultTimeout) const { return UserList.CountUsers(Timeout); }
 
        bool IsUnused(const std::chrono::milliseconds Timeout = Util::ILockable::DefaultTimeout) const { return GetUseCount(Timeout) == 0; }
 
        auto GetUserIDs(const std::chrono::milliseconds Timeout = Util::ILockable::DefaultTimeout) const { return UserList.GetUserIDs(Timeout); }
 
        auto GetUserNamesString(const std::chrono::milliseconds Timeout = Util::ILockable::DefaultTimeout) const { return UserList.GetUserNamesString(Timeout); }
 
        void CheckLinkedObjectStates() const { CheckLinkedObjectStatesChild(); };
 
        LinkedObjectWrapperOnlyType LinkedObjectWrapperOnly;                                                
 
    protected:
        void EnsureCallFromOwningThread() const;
 
        ParamsTypeSyncPtrType GetNonConstParams(const std::chrono::milliseconds Timeout = GetParamsTimeoutDefault) const;
 
        auto LockUserList(const std::chrono::milliseconds Timeout = Util::ILockable::DefaultTimeout) { return UserList.AcquireLock(Timeout); }  
        void DeregisterAllUnsafe() { UserList.DeregisterAllUnsafe(); }                                                                          
        auto GetUseCountUnsafe() { return UserList.CountUsersUnsafe(); }                                                                        
        auto GetUserNamesStringUnsafe() const { return UserList.GetUserNamesStringUnsafe(); }                                                   
 
        bool IsUnusedUnsafe() { return GetUseCountUnsafe() == 0; }
 
    private:
 
        virtual void ResetImpl(dispatch_tag<Object>) = 0;                                                   
 
        virtual std::exception_ptr GetExceptionChild(const std::chrono::milliseconds Timeout) const = 0;    
        virtual void EnsureReadyStateChild(bool IsAutomaticStartup) = 0;                                    
        virtual bool IsReadyChild() const = 0;                                                              
 
        virtual void CheckLinkedObjectStatesChild() const {};
 
        void LogWarning() const;
 
        const std::thread::id OwnerThreadID;    
        const ParamsBasePtrType Params;         
 
        mutable Util::Warning Warning;          
 
        ObjectUserList UserList;
 
        bool IsBlocked = false;
    };
 
    template <typename To, typename From, std::enable_if_t<
        std::is_base_of_v<Object, To> && std::is_base_of_v<Object, From>, int> = 0
    >
    auto dynamic_Object_cast(From* Obj)
    {
        if (!Obj)
            throw Util::InvalidArgException("Obj must not be nullptr.");
 
        auto DerivedObj = dynamic_cast<std::conditional_t<std::is_const_v<From>, std::add_const_t<To>*, To*>>(Obj);
        if (!DerivedObj)
            throw Util::TypeErrorException();
 
        return DerivedObj;
    }
 
    class RunnableObjectParams : public ParamsBase
    {
    public:
        enum StartupType { OnCreation, Automatic, Manual };
        RunnableObjectParams(ItemIDType ID, const DynExpCore& Core) : ParamsBase(ID, Core) {}
        
        virtual ~RunnableObjectParams() = 0;
 
        virtual const char* GetParamClassTag() const noexcept override { return "RunnableObjectParams"; }
 
        static Util::TextValueListType<StartupType> AvlblStartupTypeStrList();
 
        Param<StartupType> Startup = { *this, AvlblStartupTypeStrList(), "Startup", "Startup type",
            "Determines when the item is started", false, StartupType::Automatic };
 
        bool ConfigureStartupType() const noexcept { return ConfigureStartupTypeChild(); }
 
    private:
        void ConfigureParamsImpl(dispatch_tag<ParamsBase>) override final;
        virtual void ConfigureParamsImpl(dispatch_tag<RunnableObjectParams>) {}     
 
        virtual bool ConfigureStartupTypeChild() const noexcept { return true; }    
    };
 
    class RunnableObjectConfigurator : public ConfiguratorBase
    {
    public:
        using ObjectType = RunnableObject;
        using ParamsType = RunnableObjectParams;
 
        RunnableObjectConfigurator() = default;
        virtual ~RunnableObjectConfigurator() = 0;
    };
 
    class RunnableObject : public Util::INonCopyable, public Object
    {
        class RunnableInstanceOnlyType
        {
            friend class RunnableObject;
            friend class RunnableInstance;
 
            constexpr RunnableInstanceOnlyType(RunnableObject& Parent) noexcept : Parent(Parent) {}
 
            void OnThreadHasExited() const noexcept { Parent.OnThreadHasExited(); }                                     
            bool IsLinkedObjStateCheckRequested() const noexcept { return Parent.LinkedObjStateCheckRequested; }        
            void ResetLinkedObjStateCheckRequested() const noexcept { Parent.LinkedObjStateCheckRequested = false; }    
 
            RunnableObject& Parent;                                                                                     
        };
 
    public:
        class NotUnusedException
        {
        public:
            NotUnusedException(const RunnableObject& Parent) : UserNames(Parent.GetUserNamesStringUnsafe()) {}
 
            std::string_view GetUserNames() const { return UserNames; }
 
            std::string GetErrorMessage() const;
 
        private:
            std::string UserNames;  
        };
 
        using ParamsType = RunnableObjectParams;                                            
        using ConfigType = RunnableObjectConfigurator;                                      
 
        static constexpr auto ShortTimeoutDefault = std::chrono::milliseconds(50);
 
        static constexpr auto TerminateTimeoutDefault = std::chrono::milliseconds(3000);
 
        RunnableObject(const std::thread::id OwnerThreadID, ParamsBasePtrType&& Params);    
        virtual ~RunnableObject() = 0;
 
 
        bool Run(QWidget* ParentWidget = nullptr);
 
        bool RunIfRunAutomatic();
 
        bool RunIfRunOnCreation();
 
        void Terminate(bool Force = false, const std::chrono::milliseconds Timeout = TerminateTimeoutDefault);
 
        void SetPaused(bool Pause, std::string Description = "");
 
        bool IsRunning() const noexcept { return Running; }                 
        bool IsPaused() const noexcept { return Paused; }                   
        bool IsExiting() const noexcept { return ShouldExit; }              
 
        auto GetStartupType() const noexcept { return Startup.load(); }     
        auto GetReasonWhyPaused() const { return ReasonWhyPaused.Get(); }   
 
        RunnableInstanceOnlyType RunnableInstanceOnly;                      
 
    protected:
        void Init();                                                        
 
        std::promise<void> MakeThreadExitedPromise();
        
        void StoreThread(std::thread&& Thread) noexcept;
 
        bool IsCallFromRunnableThread() const;
 
        void EnsureCallFromRunnableThread() const;
 
        void SetReasonWhyPaused(std::string Description) { ReasonWhyPaused = Util::Warning(std::move(Description)); }
 
        void SetReasonWhyPaused(const Util::Exception& e) { ReasonWhyPaused = e; }
 
        void ClearReasonWhyPaused() { ReasonWhyPaused.Reset(); }
 
    private:
        void ResetImpl(dispatch_tag<Object>) override final;
        virtual void ResetImpl(dispatch_tag<RunnableObject>) = 0;           
 
        void EnsureReadyStateChild(bool IsAutomaticStartup) override final;
        void CheckLinkedObjectStatesChild() const override final { LinkedObjStateCheckRequested = true; }
 
        virtual void RunChild() = 0;                                        
 
        virtual void NotifyChild() {}
 
        virtual void TerminateChild(const std::chrono::milliseconds Timeout) {}
 
        virtual std::unique_ptr<BusyDialog> MakeStartupBusyDialogChild(QWidget* ParentWidget) const { return nullptr; }
        
        void TerminateImpl(bool Force, const std::chrono::milliseconds Timeout = TerminateTimeoutDefault);
 
        void TerminateUnsafe(bool Force, const std::chrono::milliseconds Timeout = TerminateTimeoutDefault);
 
        void OnThreadHasExited() noexcept;
 
        std::atomic<RunnableObjectParams::StartupType> Startup = RunnableObjectParams::StartupType::Automatic;
 
        std::thread Thread;                                                 
        std::future<void> ThreadExitedSignal;                               
        std::atomic<bool> Running;                                          
        std::atomic<bool> Paused;                                           
        Util::Warning ReasonWhyPaused;                                      
 
        std::atomic<bool> ShouldExit;                                       
 
        mutable std::atomic<bool> LinkedObjStateCheckRequested = false;
    };
 
    class LinkedObjectWrapperBase : public Util::INonCopyable
    {
        friend class RunnableInstance;
 
    private:
        using LinkedObjectWrapperBasePtrType = std::unique_ptr<LinkedObjectWrapperBase>;
        
        struct OwnedLinkedObjectWrapperType
        {
            OwnedLinkedObjectWrapperType(LinkedObjectWrapperBasePtrType&& OwnedLinkedObjectWrapperPtr,
                LinkedObjectWrapperContainerBase& OwnedLinkedObjectWrapperContainer)
                : OwnedLinkedObjectWrapperPtr(std::move(OwnedLinkedObjectWrapperPtr)),
                OwnedLinkedObjectWrapperContainer(OwnedLinkedObjectWrapperContainer) {}
 
            LinkedObjectWrapperBasePtrType OwnedLinkedObjectWrapperPtr;
 
            LinkedObjectWrapperContainerBase& OwnedLinkedObjectWrapperContainer;
        };
 
        using ListType = std::list<OwnedLinkedObjectWrapperType>;
 
    public:
        LinkedObjectWrapperBase(const RunnableInstance& Owner) : Owner(Owner) {}
 
        virtual ~LinkedObjectWrapperBase() = 0;
 
 
        virtual bool IsRegistered() const noexcept = 0;
 
        const Object& GetOwner() const noexcept;
 
    private:
 
        virtual void Register(const std::chrono::milliseconds Timeout) = 0;
 
        virtual void Deregister(const std::chrono::milliseconds Timeout) = 0;
 
        ListType::const_iterator ListPos;
 
        const RunnableInstance& Owner;
    };
 
    template <typename ObjectT>
    class LinkedObjectWrapper : public LinkedObjectWrapperBase
    {
    public:
        using ObjectType = std::add_const_t<ObjectT>;   
 
        LinkedObjectWrapper(const RunnableInstance& Owner, std::shared_ptr<ObjectType>&& DestinyResource, const std::chrono::milliseconds Timeout)
            : LinkedObjectWrapperBase(Owner),
            DestinyResource(std::move(DestinyResource)), IsRegisteredFlag(false)
        {
            // Checks for nullptr.
            LinkedObjectWrapper::Register(Timeout);
        }
 
        virtual ~LinkedObjectWrapper()
        {
            try
            {
                LinkedObjectWrapper::Deregister(std::chrono::milliseconds(1000));
            }
            catch (const Util::TimeoutException& e)
            {
                Util::EventLog().Log(e);
                Util::EventLog().Log("Could not deregister a linked object wrapper. Timeout occurred. Execution cannot continue.",
                    Util::ErrorType::Fatal);
 
                std::terminate();
            }
            catch (const Util::Exception& e)
            {
                Util::EventLog().Log("Could not deregister a linked object wrapper. The error listed below occurred. Execution cannot continue.",
                    Util::ErrorType::Fatal);
                Util::EventLog().Log(e);
 
                std::terminate();
            }
            catch (const std::exception& e)
            {
                Util::EventLog().Log("Could not deregister a linked object wrapper. The error listed below occurred. Execution cannot continue.",
                    Util::ErrorType::Fatal);
                Util::EventLog().Log(e.what());
 
                std::terminate();
            }
            catch (...)
            {
                Util::EventLog().Log("Could not deregister a linked object wrapper. An unknown error occurred. Execution cannot continue.",
                    Util::ErrorType::Fatal);
 
                std::terminate();
            }
        }
 
        virtual bool IsRegistered() const noexcept override { return IsRegisteredFlag; }
 
        std::string GetLinkedObjectDesc() const { return DestinyResource->GetObjectName() + " (" + DestinyResource->GetCategoryAndName() + ")"; }
 
        decltype(auto) get() const { return &this->operator*(); }
 
        decltype(auto) get() { return &this->operator*(); }                 
 
        const auto& operator*() const
        {
            // ->
            // Checking for errors with
            
            /* if (!DestinyResource->IsReady())
                throw Util::InvalidCallException("The requested object is in an invalid state or in an error state."); */
 
            // does not work here, because the OnError() handlers of instruments or modules might call
            // functions through a LinkedObjectWrapper to perform shutdown operations. This would not be
            // possible with a respective error check taking place here. This is not considered a problem,
            // since DestinyResource exists in any case and modifying its underlying Object simply does
            // not have an effect or throws an exception itself if Object is not ready. Instead, just
            // indiate errors by setting LinkedObjectWrapperContainerBase's LinkedObjectState to NotReady
            // (see LinkedObjectWrapperContainer<...>::get()).
            // <-
 
            if (!IsRegisteredFlag)
                throw Util::InvalidStateException(
                    "This linked object wrapper instance is deregistered from the requested object.");
 
            return *DestinyResource.get();
        }
 
        auto& operator*()
        {
            // Call const version of operator*
            return const_cast<typename std::shared_ptr<ObjectType>::element_type&>(
                static_cast<const LinkedObjectWrapper<ObjectT>&>(*this).operator*());
        }
 
        const auto operator->() const { return &this->operator*(); }        
        auto operator->() { return &this->operator*(); }                    
 
    private:
        virtual void Register(const std::chrono::milliseconds Timeout) override
        {
            if (!DestinyResource)
                throw Util::InvalidArgException("DestinyResource must not be nullptr.");
            if (IsRegisteredFlag)
                return;
 
            // Could throw Util::TimeoutException if resource is currently modified (e.g. call to Object::Reset()).
            DestinyResource->LinkedObjectWrapperOnly.RegisterUser(GetOwner(), Timeout);
 
            IsRegisteredFlag = true;
        }
 
        virtual void Deregister(const std::chrono::milliseconds Timeout) override
        {
            if (!IsRegisteredFlag)
                return;
 
            DestinyResource->LinkedObjectWrapperOnly.DeregisterUser(GetOwner(), Timeout);
 
            IsRegisteredFlag = false;
        }
 
        const std::shared_ptr<ObjectType> DestinyResource;
 
        bool IsRegisteredFlag;
    };
 
    template <typename ObjectT>
    class LinkedObjectWrapperPointer
    {
    public:
        using LinkedObjectWrapperType = LinkedObjectWrapper<std::add_const_t<ObjectT>>;
 
        using LinkedObjectWrapperPtrType = LinkedObjectWrapperType*;
 
        LinkedObjectWrapperPointer() noexcept : LinkedObjectWrapperPtr(nullptr) {}
 
        LinkedObjectWrapperPointer(LinkedObjectWrapperPtrType LinkedObjectWrapperPtr) noexcept
            : LinkedObjectWrapperPtr(LinkedObjectWrapperPtr) {}
 
        LinkedObjectWrapperPtrType get() const noexcept { return LinkedObjectWrapperPtr; }
 
        bool operator==(const LinkedObjectWrapperPtrType rhs) const noexcept { return LinkedObjectWrapperPtr == rhs; }
 
        bool operator!=(const LinkedObjectWrapperPtrType rhs) const noexcept { return LinkedObjectWrapperPtr != rhs; }
 
        bool operator==(const LinkedObjectWrapperPointer& rhs) const noexcept { return LinkedObjectWrapperPtr == rhs.get(); }
 
        bool operator!=(const LinkedObjectWrapperPointer& rhs) const noexcept { return LinkedObjectWrapperPtr != rhs.get(); }
 
        explicit operator bool() const noexcept { return LinkedObjectWrapperPtr != nullptr; }
 
        LinkedObjectWrapperPtrType operator->() const noexcept { return LinkedObjectWrapperPtr; }
 
        LinkedObjectWrapperType& operator*() const noexcept { return *LinkedObjectWrapperPtr; }
 
    private:
        LinkedObjectWrapperPtrType LinkedObjectWrapperPtr;
    };
 
    class LinkedObjectWrapperContainerBase : public Util::INonCopyable
    {
        friend class RunnableInstance;
 
    public:
        enum class LinkedObjectStateType { NotLinked, Ready, NotReady };
    protected:
        LinkedObjectWrapperContainerBase() noexcept : LinkedObjectState(LinkedObjectStateType::NotLinked) {}
 
        virtual ~LinkedObjectWrapperContainerBase() = 0;
 
        void Reset() noexcept;
 
        mutable LinkedObjectStateType LinkedObjectState;
 
    public:
        auto GetState() const noexcept { return LinkedObjectState; }    
 
        std::string GetLinkedObjectDesc() const { return GetLinkedObjectDescChild(); }
 
        bool CheckIfReady() { return CheckIfReadyChild(); }
 
    private:
        virtual void ResetChild() noexcept = 0;                         
        virtual std::string GetLinkedObjectDescChild() const = 0;       
        virtual bool CheckIfReadyChild() = 0;                           
    };
 
    template <typename ObjectT>
    class LinkedObjectWrapperContainer : public LinkedObjectWrapperContainerBase
    {
        friend class RunnableInstance;
 
    public:
        LinkedObjectWrapperContainer(bool PerformReadyCheck = true) noexcept
            : PerformReadyCheck(PerformReadyCheck) {}
 
        virtual ~LinkedObjectWrapperContainer() = default;
 
 
        auto get() const
        {
            const auto Destiny = GetLinkedObjWrapperPtr()->get();
 
            if (PerformReadyCheck)
            {
                try
                {
                    // This flag is reset either by SetLinkedObjWrapperPtr() or by
                    // RunnableInstance::CareAboutWrappers().
                    if (!Destiny->IsReady())
                        LinkedObjectState = LinkedObjectStateType::NotReady;
                }
                // ForwardedException signals that the underlying exception arose in the destiny resource.
                // All other exceptions are not to be handled here.
                catch ([[maybe_unused]] const Util::ForwardedException& e)
                {
                    LinkedObjectState = LinkedObjectStateType::NotReady;
                }
            }
 
            return Destiny;
        }
 
        auto& operator*() const { return *get(); }  
        auto operator->() const { return get(); }   
 
        bool valid() const noexcept { return static_cast<bool>(LinkedObjWrapperPtr); }
 
    private:
        virtual void ResetChild() noexcept override { LinkedObjWrapperPtr = nullptr; }
 
        virtual std::string GetLinkedObjectDescChild() const override
        {
            if (!LinkedObjWrapperPtr)
                return "< unknown >";
 
            return GetLinkedObjWrapperPtr()->GetLinkedObjectDesc();
        }
 
        virtual bool CheckIfReadyChild() override
        {
            if (LinkedObjectState != LinkedObjectStateType::Ready)
                return false;
 
            const auto Destiny = GetLinkedObjWrapperPtr()->get();
 
            bool IsReady = Destiny->IsReady();
            if (!IsReady)
                LinkedObjectState = LinkedObjectStateType::NotReady;
 
            return IsReady;
        }
 
        void CheckIfNullptr() const
        {
            if (!LinkedObjWrapperPtr)
                throw Util::LinkedObjectNotLockedException();
        }
 
        auto& GetLinkedObjWrapperPtr() const
        {
            CheckIfNullptr();
 
            return LinkedObjWrapperPtr;
        }
 
        void SetLinkedObjWrapperPtr(LinkedObjectWrapperPointer<ObjectT> NewLinkedObjWrapperPtr) noexcept
        {
            LinkedObjWrapperPtr = NewLinkedObjWrapperPtr;
            LinkedObjectState = LinkedObjWrapperPtr ? LinkedObjectStateType::Ready : LinkedObjectStateType::NotLinked;
 
            CheckIfReady();
        }
 
        LinkedObjectWrapperPointer<ObjectT> LinkedObjWrapperPtr;
 
        const bool PerformReadyCheck;
    };
 
    template <typename ObjectT>
    class LinkedObjectWrapperContainerList
    {
        friend class RunnableInstance;
 
        using ContainerType = LinkedObjectWrapperContainer<ObjectT>;
 
    public:
        LinkedObjectWrapperContainerList() = default;
        ~LinkedObjectWrapperContainerList() = default;
 
        const auto& GetList() const noexcept { return Containers; }         
        const auto& GetLabels() const noexcept { return ObjectLabels; }     
        std::string_view GetIconPath() const { return IconPath; }           
 
        template <typename IndexType>
        auto& operator[](IndexType Index)
        {
            auto i = Util::NumToT<size_t>(Index);
 
            if (i >= Containers.size())
                throw Util::OutOfRangeException("The specified object index is higher than the amount of linked objects.");
 
            return *Containers[i];
        }
 
    private:
        std::vector<std::unique_ptr<ContainerType>> Containers;
 
        Util::TextListType ObjectLabels;    
        std::string IconPath;               
    };
 
    class ObjectLinkBase
    {
    public:
        static constexpr std::chrono::milliseconds LockObjectTimeoutDefault = std::chrono::milliseconds(100);
 
    protected:
        ObjectLinkBase() = default;
        virtual ~ObjectLinkBase() = 0;
    };
 
    template <typename ObjectT>
    class ObjectLink : public ObjectLinkBase
    {
    public:
        using ObjectType = ObjectT;                             
        using ConstObjectType = std::add_const_t<ObjectT>;      
 
        friend class RunnableInstance;
 
        ObjectLink() : DestinyResource() {}
 
        ObjectLink(const std::shared_ptr<ObjectType>& DestinyResource) : DestinyResource(DestinyResource) {}
 
        virtual ~ObjectLink() {}
 
        void Reset() { DestinyResource.reset(); }
 
        auto& operator=(const std::shared_ptr<ObjectType>& NewDestinyResource)
        {
            // Throwing an exception here could lead to only partially loaded Param possessing an
            // invalid ObjectLink. Additionally, ParamsConfigDialog::accept() calls
            // ParamsBase::Param<LinkType>::MakeLink() which calls this. ParamsConfigDialog::accept()
            // should not face exceptions. So, do not throw anything here.
            DestinyResource = NewDestinyResource;
 
            return *this;
        }
 
        auto TryLockDestinyRaw()
        {
            // See above.
            return DestinyResource.lock();
        }
 
    private:
        std::unique_ptr<LinkedObjectWrapper<ConstObjectType>> TryLockObject(const RunnableInstance& WrapperOwner,
            std::chrono::milliseconds Timeout = LockObjectTimeoutDefault) const
        {
            std::shared_ptr<ConstObjectType> DestinyShared;
 
            // While object where DestinyResource points to is being destroyed, DestinyResource
            // should already be marked as expired, so this is thread-safe.
            DestinyShared = DestinyResource.lock();
 
            if (!DestinyShared)
                return nullptr;
 
            return std::make_unique<LinkedObjectWrapper<ConstObjectType>>(WrapperOwner, std::move(DestinyShared), Timeout);
        }
 
        auto LockObject(const RunnableInstance& WrapperOwner, std::chrono::milliseconds Timeout = LockObjectTimeoutDefault) const
        {
            auto ObjectWrapperPtr = TryLockObject(WrapperOwner, Timeout);
 
            if (!ObjectWrapperPtr)
                throw Util::InvalidObjectLinkException();
 
            return ObjectWrapperPtr;
        }
 
        std::weak_ptr<ObjectType> DestinyResource;
    };
 
    class RunnableInstance : public Util::INonCopyable
    {
    protected:
        RunnableInstance(RunnableObject& Owner, std::promise<void>&& ThreadExitedPromise);
 
        RunnableInstance(RunnableInstance&& Other);
 
        ~RunnableInstance();
 
    public:
        const auto& GetOwner() const noexcept { return Owner; }     
 
        template <typename ObjectT>
        void TryLockObject(const ParamsBase::Param<ObjectLink<ObjectT>>& LinkParam,
            LinkedObjectWrapperContainer<ObjectT>& ObjectWrapperContainer,
            std::chrono::milliseconds Timeout = ObjectLinkBase::LockObjectTimeoutDefault)
        {
            ObjectWrapperContainer.SetLinkedObjWrapperPtr(StoreLockedObject(LinkParam.GetLink().TryLockObject(*this, Timeout), ObjectWrapperContainer));
        }
 
        template <typename ObjectT>
        void LockObject(const ParamsBase::Param<ObjectLink<ObjectT>>& LinkParam,
            LinkedObjectWrapperContainer<ObjectT>& ObjectWrapperContainer,
            std::chrono::milliseconds Timeout = ObjectLinkBase::LockObjectTimeoutDefault)
        {
            ObjectWrapperContainer.SetLinkedObjWrapperPtr(StoreLockedObject(LinkParam.GetLink().LockObject(*this, Timeout), ObjectWrapperContainer));
        }
 
        template <typename ObjectT>
        void UnlockObject(LinkedObjectWrapperContainer<ObjectT>& ObjectWrapperContainer)
        {
            // Destroys corresponding LinkedObjectWrapperBase and thereby deregisters from
            // LinkedObjectWrapper::DestinyResource.
            if (ObjectWrapperContainer.LinkedObjWrapperPtr)
                OwnedLinkedObjectWrappers.erase(ObjectWrapperContainer.LinkedObjWrapperPtr->ListPos);
 
            ObjectWrapperContainer.Reset();
        }
 
        // TryLockObject() is not overloaded for object link list parameters since it is not clear what
        // to do with already locked objects when trying to lock another list of objects fails. If
        // the previously locked objects were unlocked before, then the state after a failed call to
        // TryLockObject() would not be the same as before.
 
        template <typename ObjectT>
        void LockObject(const ParamsBase::ListParam<ObjectLink<ObjectT>>& LinkListParam,
            LinkedObjectWrapperContainerList<ObjectT>& ObjectWrapperContainerList,
            std::chrono::milliseconds Timeout = ObjectLinkBase::LockObjectTimeoutDefault)
        {
            // Ensure that ObjectWrapperContainerList is empty before locking.
            UnlockObject(ObjectWrapperContainerList);
 
            for (const auto& Link : LinkListParam.GetLinks())
            {
                // Create new container in place since StoreLockedObject() stores a reference to it...
                ObjectWrapperContainerList.Containers.emplace_back(std::make_unique<LinkedObjectWrapperContainer<ObjectT>>());
                const auto& Container = ObjectWrapperContainerList.Containers.back();   // noexcept
 
                try
                {
                    // ... and fill it.
                    Container->SetLinkedObjWrapperPtr(StoreLockedObject(Link.LockObject(*this, Timeout), *Container));
 
                    ObjectWrapperContainerList.ObjectLabels.emplace_back((*Container)->GetObjectName() + " (" + (*Container)->GetCategoryAndName() + ")");
                }
                catch (...)
                {
                    // In case locking object or storing label fails, remove the container again.
                    UnlockObject(*Container);
                    ObjectWrapperContainerList.Containers.pop_back();
 
                    throw;
                }
            }
 
            if (!LinkListParam.IsOptional() && ObjectWrapperContainerList.Containers.empty())
                throw Util::EmptyException("A non-optional object link list parameter is empty.");
 
            ObjectWrapperContainerList.IconPath = LinkListParam.GetIconResourcePath();
        }
 
        template <typename ObjectT>
        void UnlockObject(LinkedObjectWrapperContainerList<ObjectT>& ObjectWrapperContainerList)
        {
            for (const auto& Container : ObjectWrapperContainerList.Containers)
                UnlockObject(*Container);
 
            ObjectWrapperContainerList.Containers.clear();
            ObjectWrapperContainerList.ObjectLabels.clear();
            ObjectWrapperContainerList.IconPath.clear();
        }
 
        bool CareAboutWrappers();
 
        std::string GetNotReadyObjectNamesString() const;
 
        const Object::ParamsGetterType ParamsGetter;
 
    private:
        void SetThreadExited();
 
        template <typename ObjectT>
        decltype(auto) StoreLockedObject(std::unique_ptr<LinkedObjectWrapper<ObjectT>>&& ObjectWrapperPtr,
            LinkedObjectWrapperContainerBase& ObjectWrapperContainer)
        {
            OwnedLinkedObjectWrappers.emplace_back(std::move(ObjectWrapperPtr), ObjectWrapperContainer);
 
            auto ObjectWrapperIterator = --OwnedLinkedObjectWrappers.end();
            ObjectWrapperIterator->OwnedLinkedObjectWrapperPtr.get()->ListPos = ObjectWrapperIterator;
 
            // Cast should never fail. Reference version since this would throw if it failed.
            return &dynamic_cast<typename LinkedObjectWrapperPointer<ObjectT>::LinkedObjectWrapperType&>(*ObjectWrapperIterator->OwnedLinkedObjectWrapperPtr.get());
        }
 
        const RunnableObject& Owner;
 
        std::promise<void> ThreadExitedPromise;
 
        bool Empty = false;
 
        LinkedObjectWrapperBase::ListType OwnedLinkedObjectWrappers;
    };
}