Functionality to retrieve Service Reference from Service (CppMicroServices#1044) (CppMicroServices#1157)

RobertLauferElektrobit · tcormackMW · web-flow · commit 9610f1fa9c51 · 2025-07-25T06:49:46.000-04:00
---------

Co-authored-by: tcormackMW &lt;113473781+tcormackMW@users.noreply.github.com&gt;
Co-authored-by: Toby Cormack &lt;tcormack@mathworks.com&gt;
diff --git a/compendium/DeclarativeServices/test/gtest/CMakeLists.txt b/compendium/DeclarativeServices/test/gtest/CMakeLists.txt
@@ -92,6 +92,7 @@ set(_declarativeservices_tests
   TestFixture.hpp
   TestServiceComponentRuntime.cpp
   TestServiceProvider.cpp
+  TestServiceReferenceRetrieval.cpp
   TestSharedLibraryException.cpp
   TestUpdateConfiguration.cpp
   ImportTestBundles.cpp
diff --git a/compendium/DeclarativeServices/test/gtest/TestServiceReferenceRetrieval.cpp b/compendium/DeclarativeServices/test/gtest/TestServiceReferenceRetrieval.cpp
@@ -0,0 +1,106 @@
+/*=============================================================================
+
+  Library: CppMicroServices
+
+  Copyright (c) The CppMicroServices developers. See the COPYRIGHT
+  file at the top-level directory of this distribution and at
+  https://github.com/CppMicroServices/CppMicroServices/COPYRIGHT .
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+
+=============================================================================*/
+
+#include "TestFixture.hpp"
+#include "cppmicroservices/Constants.h"
+#include "cppmicroservices/ServiceObjects.h"
+#include "cppmicroservices/ServiceReference.h"
+#include "gtest/gtest.h"
+
+#include "TestInterfaces/Interfaces.hpp"
+
+namespace test
+{
+    struct int1
+    {
+        [[nodiscard]] virtual int getValue() const = 0;
+        virtual ~int1() = default;
+        int1(int1 const&) = default;
+        int1& operator=(int1 const&) = default;
+        int1(int1&&) noexcept = default;
+        int1& operator=(int1&&) noexcept = default;
+
+      protected:
+        int1() = default;
+    };
+
+    struct TestServiceA : public int1
+    {
+        TestServiceA(int val) : id(val) {}
+        [[nodiscard]] int
+        getValue() const override
+        {
+            return id;
+        }
+
+      private:
+        int id;
+    };
+    /*
+     * Tests that a user is able to retrieve a serviceReference from a serviceObject from the coreFramework or DS
+     */
+    TEST_F(tServiceComponent, testServiceReferenceRetrievalForDSAndManReg)
+    {
+        auto const id1 = 100;
+        auto const id2 = 85;
+        auto reg = context.RegisterService<int1>(std::make_shared<TestServiceA>(id1));
+        auto sref = reg.GetReference();
+        auto sref2 = context.RegisterService<int1>(std::make_shared<TestServiceA>(id2)).GetReference();
+
+        auto service1 = context.GetService(sref);
+        ASSERT_EQ(service1->getValue(), id1);
+        auto service2 = context.GetService(sref2);
+        ASSERT_EQ(service2->getValue(), id2);
+
+        auto srefFromService1 = cppmicroservices::ServiceReferenceFromService(service1);
+
+        ASSERT_EQ(srefFromService1, sref);
+        ASSERT_FALSE(cppmicroservices::ServiceReferenceFromService(service1) == sref2);
+        ASSERT_EQ(cppmicroservices::ServiceReferenceFromService(service2), sref2);
+
+        // Install and start bundle
+        auto testBundle = ::test::InstallAndStartBundle(context, "TestBundleDSCA05");
+        ASSERT_TRUE(testBundle);
+
+        auto dsRef = context.GetServiceReference<test::CAInterface>();
+        ASSERT_TRUE(dsRef);
+        auto dsSvc = context.GetService<test::CAInterface>(dsRef);
+        auto retSRef = cppmicroservices::ServiceReferenceFromService(dsSvc);
+        ASSERT_EQ(retSRef, dsRef);
+        ASSERT_EQ(cppmicroservices::any_cast<std::string>(retSRef.GetProperty("ManifestProp")), "abc");
+
+        ASSERT_THROW(cppmicroservices::ServiceReferenceFromService(std::make_shared<TestServiceA>(id1)),
+                     std::runtime_error);
+
+        reg.Unregister();
+
+        // ensure only 1 sr exists in framework for int1
+        ASSERT_EQ(context.GetServiceReferences<int1>().size(), 1);
+        // assert that the serviceReference returned for my service object is not valid after unregistration
+        ASSERT_FALSE(cppmicroservices::ServiceReferenceFromService(service1));
+
+        // assert identical behavior from ref from original registration and ref from serviceReferenceFromService
+        ASSERT_FALSE(sref);
+        ASSERT_FALSE(srefFromService1);
+        ASSERT_EQ(sref, srefFromService1);
+    }
+} // namespace test
diff --git a/framework/include/cppmicroservices/ServiceReference.h b/framework/include/cppmicroservices/ServiceReference.h
@@ -86,7 +86,7 @@ namespace cppmicroservices
 
         ServiceReference(ServiceReferenceBase const& base) : ServiceReferenceBase(base)
         {
-            const std::string interfaceId(us_service_interface_iid<S>());
+            std::string const interfaceId(us_service_interface_iid<S>());
             if (GetInterfaceId() != interfaceId)
             {
                 if (this->IsConvertibleTo(interfaceId))
@@ -149,6 +149,31 @@ namespace cppmicroservices
      * interface identifier.
      */
     using ServiceReferenceU = ServiceReference<void>;
+
+    /**
+     * \ingroup MicroServices
+     * \ingroup gr_servicereference
+     *
+     * A method to retrieve a <code>ServiceObject</code>'s original <code>ServiceReference<void></code>
+     *
+     */
+    US_Framework_EXPORT ServiceReferenceU ServiceReferenceFromService(std::shared_ptr<void> const& s);
+
+    /**
+     * \ingroup MicroServices
+     * \ingroup gr_servicereference
+     *
+     * A method to retrieve a <code>ServiceObject<T></code>'s original <code>ServiceReference<U></code>
+     *
+     * @tparam T The class type of the <code>ServiceObject</code>
+     * @tparam U The class type of the <code>ServiceReference</code>. Defaults to <code>T</code> if not specified.
+     */
+    template <typename T, typename U = T>
+    ServiceReference<U>
+    ServiceReferenceFromService(std::shared_ptr<T> const& s)
+    {
+        return ServiceReference<U>(ServiceReferenceFromService(std::static_pointer_cast<void>(s)));
+    }
 } // namespace cppmicroservices
 
 namespace std
diff --git a/framework/include/cppmicroservices/ServiceReferenceBase.h b/framework/include/cppmicroservices/ServiceReferenceBase.h
@@ -209,7 +209,6 @@ namespace cppmicroservices
         friend class BundleHooks;
         friend class ServiceHooks;
         friend class ServiceObjectsBase;
-        friend struct UngetHelper;
         friend class ServiceObjectsBasePrivate;
         friend class ServiceRegistrationBase;
         friend class ServiceRegistrationBasePrivate;
diff --git a/framework/src/bundle/BundleContext.cpp b/framework/src/bundle/BundleContext.cpp
@@ -234,52 +234,6 @@ namespace cppmicroservices
         return b->coreCtx->services.Get(b.get(), clazz);
     }
 
-    /* @brief Private helper struct used to facilitate the shared_ptr aliasing constructor
-     *        in BundleContext::GetService method. The aliasing constructor helps automate
-     *        the call to UngetService method.
-     *
-     *        Service consumers can simply call GetService to obtain a shared_ptr to the
-     *        service object and not worry about calling UngetService when they are done.
-     *        The UngetService is called when all instances of the returned shared_ptr object
-     *        go out of scope.
-     */
-    template <class S>
-    struct ServiceHolder
-    {
-        std::weak_ptr<BundlePrivate> const b;
-        ServiceReferenceBase const sref;
-        std::shared_ptr<S> const service;
-
-        ServiceHolder(std::shared_ptr<BundlePrivate> const& b, ServiceReferenceBase const& sr, std::shared_ptr<S> s)
-            : b(b)
-            , sref(sr)
-            , service(std::move(s))
-        {
-        }
-
-        ~ServiceHolder()
-        {
-            try
-            {
-                sref.d.Load()->UngetService(b.lock(), true);
-            }
-            catch (...)
-            {
-                // Make sure that we don't crash if the shared_ptr service object outlives
-                // the BundlePrivate or CoreBundleContext objects.
-                if (!b.expired())
-                {
-                    DIAG_LOG(*b.lock()->coreCtx->sink)
-                        << "UngetService threw an exception. " << util::GetLastExceptionStr();
-                }
-                // don't throw exceptions from the destructor. For an explanation, see:
-                // https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md
-                // Following this rule means that a FrameworkEvent isn't an option here
-                // since it contains an exception object which clients could throw.
-            }
-        }
-    };
-
     std::shared_ptr<void>
     BundleContext::GetService(ServiceReferenceBase const& reference)
     {
@@ -297,8 +251,8 @@ namespace cppmicroservices
         d->CheckValid();
         auto b = GetAndCheckBundlePrivate(d);
 
-        std::shared_ptr<ServiceHolder<void>> h(
-            new ServiceHolder<void>(b, reference, reference.d.Load()->GetService(b.get())));
+        auto serviceHolder = new ServiceHolder<void>(b, reference, reference.d.Load()->GetService(b.get()), nullptr);
+        std::shared_ptr<ServiceHolder<void>> h(serviceHolder, CustomServiceDeleter { serviceHolder });
         return std::shared_ptr<void>(h, h->service.get());
     }
 
@@ -321,7 +275,7 @@ namespace cppmicroservices
 
         auto serviceInterfaceMap = reference.d.Load()->GetServiceInterfaceMap(b.get());
         std::shared_ptr<ServiceHolder<InterfaceMap const>> h(
-            new ServiceHolder<InterfaceMap const>(b, reference, serviceInterfaceMap));
+            new ServiceHolder<InterfaceMap const>(b, reference, serviceInterfaceMap, nullptr));
         return InterfaceMapConstPtr(h, h->service.get());
     }
 
