Fixed logic in the Compression/Decompression gem registration (#13731)

* Fixed logic in the Compression/Decompression gem registration

Renamed the CompressionFactory and DecompressionFactory classes to
CompressionRegistrar and DecompressionRegistrar

fixes #12030

Signed-off-by: lumberyard-employee-dm <[email protected]>

* Updated doxygen comments and API to fix inconstencies

Signed-off-by: lumberyard-employee-dm <[email protected]>

Signed-off-by: lumberyard-employee-dm <[email protected]>

Gems/Compression/Code/Include/Compression/CompressionInterfaceAPI.h

@@ -56,12 +56,11 @@ namespace Compression
             AZStd::span<AZStd::byte> compressedBuffer, const AZStd::span<const AZStd::byte>& uncompressedData) = 0;
     };
 
-    class CompressionFactoryInterface
+    class CompressionRegistrarInterface
     {
     public:
-        AZ_RTTI(CompressionFactoryInterface, "{92251FE8-9D19-4A23-9A2B-F91D99D9491B}");
-        virtual ~CompressionFactoryInterface() = default;
-
+        AZ_RTTI(CompressionRegistrarInterface, "{92251FE8-9D19-4A23-9A2B-F91D99D9491B}");
+        virtual ~CompressionRegistrarInterface() = default;
 
         //! Callback function that is invoked for every registered compression interface
         //! return true to indicate that visitation of compression interfaces should continue
@@ -70,28 +69,44 @@ namespace Compression
         //! Invokes the supplied visitor for each register compression interface that is non-nullptr
         virtual void VisitCompressionInterfaces(const VisitCompressionInterfaceCallback&) const = 0;
 
-        //! Registers a compression interface with the compression factory.
+        //! Registers compression interface and takes ownership of it if registration is successful
+        //! @param compressionAlgorithmId Unique id to associate with compression interface
+        //! @param compressionInterface compression interface to register
+        //! @return Success outcome if the compression interface was successfully registered
+        //! Otherwise, a failure outcome with the compression interface is forward back to the caller
+        virtual AZ::Outcome<void, AZStd::unique_ptr<ICompressionInterface>> RegisterCompressionInterface(
+            CompressionAlgorithmId compressionAlgorithmId, AZStd::unique_ptr<ICompressionInterface> compressionInterface) = 0;
+
+
+        //! Registers compression interface, but does not take ownership of it
         //! If a compression interface with a CompressionAlgorithmId is registered that
         //! matches the input compression interface, then registration does not occur
-        //! and the unique_ptr refererence is unmodified and can be re-used by the caller
         //!
-        //! @param compressionInterface unique pointer to compression interface to register
-        //! @return true if the ICompressionInterface was successfully registered, otherwise false
-        virtual bool RegisterCompressionInterface(AZStd::unique_ptr<ICompressionInterface>&&) = 0;
+        //! Registers compression interface, but does not take ownership of it
+        //! @param compressionAlgorithmId Unique id to associate with compression interface
+        //! @param compressionInterface compression interface to register
+        //! @return true if the ICompressionInterface was successfully registered
+        virtual bool RegisterCompressionInterface(CompressionAlgorithmId compressionAlgorithmId, ICompressionInterface& compressionInterface) = 0;
 
-        //! Unregisters the Compression Interface with the specified Id if it is registered with the factory
+        //! Unregisters the compression interface with the specified id
         //!
-        //! @param compressionAlgorithmId unique Id that identifies the Compression Interface
-        //! @return true if the ICompressionInterface was unregistered, otherwise false
-        virtual bool UnregisterCompressionInterface(CompressionAlgorithmId) = 0;
-
-        //! Queries the Compression Interface with the compression algorithmd Id
-        //! @param compressionAlgorithmId unique Id of Compression Interface to query
-        //! @return pointer to the Compression Interface or nullptr if not found
-        virtual ICompressionInterface* FindCompressionInterface(CompressionAlgorithmId) const = 0;
+        //! @param compressionAlgorithmId unique Id that identifies the compression interface
+        //! @return true if the unregistration is successful
+        virtual bool UnregisterCompressionInterface(CompressionAlgorithmId compressionAlgorithmId) = 0;
+
+        //! Queries the compression interface with the compression algorithmd Id
+        //! @param compressionAlgorithmId unique Id of compression interface to query
+        //! @return pointer to the compression interface or nullptr if not found
+        [[nodiscard]] virtual ICompressionInterface* FindCompressionInterface(CompressionAlgorithmId compressionAlgorithmId) const = 0;
+
+
+        //! Return true if there is an compression interface registered with the specified id
+        //! @param compressionAlgorithmId CompressionAlgorithmId to determine if an compression interface is registered
+        //! @return bool indicating if there is an compression interface with the id registered
+        [[nodiscard]] virtual bool IsRegistered(CompressionAlgorithmId compressionAlgorithmId) const = 0;
     };
 
-    using CompressionFactory = AZ::Interface<CompressionFactoryInterface>;
+    using CompressionRegistrar = AZ::Interface<CompressionRegistrarInterface>;
 
 } // namespace Compression
 

Gems/Compression/Code/Include/Compression/DecompressionInterfaceAPI.h

@@ -57,11 +57,11 @@ namespace Compression
             AZStd::span<AZStd::byte> uncompressedBuffer, const AZStd::span<const AZStd::byte>& compressedData) = 0;
     };
 
