merge development

Signed-off-by: chcurran <82187351+carlitosan@users.noreply.github.com>

Code/Framework/AzCore/AzCore/Component/ComponentApplication.cpp

@@ -728,6 +728,7 @@ namespace AZ
         DestroyReflectionManager();
 
         static_cast<SettingsRegistryImpl*>(m_settingsRegistry.get())->ClearNotifiers();
+        static_cast<SettingsRegistryImpl*>(m_settingsRegistry.get())->ClearMergeEvents();
 
         // Uninit and unload any dynamic modules.
         m_moduleManager->UnloadModules();

Code/Framework/AzCore/AzCore/EBus/Event.h

@@ -58,6 +58,12 @@ namespace AZ
 
         Event& operator=(Event&& rhs);
 
+        //! Take the handlers registered with the other event
+        //! and move them to this event. The other will event
+        //! will be cleared after call
+        //! @param other event to move handlers
+        Event& ClaimHandlers(Event&& other);
+
         //! Returns true if at least one handler is connected to this event.
         bool HasHandlerConnected() const;
 

Code/Framework/AzCore/AzCore/EBus/Event.inl

@@ -207,6 +207,32 @@ namespace AZ
     }
 
 
+    template <typename... Params>
+    auto Event<Params...>::ClaimHandlers(Event&& other) -> Event&
+    {
+        auto handlers = AZStd::move(other.m_handlers);
+        auto addList = AZStd::move(other.m_addList);
+        other.m_freeList = {};
+        other.m_updating = false;
+
+        AZStd::array handlerContainers{ &handlers, &addList };
+        for (AZStd::vector<Handler*>* handlerList : handlerContainers)
+        {
+            for (Handler* handler : *handlerList)
+            {
+                if (handler != nullptr)
+                {
+                    handler->m_index = 0;
+                    handler->m_event = this;
+                    Connect(*handler);
+                }
+            }
+        }
+
+        return *this;
+    }
+
+
     template <typename... Params>
     bool Event<Params...>::HasHandlerConnected() const
     {

Code/Framework/AzCore/AzCore/Settings/SettingsRegistry.h

@@ -123,6 +123,36 @@ namespace AZ
         using NotifyEvent = AZ::Event<AZStd::string_view, Type>;
         using NotifyEventHandler = typename NotifyEvent::Handler;
 
+        using PreMergeEventCallback = AZStd::function<void(AZStd::string_view path, AZStd::string_view rootKey)>;
+        using PostMergeEventCallback = AZStd::function<void(AZStd::string_view path, AZStd::string_view rootKey)>;
+        using PreMergeEvent = AZ::Event<AZStd::string_view, AZStd::string_view>;
+        using PostMergeEvent = AZ::Event<AZStd::string_view, AZStd::string_view>;
+        using PreMergeEventHandler = typename PreMergeEvent::Handler;
+        using PostMergeEventHandler = typename PostMergeEvent::Handler;
+
+        struct ScopedMergeEvent
+        {
+            ScopedMergeEvent(
+                PreMergeEvent& preMergeEvent, PostMergeEvent& postMergeEvent, AZStd::string_view filePath, AZStd::string_view rootKey)
+                : m_preMergeEvent{ preMergeEvent }
+                , m_postMergeEvent{ postMergeEvent }
+                , m_filePath{ filePath }
+                , m_rootKey{ rootKey }
+            {
+                preMergeEvent.Signal(m_filePath, m_rootKey);
+            }
+
+            ~ScopedMergeEvent()
+            {
+                m_postMergeEvent.Signal(m_filePath, m_rootKey);
+            }
+
+            PreMergeEvent& m_preMergeEvent;
+            PostMergeEvent& m_postMergeEvent;
+            AZStd::string_view m_filePath;
+            AZStd::string_view m_rootKey;
+        };
+
         using VisitorCallback =
             AZStd::function<VisitResponse(AZStd::string_view path, AZStd::string_view valueName, VisitAction action, Type type)>;
         //! Base class for the visitor class during traversal over the Settings Registry. The type-agnostic function is always
@@ -169,6 +199,20 @@ namespace AZ
         //! @callback The function to call when an entry gets a new/updated value.
         [[nodiscard]] virtual NotifyEventHandler RegisterNotifier(NotifyCallback&& callback) = 0;
 
+        //! Register a function that will be called before a file is merged.
+        //! @callback The function to call before a file is merged.
+        [[nodiscard]] virtual PreMergeEventHandler RegisterPreMergeEvent(const PreMergeEventCallback& callback) = 0;
+        //! Register a function that will be called before a file is merged.
+        //! @callback The function to call before a file is merged.
+        [[nodiscard]] virtual PreMergeEventHandler RegisterPreMergeEvent (PreMergeEventCallback&& callback) = 0;
+
+        //! Register a function that will be called after a file is merged.
+        //! @callback The function to call after a file is merged.
+        [[nodiscard]] virtual PostMergeEventHandler RegisterPostMergeEvent(const PostMergeEventCallback& callback) = 0;
+        //! Register a function that will be called after a file is merged.
+        //! @callback The function to call after a file is merged.
+        [[nodiscard]] virtual PostMergeEventHandler RegisterPostMergeEvent (PostMergeEventCallback&& callback) = 0;
+
         //! Gets the boolean value at the provided path.
         //! @param result The target to write the result to.
         //! @param path The path to the value.

Code/Framework/AzCore/AzCore/Settings/SettingsRegistryImpl.cpp

@@ -20,7 +20,7 @@
 namespace AZ
 {
     template<typename T>
-    bool SettingsRegistryImpl::SetValueInternal(AZStd::string_view path, T value, SettingsRegistryInterface::Type type)
+    bool SettingsRegistryImpl::SetValueInternal(AZStd::string_view path, T value)
     {
         if (path.empty())
         {
@@ -56,7 +56,6 @@ namespace AZ
                 static_assert(!AZStd::is_same_v<T, T>, "SettingsRegistryImpl::SetValueInternal called with unsupported type.");
             }
 
-            m_notifiers.Signal(path, type);
             return true;
         }
         return false;
@@ -157,11 +156,11 @@ namespace AZ
             // Setting to empty string to prevent assert
             path = "";
         }
-        AZStd::scoped_lock lock(m_settingMutex);
 
         rapidjson::Pointer pointer(path.data(), path.length());
         if (pointer.IsValid())
         {
+            AZStd::scoped_lock lock(m_settingMutex);
             const rapidjson::Value* value = pointer.Get(m_settings);
             if (value)
             {
@@ -207,7 +206,7 @@ namespace AZ
     {
         NotifyEventHandler notifyHandler{ callback };
         {
-            AZStd::scoped_lock lock(m_settingMutex);
+            AZStd::scoped_lock lock(m_notifierMutex);
             notifyHandler.Connect(m_notifiers);
         }
         return notifyHandler;
@@ -217,7 +216,7 @@ namespace AZ
     {
         NotifyEventHandler notifyHandler{ AZStd::move(callback) };
         {
-            AZStd::scoped_lock lock(m_settingMutex);
+            AZStd::scoped_lock lock(m_notifierMutex);
             notifyHandler.Connect(m_notifiers);
         }
         return notifyHandler;
@@ -225,10 +224,82 @@ namespace AZ
 
     void SettingsRegistryImpl::ClearNotifiers()
     {
-        AZStd::scoped_lock lock(m_settingMutex);
+        AZStd::scoped_lock lock(m_notifierMutex);
         m_notifiers.DisconnectAllHandlers();
     }
 
+    auto SettingsRegistryImpl::RegisterPreMergeEvent(const PreMergeEventCallback& callback) -> PreMergeEventHandler
+    {
+        PreMergeEventHandler preMergeHandler{ callback };
+        {
+            AZStd::scoped_lock lock(m_settingMutex);
+            preMergeHandler.Connect(m_preMergeEvent);
+        }
+        return preMergeHandler;
+    }
+
+    auto SettingsRegistryImpl::RegisterPreMergeEvent(PreMergeEventCallback&& callback) -> PreMergeEventHandler
+    {
+        PreMergeEventHandler preMergeHandler{ AZStd::move(callback) };
+        {
+            AZStd::scoped_lock lock(m_settingMutex);
+            preMergeHandler.Connect(m_preMergeEvent);
+        }
+        return preMergeHandler;
+    }
+
+    auto SettingsRegistryImpl::RegisterPostMergeEvent(const PostMergeEventCallback& callback) -> PostMergeEventHandler
+    {
+        PostMergeEventHandler postMergeHandler{ callback };
+        {
+            AZStd::scoped_lock lock(m_settingMutex);
+            postMergeHandler.Connect(m_postMergeEvent);
+        }
+        return postMergeHandler;
+    }
+
+    auto SettingsRegistryImpl::RegisterPostMergeEvent(PostMergeEventCallback&& callback) -> PostMergeEventHandler
+    {
+        PostMergeEventHandler postMergeHandler{ AZStd::move(callback) };
+        {
+            AZStd::scoped_lock lock(m_settingMutex);
+            postMergeHandler.Connect(m_postMergeEvent);
+        }
+        return postMergeHandler;
+    }
+
+    void SettingsRegistryImpl::ClearMergeEvents()
+    {
+        AZStd::scoped_lock lock(m_settingMutex);
+        m_preMergeEvent.DisconnectAllHandlers();
+        m_postMergeEvent.DisconnectAllHandlers();
+    }
+
+    void SettingsRegistryImpl::SignalNotifier(AZStd::string_view jsonPath, Type type)
+    {
+        // Move the Notifier AZ::Event to a local AZ::Event in order to allow
+        // the notifier handlers to be signaled outside of the notifier mutex
+        // This allows other threads to register notifiers while this thread
+        // is invoking the handlers
+        decltype(m_notifiers) localNotifierEvent;
+        {
+            AZStd::scoped_lock lock(m_notifierMutex);
+            localNotifierEvent = AZStd::move(m_notifiers);
+        }
+
+        localNotifierEvent.Signal(jsonPath, type);
+
+        {
+            // Swap the local handlers with the current m_notifiers which
+            // will contain any handlers added during the signaling of the
+            // local event
+            AZStd::scoped_lock lock(m_notifierMutex);
+            AZStd::swap(m_notifiers, localNotifierEvent);
+            // Append any added handlers to the m_notifier structure
+            m_notifiers.ClaimHandlers(AZStd::move(localNotifierEvent));
+        }
+    }
+
     SettingsRegistryInterface::Type SettingsRegistryImpl::GetType(AZStd::string_view path) const
     {
         if (path.empty())
@@ -239,11 +310,11 @@ namespace AZ
             path = "";
         }
 
-        AZStd::scoped_lock lock(m_settingMutex);
 
         rapidjson::Pointer pointer(path.data(), path.length());
         if (pointer.IsValid())
         {
+            AZStd::scoped_lock lock(m_settingMutex);
             const rapidjson::Value* value = pointer.Get(m_settings);
             if (value)
             {
@@ -316,11 +387,11 @@ namespace AZ
             // Setting to empty string to prevent assert
             path = "";
         }
-        AZStd::scoped_lock lock(m_settingMutex);
 
         rapidjson::Pointer pointer(path.data(), path.length());
         if (pointer.IsValid())
         {
+            AZStd::scoped_lock lock(m_settingMutex);
             const rapidjson::Value* value = pointer.Get(m_settings);
             if (value)
             {
@@ -333,32 +404,52 @@ namespace AZ
 
     bool SettingsRegistryImpl::Set(AZStd::string_view path, bool value)
     {
-        AZStd::scoped_lock lock(m_settingMutex);
-        return SetValueInternal(path, value, Type::Boolean);
+        if (AZStd::scoped_lock lock(m_settingMutex); !SetValueInternal(path, value))
+        {
+            return false;
+        }
+        SignalNotifier(path, Type::Boolean);
+        return true;
     }
 
     bool SettingsRegistryImpl::Set(AZStd::string_view path, s64 value)
     {
-        AZStd::scoped_lock lock(m_settingMutex);
-        return SetValueInternal(path, value, Type::Integer);
+        if (AZStd::scoped_lock lock(m_settingMutex); !SetValueInternal(path, value))
+        {
+            return false;
+        }
+        SignalNotifier(path, Type::Integer);
+        return true;
     }
 
     bool SettingsRegistryImpl::Set(AZStd::string_view path, u64 value)
     {
-        AZStd::scoped_lock lock(m_settingMutex);
-        return SetValueInternal(path, value, Type::Integer);
+        if (AZStd::scoped_lock lock(m_settingMutex); !SetValueInternal(path, value))
+        {
+            return false;
+        }
+        SignalNotifier(path, Type::Integer);
+        return true;
     }
 
     bool SettingsRegistryImpl::Set(AZStd::string_view path, double value)
     {
-        AZStd::scoped_lock lock(m_settingMutex);
-        return SetValueInternal(path, value, Type::FloatingPoint);
+        if (AZStd::scoped_lock lock(m_settingMutex); !SetValueInternal(path, value))
+        {
+            return false;
+        }
+        SignalNotifier(path, Type::FloatingPoint);
+        return true;
     }
 
     bool SettingsRegistryImpl::Set(AZStd::string_view path, AZStd::string_view value)
     {
-        AZStd::scoped_lock lock(m_settingMutex);
-        return SetValueInternal(path, value, Type::String);
+        if (AZStd::scoped_lock lock(m_settingMutex); !SetValueInternal(path, value))
+        {
+            return false;
+        }
+        SignalNotifier(path, Type::String);
+        return true;
     }
 
     bool SettingsRegistryImpl::Set(AZStd::string_view path, const char* value)
@@ -376,7 +467,6 @@ namespace AZ
             path = "";
         }
 
-        AZStd::scoped_lock lock(m_settingMutex);
 
         rapidjson::Pointer pointer(path.data(), path.length());
         if (pointer.IsValid())
@@ -386,9 +476,10 @@ namespace AZ
                 value, nullptr, valueTypeID, m_serializationSettings);
             if (jsonResult.GetProcessing() != JsonSerializationResult::Processing::Halted)
             {
+                AZStd::scoped_lock lock(m_settingMutex);
                 rapidjson::Value& setting = pointer.Create(m_settings, m_settings.GetAllocator());
                 setting = AZStd::move(store);
-                m_notifiers.Signal(path, Type::Object);
+                SignalNotifier(path, Type::Object);
                 return true;
             }
         }
@@ -404,13 +495,13 @@ namespace AZ
             // Setting to empty string to prevent assert
             path = "";
         }
-        AZStd::scoped_lock lock(m_settingMutex);
         rapidjson::Pointer pointerPath(path.data(), path.size());
         if (!pointerPath.IsValid())
         {
             return false;
         }
 
+        AZStd::scoped_lock lock(m_settingMutex);
         return pointerPath.Erase(m_settings);
     }
 
@@ -540,7 +631,7 @@ namespace AZ
             return false;
         }
 
-        m_notifiers.Signal("", Type::Object);
+        SignalNotifier("", Type::Object);
 
         return true;
     }
@@ -562,8 +653,6 @@ namespace AZ
             scratchBuffer = &buffer;
         }
 