diff --git a/framework/src/service/ServiceObjects.cpp b/framework/src/service/ServiceObjects.cpp
@@ -82,64 +82,6 @@ namespace cppmicroservices
         }
     }
 
-    /* @brief Private helper struct used to facilitate the shared_ptr aliasing constructor
-     *        in ServiceObjectsBase::GetService & ServiceObjectsBase::GetServiceInterfaceMap
-     *        methods. The aliasing constructor helps automate the call to UngetService method.
-     *
-     *        Service consumers can simply call GetService to obtain a shared_ptr to the
-     *        service object and not worry about calling UngetService when they are done.
-     *        The UngetService is called when all instances of the returned shared_ptr object
-     *        go out of scope.
-     */
-    struct UngetHelper
-    {
-        const InterfaceMapConstPtr interfaceMap;
-        const ServiceReferenceBase sref;
-        const std::weak_ptr<BundlePrivate> b;
-
-        UngetHelper(InterfaceMapConstPtr im, ServiceReferenceBase const& sr, std::shared_ptr<BundlePrivate> const& b)
-            : interfaceMap(std::move(im))
-            , sref(sr)
-            , b(b)
-        {
-        }
-        ~UngetHelper()
-        {
-            try
-            {
-                auto bundle = b.lock();
-                if (sref)
-                {
-                    bool isPrototypeScope
-                        = sref.GetProperty(Constants::SERVICE_SCOPE).ToString() == Constants::SCOPE_PROTOTYPE;
-
-                    if (isPrototypeScope)
-                    {
-                        sref.d.Load()->UngetPrototypeService(bundle, interfaceMap);
-                    }
-                    else
-                    {
-                        sref.d.Load()->UngetService(bundle, true);
-                    }
-                }
-            }
-            catch (...)
-            {
-                // Make sure that we don't crash if the shared_ptr service object outlives
-                // the BundlePrivate or CoreBundleContext objects.
-                if (!b.expired())
-                {
-                    DIAG_LOG(*b.lock()->coreCtx->sink)
-                        << "UngetHelper threw an exception. " << util::GetLastExceptionStr();
-                }
-                // don't throw exceptions from the destructor. For an explanation, see:
-                // https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md
-                // Following this rule means that a FrameworkEvent isn't an option here
-                // since it contains an exception object which clients could throw.
-            }
-        }
-    };
-
     std::shared_ptr<void>
     ServiceObjectsBase::GetService() const
     {
@@ -162,7 +104,7 @@ namespace cppmicroservices
             return nullptr;
         }
 