-    class DecompressionFactoryInterface
+    class DecompressionRegistrarInterface
     {
     public:
-        AZ_RTTI(DecompressionFactoryInterface, "{DB1ACA55-B36F-469B-9704-EC486D9FC810}");
-        virtual ~DecompressionFactoryInterface() = default;
+        AZ_RTTI(DecompressionRegistrarInterface, "{DB1ACA55-B36F-469B-9704-EC486D9FC810}");
+        virtual ~DecompressionRegistrarInterface() = default;
 
         //! Callback function that is invoked for every registered decompression interface
         //! return true to indicate that visitation of decompression interfaces should continue
@@ -70,28 +70,45 @@ namespace Compression
         //! Invokes the supplied visitor for each register decompression interface that is non-nullptr
         virtual void VisitDecompressionInterfaces(const VisitDecompressionInterfaceCallback&) const = 0;
 
-        //! Registers a decompression interface with the decompression factory.
+
+        //! Registers decompression interface and takes ownership of it if registration is successful
+        //! @param compressionAlgorithmId Unique id to associate with decompression interface
+        //! @param decompressionInterface decompression interface to register
+        //! @return Success outcome if the decompression interface was successfully registered
+        //! Otherwise, a failure outcome with the decompression interface is forward back to the caller
+        virtual AZ::Outcome<void, AZStd::unique_ptr<IDecompressionInterface>> RegisterDecompressionInterface(
+            CompressionAlgorithmId compressionAlgorithmId, AZStd::unique_ptr<IDecompressionInterface> decompressionInterface) = 0;
+
+
+        //! Registers decompression interface, but does not take ownership of it
         //! If a decompression interface with a CompressionAlgorithmId is registered that
         //! matches the input decompression interface, then registration does not occur
-        //! and the unique_ptr refererence is unmodified and can be re-used by the caller
         //!
-        //! @param decompressionInterface unique pointer to decompression interface to register
-        //! @return true if the IDecompressionInterface was successfully registered, otherwise false
-        virtual bool RegisterDecompressionInterface(AZStd::unique_ptr<IDecompressionInterface>&&) = 0;
+        //! Registers decompression interface, but does not take ownership of it
+        //! @param compressionAlgorithmId Unique id to associate with decompression interface
+        //! @param decompressionInterface decompression interface to register
+        //! @return true if the ICompressionInterface was successfully registered
+        virtual bool RegisterDecompressionInterface(CompressionAlgorithmId compressionAlgorithmId, IDecompressionInterface& decompressionInterface) = 0;
 
-        //! Unregisters the Decompression Interface with the specified Id if it is registered with the factory
+        //! Unregisters the decompression interface with the specified id
         //!
-        //! @param compressionAlgorithmId unique Id that identifies the Decompression Interface
-        //! @return true if the IDecompressionInterface was unregistered, otherwise false
-        virtual bool UnregisterDecompressionInterface(CompressionAlgorithmId) = 0;
-
-        //! Queries the Decompression Interface with the compression algorithmd Id
-        //! @param compressionAlgorithmId unique Id of Decompression Interface to query
-        //! @return pointer to the DeCompression Interface or nullptr if not found
-        virtual IDecompressionInterface* FindDecompressionInterface(CompressionAlgorithmId) const = 0;
+        //! @param decompressionAlgorithmId unique Id that identifies the decompression interface
+        //! @return true if the unregistration is successful
+        virtual bool UnregisterDecompressionInterface(CompressionAlgorithmId compressionAlgorithmId) = 0;
+
+        //! Queries the decompression interface with the decompression algorithmd Id
+        //! @param compressionAlgorithmId unique Id of decompression interface to query
+        //! @return pointer to the decompression tnterface or nullptr if not found
+        [[nodiscard]] virtual IDecompressionInterface* FindDecompressionInterface(CompressionAlgorithmId compressionAlgorithmId) const = 0;
+
+
+        //! Return true if there is an decompression interface registered with the specified id
+        //! @param compressionAlgorithmId CompressionAlgorithmId to determine if an decompression interface is registered
+        //! @return bool indicating if there is an decompression interface with the id registered
+        [[nodiscard]] virtual bool IsRegistered(CompressionAlgorithmId compressionAlgorithmId) const = 0;
     };
 
-    using DecompressionFactory = AZ::Interface<DecompressionFactoryInterface>;
+    using DecompressionRegistrar = AZ::Interface<DecompressionRegistrarInterface>;
 
 } // namespace Compression
 

Gems/Compression/Code/Include/Compression/DecompressionInterfaceAPI.inl

@@ -8,7 +8,6 @@
 
 #pragma once
 
-
 namespace Compression
 {
     //! Returns a boolean true if decompression has succeeded

Gems/Compression/Code/Source/Clients/CompressionModule.cpp

@@ -10,7 +10,7 @@
 #include <CompressionModuleInterface.h>
 #include "CompressionSystemComponent.h"
 #include <Compression/DecompressionInterfaceAPI.h>
-#include "DecompressionFactoryImpl.h"
+#include "DecompressionRegistrarImpl.h"
 
 namespace Compression
 {
@@ -23,25 +23,25 @@ namespace Compression
 
         CompressionModule()
         {
-            // Create and Register the Decompression Factory
-            m_decompressionFactoryInterface = AZStd::make_unique<DecompressionFactoryImpl>();
-            if (DecompressionFactory::Get() == nullptr)
+            // Create and Register the Decompression Registrar
+            m_decompressionRegistrarInterface = AZStd::make_unique<DecompressionRegistrarImpl>();
+            if (DecompressionRegistrar::Get() == nullptr)
             {
-                DecompressionFactory::Register(m_decompressionFactoryInterface.get());
+                DecompressionRegistrar::Register(m_decompressionRegistrarInterface.get());
             }
         }
 
         ~CompressionModule()
         {
-            if (DecompressionFactory::Get() == m_decompressionFactoryInterface.get())
+            if (DecompressionRegistrar::Get() == m_decompressionRegistrarInterface.get())
             {
-                DecompressionFactory::Unregister(m_decompressionFactoryInterface.get());
+                DecompressionRegistrar::Unregister(m_decompressionRegistrarInterface.get());
             }
         }
     private:
-        // DecompressionFactory interface used to register Decompression interfaces
+        // DecompressionRegistrar interface used to register Decompression interfaces
         // Available in ALL applications to allow decompression to occur
-        AZStd::unique_ptr<DecompressionFactoryInterface> m_decompressionFactoryInterface;
+        AZStd::unique_ptr<DecompressionRegistrarInterface> m_decompressionRegistrarInterface;
     };
 }// namespace Compression
 

Gems/Compression/Code/Source/Clients/DecompressionFactoryImpl.cpp