-        AZStd::scoped_lock lock(m_settingMutex);
-
         bool result = false;
         if (path[path.length()] == 0)
         {
@@ -577,6 +666,8 @@ namespace AZ
                     R"(Path "%.*s" is too long. Either make sure that the provided path is terminated or use a shorter path.)",
                     static_cast<int>(path.length()), path.data());
                 Pointer pointer(AZ_SETTINGS_REGISTRY_HISTORY_KEY "/-");
+
+                AZStd::scoped_lock lock(m_settingMutex);
                 Value pathValue(path.data(), aznumeric_caster(path.length()), m_settings.GetAllocator());
                 pointer.Create(m_settings, m_settings.GetAllocator()).SetObject()
                     .AddMember(StringRef("Error"), StringRef("Unable to read registry file."), m_settings.GetAllocator())
@@ -622,6 +713,7 @@ namespace AZ
         {
             AZ_Error("Settings Registry", false, "Folder path for the Setting Registry is too long: %.*s",
                 static_cast<int>(path.size()), path.data());
+            AZStd::scoped_lock lock(m_settingMutex);
             pointer.Create(m_settings, m_settings.GetAllocator()).SetObject()
                 .AddMember(StringRef("Error"), StringRef("Folder path for the Setting Registry is too long."), m_settings.GetAllocator())
                 .AddMember(StringRef("Path"), Value(path.data(), aznumeric_caster(path.length()), m_settings.GetAllocator()), m_settings.GetAllocator());
@@ -659,6 +751,7 @@ namespace AZ
                 if (fileList.size() >= MaxRegistryFolderEntries)
                 {
                     AZ_Error("Settings Registry", false, "Too many files in registry folder.");
+                    AZStd::scoped_lock lock(m_settingMutex);
                     pointer.Create(m_settings, m_settings.GetAllocator()).SetObject()
                         .AddMember(StringRef("Error"), StringRef("Too many files in registry folder."), m_settings.GetAllocator())
                         .AddMember(StringRef("Path"), Value(folderPath.c_str(), aznumeric_caster(folderPath.size()), m_settings.GetAllocator()), m_settings.GetAllocator())
@@ -678,7 +771,6 @@ namespace AZ
         SystemFile::FindFiles(folderPath.c_str(), callback);
 
 
-        AZStd::scoped_lock lock(m_settingMutex);
         if (!platform.empty())
         {
             // Move the folderPath prefix back to the supplied path before the wildcard
@@ -696,6 +788,7 @@ namespace AZ
                     if (fileList.size() >= MaxRegistryFolderEntries)
                     {
                         AZ_Error("Settings Registry", false, "Too many files in registry folder.");
+                        AZStd::scoped_lock lock(m_settingMutex);
                         pointer.Create(m_settings, m_settings.GetAllocator()).SetObject()
                             .AddMember(StringRef("Error"), StringRef("Too many files in registry folder."), m_settings.GetAllocator())
                             .AddMember(StringRef("Path"), Value(folderPath.c_str(), aznumeric_caster(folderPath.size()), m_settings.GetAllocator()), m_settings.GetAllocator())
@@ -923,6 +1016,8 @@ namespace AZ
         collisionFound = true;
         AZ_Error("Settings Registry", false, R"(Two registry files in "%.*s" point to the same specialization: "%s" and "%s")",
             AZ_STRING_ARG(folderPath), lhs.m_relativePath.c_str(), rhs.m_relativePath.c_str());
+
+        AZStd::scoped_lock lock(m_settingMutex);
         historyPointer.Create(m_settings, m_settings.GetAllocator()).SetObject()
             .AddMember(StringRef("Error"), StringRef("Too many files in registry folder."), m_settings.GetAllocator())
             .AddMember(StringRef("Path"),
@@ -1077,6 +1172,7 @@ namespace AZ
                 }
             }
             
+            AZStd::scoped_lock lock(m_settingMutex);
             pointer.Create(m_settings, m_settings.GetAllocator()).SetObject()
                 .AddMember(StringRef("Error"), StringRef("Unable to parse registry file due to invalid json."), m_settings.GetAllocator())
                 .AddMember(StringRef("Path"), Value(path, m_settings.GetAllocator()), m_settings.GetAllocator())
@@ -1102,6 +1198,7 @@ namespace AZ
                     R"(To merge the supplied settings registry file, the settings within it must be placed within a JSON Object '{}')"
                     R"( in order to allow moving of its fields using the root-key as an anchor.)", path);
 
+                AZStd::scoped_lock lock(m_settingMutex);
                 pointer.Create(m_settings, m_settings.GetAllocator()).SetObject()
                     .AddMember(StringRef("Error"), StringRef("Cannot merge registry file with a root which is not a JSON Object,"
                         " an empty root key and a merge approach of JsonMergePatch. Otherwise the Settings Registry would be overridden."
@@ -1115,9 +1212,12 @@ namespace AZ
             return false;
         }
 
+        ScopedMergeEvent scopedMergeEvent(m_preMergeEvent, m_postMergeEvent, path, rootKey);
+
         JsonSerializationResult::ResultCode mergeResult(JsonSerializationResult::Tasks::Merge);
         if (rootKey.empty())
         {
+            AZStd::scoped_lock lock(m_settingMutex);
             mergeResult = JsonSerialization::ApplyPatch(m_settings, m_settings.GetAllocator(), jsonPatch, mergeApproach, m_applyPatchSettings);
         }
         else
@@ -1125,6 +1225,7 @@ namespace AZ
             Pointer root(rootKey.data(), rootKey.length());
             if (root.IsValid())
             {
+                AZStd::scoped_lock lock(m_settingMutex);
                 Value& rootValue = root.Create(m_settings, m_settings.GetAllocator());
                 mergeResult = JsonSerialization::ApplyPatch(rootValue, m_settings.GetAllocator(), jsonPatch, mergeApproach, m_applyPatchSettings);
             }
@@ -1132,6 +1233,7 @@ namespace AZ
             {
                 AZ_Error("Settings Registry", false, R"(Failed to root path "%.*s" is invalid.)",
                     aznumeric_cast<int>(rootKey.length()), rootKey.data());
+                AZStd::scoped_lock lock(m_settingMutex);
                 pointer.Create(m_settings, m_settings.GetAllocator()).SetObject()
                     .AddMember(StringRef("Error"), StringRef("Invalid root key."), m_settings.GetAllocator())
                     .AddMember(StringRef("Path"), Value(path, m_settings.GetAllocator()), m_settings.GetAllocator());
@@ -1141,15 +1243,19 @@ namespace AZ
         if (mergeResult.GetProcessing() != JsonSerializationResult::Processing::Completed)
         {
             AZ_Error("Settings Registry", false, R"(Failed to fully merge registry file "%s".)", path);
+            AZStd::scoped_lock lock(m_settingMutex);
             pointer.Create(m_settings, m_settings.GetAllocator()).SetObject()
                 .AddMember(StringRef("Error"), StringRef("Failed to fully merge registry file."), m_settings.GetAllocator())
                 .AddMember(StringRef("Path"), Value(path, m_settings.GetAllocator()), m_settings.GetAllocator());
             return false;
         }
 
-        pointer.Create(m_settings, m_settings.GetAllocator()).SetString(path, m_settings.GetAllocator());
+        {
+            AZStd::scoped_lock lock(m_settingMutex);
+            pointer.Create(m_settings, m_settings.GetAllocator()).SetString(path, m_settings.GetAllocator());
+        }
 
-        m_notifiers.Signal("", Type::Object);
+        SignalNotifier("", Type::Object);
 
         return true;
     }

Code/Framework/AzCore/AzCore/Settings/SettingsRegistryImpl.h

@@ -48,6 +48,12 @@ namespace AZ
         [[nodiscard]] NotifyEventHandler RegisterNotifier(NotifyCallback&& callback) override;
         void ClearNotifiers();
 
+        [[nodiscard]] PreMergeEventHandler RegisterPreMergeEvent(const PreMergeEventCallback& callback) override;
+        [[nodiscard]] PreMergeEventHandler RegisterPreMergeEvent(PreMergeEventCallback&& callback) override;
+        [[nodiscard]] PostMergeEventHandler RegisterPostMergeEvent(const PostMergeEventCallback& callback) override;
+        [[nodiscard]] PostMergeEventHandler RegisterPostMergeEvent(PostMergeEventCallback&& callback) override;
+        void ClearMergeEvents();
+
         bool Get(bool& result, AZStd::string_view path) const override;
         bool Get(s64& result, AZStd::string_view path) const override;
         bool Get(u64& result, AZStd::string_view path) const override;
@@ -89,7 +95,7 @@ namespace AZ
         using RegistryFileList = AZStd::fixed_vector<RegistryFile, MaxRegistryFolderEntries>;
 
         template<typename T>
-        bool SetValueInternal(AZStd::string_view path, T value, SettingsRegistryInterface::Type type);
+        bool SetValueInternal(AZStd::string_view path, T value);
         template<typename T>
         bool GetValueInternal(T& result, AZStd::string_view path) const;
         VisitResponse Visit(Visitor& visitor, StackedString& path, AZStd::string_view valueName,
@@ -100,9 +106,15 @@ namespace AZ
             const rapidjson::Pointer& historyPointer, AZStd::string_view folderPath);
         bool ExtractFileDescription(RegistryFile& output, const char* filename, const Specializations& specializations);
         bool MergeSettingsFileInternal(const char* path, Format format, AZStd::string_view rootKey, AZStd::vector<char>& scratchBuffer);
+
+        void SignalNotifier(AZStd::string_view jsonPath, Type type);
         
         mutable AZStd::recursive_mutex m_settingMutex;
+        mutable AZStd::recursive_mutex m_notifierMutex;
         NotifyEvent m_notifiers;
+        PreMergeEvent m_preMergeEvent;
+        PostMergeEvent m_postMergeEvent;
+
         rapidjson::Document m_settings;
         JsonSerializerSettings m_serializationSettings;
         JsonDeserializerSettings m_deserializationSettings;

Code/Framework/AzCore/AzCore/UnitTest/Mocks/MockSettingsRegistry.h

@@ -25,6 +25,10 @@ namespace AZ
         MOCK_CONST_METHOD2(Visit, bool(const VisitorCallback&, AZStd::string_view));
         MOCK_METHOD1(RegisterNotifier, NotifyEventHandler(const NotifyCallback&));
         MOCK_METHOD1(RegisterNotifier, NotifyEventHandler(NotifyCallback&&));
+        MOCK_METHOD1(RegisterPreMergeEvent, PreMergeEventHandler(const PreMergeEventCallback&));
+        MOCK_METHOD1(RegisterPreMergeEvent, PreMergeEventHandler(PreMergeEventCallback&&));
+        MOCK_METHOD1(RegisterPostMergeEvent, PostMergeEventHandler(const PostMergeEventCallback&));
+        MOCK_METHOD1(RegisterPostMergeEvent, PostMergeEventHandler(PostMergeEventCallback&&));
 
         MOCK_CONST_METHOD2(Get, bool(bool&, AZStd::string_view));
         MOCK_CONST_METHOD2(Get, bool(s64&, AZStd::string_view));

Code/Framework/AzCore/Tests/EventTests.cpp

@@ -240,6 +240,37 @@ namespace UnitTest
         static_assert(!AZStd::is_copy_assignable_v<AZ::Event<int32_t>>, "AZ Events should not be copy assignable");
     }
 
+    TEST_F(EventTests, TestClaimHandlers_TakesAllSourceHandlers)
+    {
+        AZ::Event<> testEvent1;
+        AZ::Event<> testEvent2;
+
+        int32_t handlerInvokeCount{};
+        auto handlerCallback = [&handlerInvokeCount]()
+        {
+            ++handlerInvokeCount;
+        };
+        AZ::Event<>::Handler testHandler1(handlerCallback);
+        AZ::Event<>::Handler testHandler2(handlerCallback);
+
+        testHandler1.Connect(testEvent1);
+        testHandler2.Connect(testEvent2);
+
+        EXPECT_TRUE(testEvent1.HasHandlerConnected());
+        EXPECT_TRUE(testEvent2.HasHandlerConnected());
+
+        testEvent1.ClaimHandlers(AZStd::move(testEvent2));
+        EXPECT_TRUE(testEvent1.HasHandlerConnected());
+        EXPECT_FALSE(testEvent2.HasHandlerConnected());
+
+        // testEvent1 should have both handlers
+        testEvent1.Signal();
+        EXPECT_EQ(2, handlerInvokeCount);
+        // testEvent2 should have neither of the handlers
+        testEvent2.Signal();
+        EXPECT_EQ(2, handlerInvokeCount);
+    }
+
     TEST_F(EventTests, HandlerMoveAssignment_ProperlyDisconnectsFromOldEvent)
     {
         AZ::Event<> testEvent1;