-        auto h = std::make_shared<UngetHelper>(interfaceMap, d->m_reference, bundle_);
+        auto h = std::make_shared<ServiceHolder<void>>(bundle_, d->m_reference, nullptr, interfaceMap);
         auto deleter = h->interfaceMap->find(d->m_reference.GetInterfaceId())->second.get();
         return std::shared_ptr<void>(h, deleter);
     }
@@ -190,8 +132,8 @@ namespace cppmicroservices
         {
             return nullptr;
         }
-
-        std::shared_ptr<UngetHelper> h(new UngetHelper { result, d->m_reference, bundle_ });
+        auto sh = new ServiceHolder<void> { bundle_, d->m_reference, nullptr, result };
+        std::shared_ptr<ServiceHolder<void>> h(sh, CustomServiceDeleter { sh });
         return InterfaceMapConstPtr(h, h->interfaceMap.get());
     }
 
diff --git a/framework/src/service/ServiceReferenceBasePrivate.cpp b/framework/src/service/ServiceReferenceBasePrivate.cpp
@@ -482,4 +482,15 @@ namespace cppmicroservices
         }
         return false;
     }
+
+    ServiceReferenceU
+    ServiceReferenceFromService(std::shared_ptr<void> const& s)
+    {
+        auto deleter = std::get_deleter<CustomServiceDeleter>(s);
+        if (!deleter)
+        {
+            throw std::runtime_error("The input is not a CppMicroServices managed ServiceObject");
+        }
+        return deleter->getServiceRef();
+    }
 } // namespace cppmicroservices
diff --git a/framework/src/service/ServiceReferenceBasePrivate.h b/framework/src/service/ServiceReferenceBasePrivate.h