@@ -1,93 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#include "DecompressionFactoryImpl.h"
-#include <AzCore/std/functional.h>
-#include <AzCore/std/ranges/ranges_algorithm.h>
-
-namespace Compression
-{
-    DecompressionFactoryImpl::~DecompressionFactoryImpl() = default;
-
-    void DecompressionFactoryImpl::VisitDecompressionInterfaces(const VisitDecompressionInterfaceCallback& callback) const
-    {
-        auto VisitInterface = [&callback](const AZStd::unique_ptr<IDecompressionInterface>& decompressionInterface)
-        {
-            return decompressionInterface != nullptr ? callback(*decompressionInterface) : true;
-        };
-
-        AZStd::ranges::all_of(m_decompressionInterfaces, VisitInterface);
-    }
-
-    bool DecompressionFactoryImpl::RegisterDecompressionInterface(AZStd::unique_ptr<IDecompressionInterface>&& decompressionInterface)
-    {
-        if (decompressionInterface == nullptr)
-        {
-            return false;
-        }
-
-        CompressionAlgorithmId compressionAlgorithmId = decompressionInterface->GetCompressionAlgorithmId();
-        const size_t compressionIndex = FindDecompressionIndex(compressionAlgorithmId);
-        if (compressionIndex < m_decompressionInterfaces.size())
-        {
-            return false;
-        }
-
-        // Insert new compression interface since it is not registered
-        m_decompressionInterfaces.emplace_back(AZStd::move(decompressionInterface));
-        const size_t emplaceIndex = m_decompressionInterfaces.size() - 1;
-
-        // Use UpperBound to find the insertion slot for the new entry within the compression index set
-        auto FindIdIndexEntry = [](const DecompressionIdIndexEntry& lhs, const DecompressionIdIndexEntry& rhs)
-        {
-            return lhs.m_id < rhs.m_id;
-        };
-        DecompressionIdIndexEntry newEntry{ compressionAlgorithmId, emplaceIndex };
-        m_decompressionIdIndexSet.insert(AZStd::upper_bound(m_decompressionIdIndexSet.begin(), m_decompressionIdIndexSet.end(),
-            newEntry, AZStd::move(FindIdIndexEntry)),
-            AZStd::move(newEntry));
-        return true;
-    }
-
-    bool DecompressionFactoryImpl::UnregisterDecompressionInterface(CompressionAlgorithmId compressionAlgorithmId)
-    {
-        const size_t compressionIndex = FindDecompressionIndex(compressionAlgorithmId);
-        if (compressionIndex < m_decompressionInterfaces.size())
-        {
-            auto oldInterfaceIter = m_decompressionInterfaces.begin() + compressionIndex;
-            m_decompressionInterfaces.erase(oldInterfaceIter);
-            return true;
-        }
-
-        return false;
-    }
-
-    IDecompressionInterface* DecompressionFactoryImpl::FindDecompressionInterface(CompressionAlgorithmId compressionAlgorithmId) const
-    {
-        const size_t compressionIndex = FindDecompressionIndex(compressionAlgorithmId);
-        return compressionIndex < m_decompressionInterfaces.size()
-            ? m_decompressionInterfaces[compressionIndex].get() : nullptr;
-    }
-
-    // find decompression index entry in vector
-    // returns the index into the m_decompressionInterfaces vector that matches the compression algorithm Id
-    // otherwise returns the size of the m_decompressionInterfaces container to indicate out of bounds
-    size_t DecompressionFactoryImpl::FindDecompressionIndex(CompressionAlgorithmId compressionAlgorithmId) const
-    {
-        auto FindIdIndexEntry = [](const DecompressionIdIndexEntry& lhs, const DecompressionIdIndexEntry& rhs)
-        {
-            return lhs.m_id < rhs.m_id;
-        };
-        auto searchIter = AZStd::lower_bound(m_decompressionIdIndexSet.begin(), m_decompressionIdIndexSet.end(),
-            DecompressionIdIndexEntry{ compressionAlgorithmId }, FindIdIndexEntry);
-
-        return searchIter != m_decompressionIdIndexSet.end() && !FindIdIndexEntry(
-            DecompressionIdIndexEntry{ compressionAlgorithmId }, *searchIter) ?
-            searchIter->m_index : m_decompressionInterfaces.size();
-    }
-}// namespace Compression

Gems/Compression/Code/Source/Clients/DecompressionFactoryImpl.h

@@ -1,40 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#include <AzCore/std/containers/vector.h>
-#include <AzCore/Memory/SystemAllocator.h>
-#include <Compression/DecompressionInterfaceAPI.h>
-
-namespace Compression
-{
-    class DecompressionFactoryImpl final
-        : public DecompressionFactoryInterface
-    {
-    public:
-        AZ_RTTI(DecompressionFactoryImpl, "{2353362A-A059-4681-ADF0-5ABE41E85A6B}", DecompressionFactoryInterface);
-        AZ_CLASS_ALLOCATOR(DecompressionFactoryImpl, AZ::SystemAllocator, 0);
-
-        ~DecompressionFactoryImpl();
-
-        void VisitDecompressionInterfaces(const VisitDecompressionInterfaceCallback&) const override;
-        bool RegisterDecompressionInterface(AZStd::unique_ptr<IDecompressionInterface>&&) override;
-        bool UnregisterDecompressionInterface(CompressionAlgorithmId) override;
-        IDecompressionInterface* FindDecompressionInterface(CompressionAlgorithmId) const override;
-
-    private:
-        size_t FindDecompressionIndex(CompressionAlgorithmId) const;
-        struct DecompressionIdIndexEntry
-        {
-            CompressionAlgorithmId m_id;
-            size_t m_index;
-        };
-        //! Index into the Decompression Interfaces vector
-        AZStd::vector<DecompressionIdIndexEntry> m_decompressionIdIndexSet;
-        AZStd::vector<AZStd::unique_ptr<IDecompressionInterface>> m_decompressionInterfaces;
-    };
-}// namespace Compression

Gems/Compression/Code/Source/Clients/DecompressionRegistrarImpl.cpp

@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include "DecompressionRegistrarImpl.h"
+#include <AzCore/std/functional.h>
+#include <AzCore/std/parallel/scoped_lock.h>
+#include <AzCore/std/ranges/ranges_algorithm.h>
+
+namespace Compression
+{
+    DecompressionRegistrarImpl::DecompressionInterfaceDeleter::DecompressionInterfaceDeleter() = default;
+    DecompressionRegistrarImpl::DecompressionInterfaceDeleter::DecompressionInterfaceDeleter(bool shouldDelete)
+        : m_delete(shouldDelete)
+    {}
+
+    void DecompressionRegistrarImpl::DecompressionInterfaceDeleter::operator()(IDecompressionInterface* ptr) const
+    {
+        if (m_delete)
+        {
+            delete ptr;
+        }
+    }
+
+    DecompressionRegistrarImpl::DecompressionRegistrarImpl() = default;
+    DecompressionRegistrarImpl::~DecompressionRegistrarImpl() = default;
+
+    void DecompressionRegistrarImpl::VisitDecompressionInterfaces(const VisitDecompressionInterfaceCallback& callback) const
+    {
+        auto VisitInterface = [&callback](const DecompressionIdIndexEntry& decompressionInterfaceEntry)
+        {
+            return decompressionInterfaceEntry.m_decompressionInterface != nullptr ? callback(*decompressionInterfaceEntry.m_decompressionInterface) : true;
+        };
+
+        AZStd::scoped_lock lock(m_decompressionInterfaceMutex);
+        AZStd::ranges::all_of(m_decompressionInterfaces, VisitInterface);
+    }
+
+    AZ::Outcome<void, AZStd::unique_ptr<IDecompressionInterface>> DecompressionRegistrarImpl::RegisterDecompressionInterface(
+        CompressionAlgorithmId compressionAlgorithmId, AZStd::unique_ptr<IDecompressionInterface> decompressionInterface)
+    {
+        // Transfer ownership to a temporary DecompressionInterfacePtr which is supplied to the RegisterDecompressionInterfaceImpl
+        // If registration fails, the compression interface pointer is returned in the failure outcome
+        if (auto registerResult = RegisterDecompressionInterfaceImpl(compressionAlgorithmId, DecompressionInterfacePtr{ decompressionInterface.release() });
+            !registerResult.IsSuccess())
+        {
+            return AZ::Failure(AZStd::unique_ptr<IDecompressionInterface>(registerResult.TakeError().release()));
+        }
+
+        // registration succeeded, return a void success outcome
+        return AZ::Success();
+    }
+
+    bool DecompressionRegistrarImpl::RegisterDecompressionInterface(CompressionAlgorithmId compressionAlgorithmId,
+        IDecompressionInterface& decompressionInterface)
+    {
+        // Create a temporary DecompressionInterfacePtr with a custom deleter that does NOT delete the decompressionInterface reference
+        // On success, the the DecompressionInterfacePtr is stored in the decompression interface array
+        // and will not delete the reference to registered interface
+        return RegisterDecompressionInterfaceImpl(compressionAlgorithmId, DecompressionInterfacePtr{ &decompressionInterface, DecompressionInterfaceDeleter{false} }).IsSuccess();
+    }
+
+    auto DecompressionRegistrarImpl::RegisterDecompressionInterfaceImpl(CompressionAlgorithmId compressionAlgorithmId,
+        DecompressionInterfacePtr decompressionInterfacePtr)
+        -> AZ::Outcome<void, DecompressionInterfacePtr>
+    {
+        if (decompressionInterfacePtr == nullptr)
+        {
+            return AZ::Failure(AZStd::move(decompressionInterfacePtr));
+        }
+
+        AZStd::scoped_lock lock(m_decompressionInterfaceMutex);
+        auto decompressionIter = FindDecompressionInterfaceImpl(compressionAlgorithmId);
+        if (decompressionIter != m_decompressionInterfaces.end())
+        {
+            // The compression interface has been found using the compression interface id,
+            // so another registration cannot be done
+            return AZ::Failure(AZStd::move(decompressionInterfacePtr));
+        }
+
+        // Use UpperBound to find the insertion slot for the new entry
+        auto ProjectionToCompressionAlgorithmId = [](const DecompressionIdIndexEntry& entry) -> CompressionAlgorithmId
+        {
+            return entry.m_id;
+        };
+
+        m_decompressionInterfaces.emplace(AZStd::ranges::upper_bound(m_decompressionInterfaces, compressionAlgorithmId,
+            AZStd::ranges::less{}, ProjectionToCompressionAlgorithmId),
+            DecompressionIdIndexEntry{ compressionAlgorithmId, AZStd::move(decompressionInterfacePtr) });
+
+        return AZ::Success();
+    }
+
+    bool DecompressionRegistrarImpl::UnregisterDecompressionInterface(CompressionAlgorithmId compressionAlgorithmId)
+    {
+        AZStd::scoped_lock lock(m_decompressionInterfaceMutex);
+        if (auto decompressionIter = FindDecompressionInterfaceImpl(compressionAlgorithmId);
+            decompressionIter != m_decompressionInterfaces.end())
+        {
+            // Remove the decompressionInterface
+            m_decompressionInterfaces.erase(decompressionIter);
+            return true;
+        }
+
+        return false;
+    }
+
+    IDecompressionInterface* DecompressionRegistrarImpl::FindDecompressionInterface(CompressionAlgorithmId compressionAlgorithmId) const
+    {
+        AZStd::scoped_lock lock(m_decompressionInterfaceMutex);
+        auto decompressionIter = FindDecompressionInterfaceImpl(compressionAlgorithmId);
+        return decompressionIter != m_decompressionInterfaces.end() ? decompressionIter->m_decompressionInterface.get() : nullptr;
+    }
+
+    bool DecompressionRegistrarImpl::IsRegistered(CompressionAlgorithmId compressionAlgorithmId) const
+    {
+        AZStd::scoped_lock lock(m_decompressionInterfaceMutex);
+        auto decompressionIter = FindDecompressionInterfaceImpl(compressionAlgorithmId);
+        return decompressionIter != m_decompressionInterfaces.end();
+    }
+
+    // NOTE: The caller should lock the mutex
+    // returns iterator to the compression inteface with the specified compression algorithm id
+    // otherwise a sentinel iterator is returned
+    auto DecompressionRegistrarImpl::FindDecompressionInterfaceImpl(CompressionAlgorithmId compressionAlgorithmId) const
+        -> typename IdToDecompressionInterfaceMap::const_iterator
+    {
+        auto ProjectionToDecompressionAlgorithmId = [](const DecompressionIdIndexEntry& entry) -> CompressionAlgorithmId
+        {
+            return entry.m_id;
+        };
+
+        auto [firstFoundIter, lastFoundIter] = AZStd::ranges::equal_range(m_decompressionInterfaces,
+            compressionAlgorithmId, AZStd::ranges::less{}, ProjectionToDecompressionAlgorithmId);
+
+        return firstFoundIter != lastFoundIter ? firstFoundIter : m_decompressionInterfaces.end();
+    }
+}// namespace Compression

Gems/Compression/Code/Source/Clients/DecompressionRegistrarImpl.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/std/containers/vector.h>
+#include <AzCore/Memory/SystemAllocator.h>
+#include <Compression/DecompressionInterfaceAPI.h>
+
+namespace Compression
+{
+    class DecompressionRegistrarImpl final
+        : public DecompressionRegistrarInterface
+    {
+    public:
+        AZ_RTTI(DecompressionRegistrarImpl, "{2353362A-A059-4681-ADF0-5ABE41E85A6B}", DecompressionRegistrarInterface);
+        AZ_CLASS_ALLOCATOR(DecompressionRegistrarImpl, AZ::SystemAllocator, 0);
+
+        DecompressionRegistrarImpl();
+        ~DecompressionRegistrarImpl();
+
+        void VisitDecompressionInterfaces(const VisitDecompressionInterfaceCallback&) const override;
+
+        //! Registers a decompression interface with a standard deleter
+        AZ::Outcome<void, AZStd::unique_ptr<IDecompressionInterface>> RegisterDecompressionInterface(
+            CompressionAlgorithmId algorithmId,
+            AZStd::unique_ptr<IDecompressionInterface> decompressionInterface) override;
+
+        //! Registers a decompression interface with a null deleter
+        bool RegisterDecompressionInterface(CompressionAlgorithmId algorithmId, IDecompressionInterface& decompressionInterface) override;
+
+        bool UnregisterDecompressionInterface(CompressionAlgorithmId algorithmId) override;
+
+        [[nodiscard]] IDecompressionInterface* FindDecompressionInterface(CompressionAlgorithmId algorithmId) const override;
+
+        [[nodiscard]] bool IsRegistered(CompressionAlgorithmId algorithmId) const override;
+
+        struct DecompressionInterfaceDeleter
+        {
+            DecompressionInterfaceDeleter();
+            DecompressionInterfaceDeleter(bool shouldDelete);
+            void operator()(IDecompressionInterface* ptr) const;
+            bool m_delete{ true };
+        };
+    private:
+        using DecompressionInterfacePtr = AZStd::unique_ptr<IDecompressionInterface, DecompressionInterfaceDeleter>;
+
+        //! Helper function that is used to register a decompression interface into the decompression interface array
+        //! while taking into account whether the decompression interface should be owned by this registrar
+        //! @param compressionAlgorithmId Unique Id of the decompression interface to register with this registrar
+        //! @param decompressionInterface unique_ptr to decompression interface to register
+        //! @return outcome which indicates whether the decompression interface was registered with the decompression interface array
+        //! On success an empty Success outcome is returned
+        //! On failure, the supplied decompression interface parameter is returned back to the caller
+        [[nodiscard]] AZ::Outcome<void, DecompressionInterfacePtr> RegisterDecompressionInterfaceImpl(
+            CompressionAlgorithmId algorithmId, DecompressionInterfacePtr decompressionInterface);
+
+        struct DecompressionIdIndexEntry
+        {
+            CompressionAlgorithmId m_id;
+            DecompressionInterfacePtr m_decompressionInterface;
+        };
+
+        using IdToDecompressionInterfaceMap = AZStd::vector<DecompressionIdIndexEntry>;
+
+        //! Searches within the decompression interface array for the decompression interface registered with the specified id
+        //! @param compressionAlgorithmId Unique Id of decompression interface to locate
+        //! @return iterator pointing the decompression interface registered with the specified CompressionAlgorithmId
+        //! NOTE: It is responsibility of the caller to lock the decompression interface mutex to protect the search
+        typename IdToDecompressionInterfaceMap::const_iterator FindDecompressionInterfaceImpl(CompressionAlgorithmId compressionAlgorithmId) const;
+
+
+        //! Contains the registered decompression interfaces
+        //! Sorted to provide O(Log N) search
+        IdToDecompressionInterfaceMap m_decompressionInterfaces;
+
+        //! Protects modifications to the decompression interfaces container
+        mutable AZStd::mutex m_decompressionInterfaceMutex;
+    };
+}// namespace Compression

Gems/Compression/Code/Source/Tools/CompressionEditorModule.cpp

@@ -6,7 +6,7 @@
  *
  */
 
-#include "CompressionFactoryImpl.h"
+#include "CompressionRegistrarImpl.h"
 #include <CompressionModuleInterface.h>
 #include "CompressionEditorSystemComponent.h"
 
@@ -29,18 +29,18 @@ namespace Compression
                 CompressionEditorSystemComponent::CreateDescriptor(),
             });
 
-            m_compressionFactoryInterface = AZStd::make_unique<CompressionFactoryImpl>();
-            if (CompressionFactory::Get() == nullptr)
+            m_compressionRegistrarInterface = AZStd::make_unique<CompressionRegistrarImpl>();
+            if (CompressionRegistrar::Get() == nullptr)
             {
-                CompressionFactory::Register(m_compressionFactoryInterface.get());
+                CompressionRegistrar::Register(m_compressionRegistrarInterface.get());
             }
         }
 
         ~CompressionEditorModule()
         {
-            if (CompressionFactory::Get() == m_compressionFactoryInterface.get())
+            if (CompressionRegistrar::Get() == m_compressionRegistrarInterface.get())
             {
-                CompressionFactory::Unregister(m_compressionFactoryInterface.get());
+                CompressionRegistrar::Unregister(m_compressionRegistrarInterface.get());
             }
         }
 
@@ -56,9 +56,9 @@ namespace Compression
         }
 
     private:
-        // CompressionFactory interface used to register Compression interfaces
+        // CompressionRegistrar interface used to register Compression interfaces
         // Available in tooling applications to allow compression algorithms to run
-        AZStd::unique_ptr<CompressionFactoryInterface> m_compressionFactoryInterface;
+        AZStd::unique_ptr<CompressionRegistrarInterface> m_compressionRegistrarInterface;
     };
 }// namespace Compression
 

Gems/Compression/Code/Source/Tools/CompressionFactoryImpl.cpp

@@ -1,93 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#include "CompressionFactoryImpl.h"
-#include <AzCore/std/functional.h>
-#include <AzCore/std/ranges/ranges_algorithm.h>
-
-namespace Compression
-{
-    CompressionFactoryImpl::~CompressionFactoryImpl() = default;
-
-    void CompressionFactoryImpl::VisitCompressionInterfaces(const VisitCompressionInterfaceCallback& callback) const
-    {
-        auto VisitInterface = [&callback](const AZStd::unique_ptr<ICompressionInterface>& compressionInterface)
-        {
-            return compressionInterface != nullptr ? callback(*compressionInterface) : true;
-        };
-
-        AZStd::ranges::all_of(m_compressionInterfaces, VisitInterface);
-    }
-
-    bool CompressionFactoryImpl::RegisterCompressionInterface(AZStd::unique_ptr<ICompressionInterface>&& compressionInterface)
-    {
-        if (compressionInterface == nullptr)
-        {
-            return false;
-        }
-
-        CompressionAlgorithmId compressionAlgorithmId = compressionInterface->GetCompressionAlgorithmId();
-        const size_t compressionIndex = FindCompressionIndex(compressionAlgorithmId);
-        if (compressionIndex < m_compressionInterfaces.size())
-        {
-            return false;
-        }
-
-        // Insert new compression interface since it is not registered
-        m_compressionInterfaces.emplace_back(AZStd::move(compressionInterface));
-        const size_t emplaceIndex = m_compressionInterfaces.size() - 1;
-
-        // Use UpperBound to find the insertion slot for the new entry within the compression index set
-        auto FindIdIndexEntry = [](const CompressionIdIndexEntry& lhs, const CompressionIdIndexEntry& rhs)
-        {
-            return lhs.m_id < rhs.m_id;
-        };
-        CompressionIdIndexEntry newEntry{ compressionAlgorithmId, emplaceIndex };
-        m_compressionIdIndexSet.insert(AZStd::upper_bound(m_compressionIdIndexSet.begin(), m_compressionIdIndexSet.end(),
-            newEntry, AZStd::move(FindIdIndexEntry)),
-            AZStd::move(newEntry));
-        return true;
-    }
-
-    bool CompressionFactoryImpl::UnregisterCompressionInterface(CompressionAlgorithmId compressionAlgorithmId)
-    {
-        const size_t compressionIndex = FindCompressionIndex(compressionAlgorithmId);
-        if (compressionIndex < m_compressionInterfaces.size())
-        {
-            auto oldInterfaceIter = m_compressionInterfaces.begin() + compressionIndex;
-            m_compressionInterfaces.erase(oldInterfaceIter);
-            return true;
-        }
-
-        return false;
-    }
-
-    ICompressionInterface* CompressionFactoryImpl::FindCompressionInterface(CompressionAlgorithmId compressionAlgorithmId) const
-    {
-        const size_t compressionIndex = FindCompressionIndex(compressionAlgorithmId);
-        return compressionIndex < m_compressionInterfaces.size()
-            ? m_compressionInterfaces[compressionIndex].get() : nullptr;
-    }
-
-    // find compression index entry in vector
-    // returns the index into the m_compressionInterfaces vector that matches the compression algorithm Id
-    // otherwise returns the size of the m_compressionInterfaces container to indicate out of bounds
-    size_t CompressionFactoryImpl::FindCompressionIndex(CompressionAlgorithmId compressionAlgorithmId) const
-    {
-        auto FindIdIndexEntry = [](const CompressionIdIndexEntry& lhs, const CompressionIdIndexEntry& rhs)
-        {
-            return lhs.m_id < rhs.m_id;
-        };
-        auto searchIter = AZStd::lower_bound(m_compressionIdIndexSet.begin(), m_compressionIdIndexSet.end(),
-            CompressionIdIndexEntry{ compressionAlgorithmId }, FindIdIndexEntry);
-
-        return searchIter != m_compressionIdIndexSet.end() && !FindIdIndexEntry(
-            CompressionIdIndexEntry{ compressionAlgorithmId }, *searchIter) ?
-            searchIter->m_index : m_compressionInterfaces.size();
-    }
-}// namespace Compression

Gems/Compression/Code/Source/Tools/CompressionFactoryImpl.h

@@ -1,40 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#include <AzCore/std/containers/vector.h>
-#include <AzCore/Memory/SystemAllocator.h>
-#include <Compression/CompressionInterfaceAPI.h>
-
-namespace Compression
-{
-    class CompressionFactoryImpl final
-        : public CompressionFactoryInterface
-    {
-    public:
-        AZ_RTTI(CompressionFactoryImpl, "{9F3B8418-4BEB-4249-BAAF-6653A8F511A3}", CompressionFactoryInterface);
-        AZ_CLASS_ALLOCATOR(CompressionFactoryImpl, AZ::SystemAllocator, 0);
-
-        ~CompressionFactoryImpl();
-
-        void VisitCompressionInterfaces(const VisitCompressionInterfaceCallback&) const override;
-        bool RegisterCompressionInterface(AZStd::unique_ptr<ICompressionInterface>&&) override;
-        bool UnregisterCompressionInterface(CompressionAlgorithmId) override;
-        ICompressionInterface* FindCompressionInterface(CompressionAlgorithmId) const override;
-
-    private:
-        size_t FindCompressionIndex(CompressionAlgorithmId) const;
-        struct CompressionIdIndexEntry
-        {
-            CompressionAlgorithmId m_id;
-            size_t m_index;
-        };
-        //! Index into the Compression Interfaces vector
-        AZStd::vector<CompressionIdIndexEntry> m_compressionIdIndexSet;
-        AZStd::vector<AZStd::unique_ptr<ICompressionInterface>> m_compressionInterfaces;
-    };
-}// namespace Compression

Gems/Compression/Code/Source/Tools/CompressionRegistrarImpl.cpp

@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#include "CompressionRegistrarImpl.h"
+#include <AzCore/std/functional.h>
+#include <AzCore/std/parallel/scoped_lock.h>
+#include <AzCore/std/ranges/ranges_algorithm.h>
+
+namespace Compression
+{
+    CompressionRegistrarImpl::CompressionInterfaceDeleter::CompressionInterfaceDeleter() = default;
+    CompressionRegistrarImpl::CompressionInterfaceDeleter::CompressionInterfaceDeleter(bool shouldDelete)
+        : m_delete(shouldDelete)
+    {}
+    void CompressionRegistrarImpl::CompressionInterfaceDeleter::operator()(ICompressionInterface* ptr) const
+    {
+        if (m_delete)
+        {
+            delete ptr;
+        }
+    }
+
+    CompressionRegistrarImpl::CompressionRegistrarImpl() = default;
+    CompressionRegistrarImpl::~CompressionRegistrarImpl() = default;
+
+    void CompressionRegistrarImpl::VisitCompressionInterfaces(const VisitCompressionInterfaceCallback& callback) const
+    {
+        auto VisitInterface = [&callback](const CompressionIdIndexEntry& compressionInterfaceEntry)
+        {
+            return compressionInterfaceEntry.m_compressionInterface != nullptr ? callback(*compressionInterfaceEntry.m_compressionInterface) : true;
+        };
+
+        AZStd::scoped_lock lock(m_compressionInterfaceMutex);
+        AZStd::ranges::all_of(m_compressionInterfaces, VisitInterface);
+    }
+
+    AZ::Outcome<void, AZStd::unique_ptr<ICompressionInterface>> CompressionRegistrarImpl::RegisterCompressionInterface(
+        CompressionAlgorithmId compressionAlgorithmId, AZStd::unique_ptr<ICompressionInterface> compressionInterface)
+    {
+        // Transfer ownership to a temporary CompressionInterfacePtr which is supplied to the RegisterCompressionInterfaceImpl
+        // If registration fails, the compression interface pointer is returned in the failure outcome
+        if (auto registerResult = RegisterCompressionInterfaceImpl(compressionAlgorithmId, CompressionInterfacePtr{ compressionInterface.release() });
+            !registerResult.IsSuccess())
+        {
+            return AZ::Failure(AZStd::unique_ptr<ICompressionInterface>(registerResult.TakeError().release()));
+        }
+
+        // registration succeeded, return a void success outcome
+        return AZ::Success();
+    }
+
+    bool CompressionRegistrarImpl::RegisterCompressionInterface(CompressionAlgorithmId compressionAlgorithmId, ICompressionInterface& compressionInterface)
+    {
+        // Create a temporary CompressionInterfacePtr with a custom deleter that does NOT delete the compressionInterface reference
+        // On success, the the CompressionInterfacePtr is stored in the compression interface array
+        // and will not delete the reference to registered interface
+        return RegisterCompressionInterfaceImpl(compressionAlgorithmId, CompressionInterfacePtr{ &compressionInterface, CompressionInterfaceDeleter{false} }).IsSuccess();
+    }
+
+    auto CompressionRegistrarImpl::RegisterCompressionInterfaceImpl(CompressionAlgorithmId compressionAlgorithmId, CompressionInterfacePtr compressionInterfacePtr)
+        -> AZ::Outcome<void, CompressionInterfacePtr>
+    {
+        if (compressionInterfacePtr == nullptr)
+        {
+            return AZ::Failure(AZStd::move(compressionInterfacePtr));
+        }
+
+        AZStd::scoped_lock lock(m_compressionInterfaceMutex);
+        auto compressionIter = FindCompressionInterfaceImpl(compressionAlgorithmId);
+        if (compressionIter != m_compressionInterfaces.end())
+        {
+            // The compression interface has been found using the compression interface id,
+            // so another registration cannot be done
+            return AZ::Failure(AZStd::move(compressionInterfacePtr));
+        }
+
+        // Use UpperBound to find the insertion slot for the new entry
+        auto ProjectionToCompressionAlgorithmId = [](const CompressionIdIndexEntry& entry) -> CompressionAlgorithmId
+        {
+            return entry.m_id;
+        };
+
+        m_compressionInterfaces.emplace(AZStd::ranges::upper_bound(m_compressionInterfaces, compressionAlgorithmId,
+            AZStd::ranges::less{}, ProjectionToCompressionAlgorithmId),
+            CompressionIdIndexEntry{ compressionAlgorithmId, AZStd::move(compressionInterfacePtr) });
+
+        return AZ::Success();
+    }
+
+    bool CompressionRegistrarImpl::UnregisterCompressionInterface(CompressionAlgorithmId compressionAlgorithmId)
+    {
+        AZStd::scoped_lock lock(m_compressionInterfaceMutex);
+        if (auto compressionIter = FindCompressionInterfaceImpl(compressionAlgorithmId);
+            compressionIter != m_compressionInterfaces.end())
+        {
+            // Remove the compressionInterface
+            m_compressionInterfaces.erase(compressionIter);
+            return true;
+        }
+
+        return false;
+    }
+
+    ICompressionInterface* CompressionRegistrarImpl::FindCompressionInterface(CompressionAlgorithmId compressionAlgorithmId) const
+    {
+        AZStd::scoped_lock lock(m_compressionInterfaceMutex);
+        auto compressionIter = FindCompressionInterfaceImpl(compressionAlgorithmId);
+        return compressionIter != m_compressionInterfaces.end() ? compressionIter->m_compressionInterface.get() : nullptr;
+    }
+
+    bool CompressionRegistrarImpl::IsRegistered(CompressionAlgorithmId compressionAlgorithmId) const
+    {
+        AZStd::scoped_lock lock(m_compressionInterfaceMutex);
+        auto compressionIter = FindCompressionInterfaceImpl(compressionAlgorithmId);
+        return compressionIter != m_compressionInterfaces.end();
+    }
+
+    // NOTE: The caller should lock the mutex
+    // returns iterator to the compression inteface with the specified compression algorithm id
+    // otherwise a sentinel iterator is returned
+    auto CompressionRegistrarImpl::FindCompressionInterfaceImpl(CompressionAlgorithmId compressionAlgorithmId) const
+        -> typename IdToCompressionInterfaceMap::const_iterator
+    {
+        auto ProjectionToCompressionAlgorithmId = [](const CompressionIdIndexEntry& entry) -> CompressionAlgorithmId
+        {
+            return entry.m_id;
+        };
+
+        auto [firstFoundIter, lastFoundIter] = AZStd::ranges::equal_range(m_compressionInterfaces,
+            compressionAlgorithmId, AZStd::ranges::less{}, ProjectionToCompressionAlgorithmId);
+
+        return firstFoundIter != lastFoundIter ? firstFoundIter : m_compressionInterfaces.end();
+    }
+}// namespace Compression

Gems/Compression/Code/Source/Tools/CompressionRegistrarImpl.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+
+#pragma once
+
+#include <AzCore/std/containers/vector.h>
+#include <AzCore/Memory/SystemAllocator.h>
+#include <Compression/CompressionInterfaceAPI.h>
+
+namespace Compression
+{
+    class CompressionRegistrarImpl final
+        : public CompressionRegistrarInterface
+    {
+    public:
+        AZ_RTTI(CompressionRegistrarImpl, "{9F3B8418-4BEB-4249-BAAF-6653A8F511A3}", CompressionRegistrarInterface);
+        AZ_CLASS_ALLOCATOR(CompressionRegistrarImpl, AZ::SystemAllocator, 0);
+
+        CompressionRegistrarImpl();
+        ~CompressionRegistrarImpl();
+
+        void VisitCompressionInterfaces(const VisitCompressionInterfaceCallback&) const override;
+
+        //! Registers a compression interface with a standard deleter
+        AZ::Outcome<void, AZStd::unique_ptr<ICompressionInterface>> RegisterCompressionInterface(
+            CompressionAlgorithmId algorithmId,
+            AZStd::unique_ptr<ICompressionInterface> compressionInterface) override;
+
+        //! Registers a compression interface with a null deleter
+        bool RegisterCompressionInterface(CompressionAlgorithmId algorithmId, ICompressionInterface& compressionInterface) override;
+
+        bool UnregisterCompressionInterface(CompressionAlgorithmId algorithmId) override;
+
+        [[nodiscard]] ICompressionInterface* FindCompressionInterface(CompressionAlgorithmId algorithmId) const override;
+
+        [[nodiscard]] bool IsRegistered(CompressionAlgorithmId algorithmId) const override;
+
+        struct CompressionInterfaceDeleter
+        {
+            CompressionInterfaceDeleter();
+            CompressionInterfaceDeleter(bool shouldDelete);
+            void operator()(ICompressionInterface* ptr) const;
+            bool m_delete{ true };
+        };
+    private:
+        using CompressionInterfacePtr = AZStd::unique_ptr<ICompressionInterface, CompressionInterfaceDeleter>;
+
+        //! Helper function that is used to register a compression interface into the compression interface array
+        //! while taking into account whether the compression interface should be owned by this registrar
+        //! @param compressionAlgorithmId Unique Id of the compression interface to register with this registrar
+        //! @param compression unique_ptr to compression interface to register
+        //! @return outcome which indicates whether the compression interface was registered with the compression interface array
+        //! On success an empty Success outcome is returned
+        //! On failure, the supplied compression interface parameter is returned back to the caller
+        [[nodiscard]] AZ::Outcome<void, CompressionInterfacePtr> RegisterCompressionInterfaceImpl(
+            CompressionAlgorithmId algorithmId, CompressionInterfacePtr compressionInterface);
+
+        struct CompressionIdIndexEntry
+        {
+            CompressionAlgorithmId m_id;
+            CompressionInterfacePtr m_compressionInterface;
+        };
+
+        using IdToCompressionInterfaceMap = AZStd::vector<CompressionIdIndexEntry>;
+
+        //! Searches within the compression interface array for the compression interface registered with the specified id
+        //! @param compressionAlgorithmId Unique Id of compression interface to locate
+        //! @return iterator pointing the compression interface registered with the specified CompressionAlgorithmId
+        //! NOTE: It is responsibility of the caller to lock the compression interface mutex to protect the search
+        typename IdToCompressionInterfaceMap::const_iterator FindCompressionInterfaceImpl(CompressionAlgorithmId compressionAlgorithmId) const;
+
+
+        //! Contains the registered compression interfaces
+        //! Sorted to provide O(Log N) search
+        IdToCompressionInterfaceMap m_compressionInterfaces;
+
+        //! Protects modifications to the compression interfaces container
+        mutable AZStd::mutex m_compressionInterfaceMutex;
+    };
+}// namespace Compression

Gems/Compression/Code/compression_editor_private_files.cmake

@@ -7,6 +7,6 @@
 set(FILES
     Source/Tools/CompressionEditorSystemComponent.cpp
     Source/Tools/CompressionEditorSystemComponent.h
-    Source/Tools/CompressionFactoryImpl.h
-    Source/Tools/CompressionFactoryImpl.cpp
+    Source/Tools/CompressionRegistrarImpl.h
+    Source/Tools/CompressionRegistrarImpl.cpp
 )

Gems/Compression/Code/compression_private_files.cmake

@@ -8,6 +8,6 @@ set(FILES
     Source/CompressionModuleInterface.h
     Source/Clients/CompressionSystemComponent.cpp
     Source/Clients/CompressionSystemComponent.h
-    Source/Clients/DecompressionFactoryImpl.cpp
-    Source/Clients/DecompressionFactoryImpl.h
+    Source/Clients/DecompressionRegistrarImpl.cpp
+    Source/Clients/DecompressionRegistrarImpl.h
 )