Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1580 insertions, 0 deletions

diff --git a/stoc/source/implementationregistration/implreg.cxx b/stoc/source/implementationregistration/implreg.cxx
new file mode 100644
index 000000000..7d697e41f
--- /dev/null
+++ b/stoc/source/implementationregistration/implreg.cxx
@@ -0,0 +1,1580 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you 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 .
+ */
+
+#include <string.h>
+#include <string_view>
+#include <vector>
+
+#include <cppuhelper/exc_hlp.hxx>
+#include <cppuhelper/weak.hxx>
+#include <cppuhelper/implbase.hxx>
+#include <cppuhelper/supportsservice.hxx>
+#include <comphelper/sequence.hxx>
+#include <rtl/ustring.hxx>
+
+#include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/lang/XInitialization.hpp>
+#include <com/sun/star/loader/XImplementationLoader.hpp>
+#include <com/sun/star/registry/XImplementationRegistration2.hpp>
+#include <com/sun/star/container/XHierarchicalNameAccess.hpp>
+#include <com/sun/star/reflection/XServiceTypeDescription.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/uno/RuntimeException.hpp>
+#include <com/sun/star/uno/XComponentContext.hpp>
+
+#include "mergekeys.hxx"
+
+#if defined(_WIN32)
+#include <io.h>
+#endif
+
+
+using namespace com::sun::star;
+using namespace css::uno;
+using namespace css::loader;
+using namespace css::beans;
+using namespace css::lang;
+using namespace css::registry;
+using namespace cppu;
+using namespace osl;
+
+namespace {
+
+constexpr OUStringLiteral slash_UNO_slash_REGISTRY_LINKS
+        = u"/UNO/REGISTRY_LINKS";
+constexpr OUStringLiteral slash_IMPLEMENTATIONS
+        =  u"/IMPLEMENTATIONS";
+constexpr OUStringLiteral slash_UNO
+        = u"/UNO";
+constexpr OUStringLiteral slash_UNO_slash_SERVICES
+        = u"/UNO/SERVICES";
+constexpr OUStringLiteral slash_UNO_slash_SINGLETONS
+        = u"/UNO/SINGLETONS";
+constexpr OUStringLiteral slash_SERVICES
+        = u"/SERVICES/";
+constexpr OUStringLiteral slash_UNO_slash_LOCATION
+        = u"/UNO/LOCATION";
+constexpr OUStringLiteral slash_UNO_slash_ACTIVATOR
+        = u"/UNO/ACTIVATOR";
+constexpr OUStringLiteral colon_old
+        = u":old";
+constexpr OUStringLiteral com_sun_star_registry_SimpleRegistry
+        = u"com.sun.star.registry.SimpleRegistry";
+constexpr OUStringLiteral Registry
+        = u"Registry";
+
+//  static deleteAllLinkReferences()
+
+void deleteAllLinkReferences(const Reference < XSimpleRegistry >& xReg,
+                                    const Reference < XRegistryKey >& xSource)
+    // throw ( InvalidRegistryException, RuntimeException )
+{
+    Reference < XRegistryKey > xKey = xSource->openKey(
+        slash_UNO_slash_REGISTRY_LINKS );
+
+    if (!(xKey.is() && (xKey->getValueType() == RegistryValueType_ASCIILIST)))
+        return;
+
+    const Sequence<OUString> linkNames = xKey->getAsciiListValue();
+
+    if (!linkNames.hasElements())
+        return;
+
+    OUString            aLinkName;
+    OUString            aLinkParent;
+    Reference < XRegistryKey >  xLinkParent;
+    const sal_Unicode*  pTmpName = nullptr;
+    const sal_Unicode*  pShortName = nullptr;
+    sal_Int32           sEnd = 0;
+
+    for (const OUString& rLinkName : linkNames)
+    {
+        aLinkName = rLinkName;
+
+        pTmpName = aLinkName.getStr();
+
+        if (pTmpName[0] != L'/')
+            continue;
+
+        sal_Int32 nIndex = rtl_ustr_indexOfChar( pTmpName, '%' );
+        if ( nIndex == -1 )
+            pShortName = nullptr;
+        else
+            pShortName = pTmpName+nIndex;
+
+        while (pShortName && pShortName[1] == L'%')
+        {
+            nIndex = rtl_ustr_indexOfChar( pShortName+2, '%' );
+            if ( nIndex == -1 )
+                pShortName = nullptr;
+            else
+                pShortName += nIndex+2;
+        }
+
+        if (pShortName)
+        {
+            aLinkName = aLinkName.copy(0, pShortName - pTmpName);
+        }
+
+        xReg->getRootKey()->deleteLink(aLinkName);
+
+        sEnd = aLinkName.lastIndexOf( '/' );
+
+        aLinkParent = aLinkName.copy(0, sEnd);
+
+        while(!aLinkParent.isEmpty())
+        {
+            xLinkParent = xReg->getRootKey()->openKey(aLinkParent);
+
+            if (xLinkParent.is() && !xLinkParent->getKeyNames().hasElements())
+            {
+                aLinkName = aLinkParent;
+
+                xReg->getRootKey()->deleteKey(aLinkParent);
+
+                sEnd = aLinkName.lastIndexOf( '/' );
+
+                aLinkParent = aLinkName.copy(0, sEnd);
+            }
+            else
+            {
+                break;
+            }
+        }
+    }
+}
+
+
+//  static prepareLink
+
+void prepareLink( const Reference < XSimpleRegistry > & xDest,
+                         const Reference < XRegistryKey > & xSource,
+                         const OUString& link)
+    // throw ( InvalidRegistryException, RuntimeException )
+{
+    OUString linkRefName = xSource->getKeyName();
+    OUString linkName(link);
+    bool    isRelativ = false;
+
+    const sal_Unicode*  pTmpName = link.getStr();
+    const sal_Unicode*  pShortName;
+    sal_Int32           nIndex = rtl_ustr_indexOfChar( pTmpName, '%' );
+    if ( nIndex == -1 )
+        pShortName = nullptr;
+    else
+        pShortName = pTmpName+nIndex;
+
+    if (pTmpName[0] != L'/')
+        isRelativ = true;
+
+    while (pShortName && pShortName[1] == L'%')
+    {
+        nIndex = rtl_ustr_indexOfChar( pShortName+2, '%' );
+        if ( nIndex == -1 )
+            pShortName = nullptr;
+        else
+            pShortName += nIndex+2;
+    }
+
+    if (pShortName)
+    {
+        linkRefName += link.subView(pShortName - pTmpName + 1);
+        linkName = link.copy(0, pShortName - pTmpName);
+    }
+
+    if (isRelativ)
+        xSource->createLink(linkName, linkRefName);
+    else
+        xDest->getRootKey()->createLink(linkName, linkRefName);
+}
+
+
+//  static searchImplForLink
+
+OUString searchImplForLink(
+    const Reference < XRegistryKey > & xRootKey,
+    std::u16string_view linkName,
+    std::u16string_view implName )
+    // throw ( InvalidRegistryException, RuntimeException )
+{
+    Reference < XRegistryKey > xKey = xRootKey->openKey( slash_IMPLEMENTATIONS );
+    if (xKey.is())
+    {
+        const Sequence< Reference < XRegistryKey > > subKeys( xKey->openKeys() );
+        OUString key_name( slash_UNO + linkName );
+
+        for (const Reference < XRegistryKey >& xImplKey : subKeys)
+        {
+            try
+            {
+                if (xImplKey->getKeyType( key_name ) == RegistryKeyType_LINK)
+                {
+                    OUString oldImplName = xImplKey->getKeyName().copy(strlen("/IMPLEMENTATIONS/"));
+                    if (implName != oldImplName)
+                    {
+                        return oldImplName;
+                    }
+                }
+            }
+            catch(InvalidRegistryException&)
+            {
+            }
+        }
+    }
+
+    return OUString();
+}
+
+
+//  static searchLinkTargetForImpl
+
+OUString searchLinkTargetForImpl(const Reference < XRegistryKey >& xRootKey,
+                                        std::u16string_view linkName,
+                                        const OUString& implName)
+{
+    Reference < XRegistryKey > xKey = xRootKey->openKey( slash_IMPLEMENTATIONS );
+
+    if (xKey.is())
+    {
+        const Sequence< Reference < XRegistryKey > > subKeys = xKey->openKeys();
+
+        OUString qualifiedLinkName( slash_UNO + linkName );
+
+        auto pSubKey = std::find_if(subKeys.begin(), subKeys.end(),
+            [&implName, &qualifiedLinkName](const Reference<XRegistryKey>& rSubKey) {
+                OUString tmpImplName = rSubKey->getKeyName().copy(strlen("/IMPLEMENTATIONS/"));
+                return tmpImplName == implName
+                    && rSubKey->getKeyType( qualifiedLinkName ) == RegistryKeyType_LINK;
+            });
+        if (pSubKey != subKeys.end())
+            return (*pSubKey)->getLinkTarget( qualifiedLinkName );
+    }
+
+    return OUString();
+}
+
+
+//  static createUniqueSubEntry
+
+void createUniqueSubEntry(const Reference < XRegistryKey > & xSuperKey,
+                                 const OUString& value)
+    // throw ( InvalidRegistryException, RuntimeException )
+{
+    if (!xSuperKey.is())
+        return;
+
+    if (xSuperKey->getValueType() == RegistryValueType_ASCIILIST)
+    {
+        const Sequence<OUString> implEntries = xSuperKey->getAsciiListValue();
+        sal_Int32 length = implEntries.getLength();
+
+        bool bReady = comphelper::findValue(implEntries, value) != -1;
+
+        if (bReady)
+        {
+            Sequence<OUString> implEntriesNew(length);
+            auto it = implEntriesNew.getArray();
+            *it = value;
+
+            std::copy_if(implEntries.begin(), implEntries.end(), std::next(it),
+                [&value](const OUString& rEntry) { return rEntry != value; });
+            xSuperKey->setAsciiListValue(implEntriesNew);
+        } else
+        {
+            Sequence<OUString> implEntriesNew(length+1);
+            auto it = implEntriesNew.getArray();
+            *it = value;
+
+            std::copy(implEntries.begin(), implEntries.end(), std::next(it));
+            xSuperKey->setAsciiListValue(implEntriesNew);
+        }
+    } else
+    {
+        Sequence<OUString> implEntriesNew { value };
+
+        xSuperKey->setAsciiListValue(implEntriesNew);
+    }
+}
+
+
+//  static deleteSubEntry
+
+bool deleteSubEntry(const Reference < XRegistryKey >& xSuperKey, const OUString& value)
+    // throw ( InvalidRegistryException, RuntimeException )
+{
+    if (xSuperKey->getValueType() == RegistryValueType_ASCIILIST)
+    {
+        const Sequence<OUString> implEntries = xSuperKey->getAsciiListValue();
+        sal_Int32 length = implEntries.getLength();
+        sal_Int32 equals = static_cast<sal_Int32>(std::count(implEntries.begin(), implEntries.end(), value));
+        bool hasNoImplementations = false;
+
+        if (equals == length)
+        {
+            hasNoImplementations = true;
+        } else
+        {
+            Sequence<OUString> implEntriesNew(length - equals);
+
+            std::copy_if(implEntries.begin(), implEntries.end(), implEntriesNew.getArray(),
+                [&value](const OUString& rEntry) { return rEntry != value; });
+            xSuperKey->setAsciiListValue(implEntriesNew);
+        }
+
+        if (hasNoImplementations)
+        {
+            return true;
+        }
+    }
+    return false;
+}
+
+
+//  static prepareUserLink
+
+void prepareUserLink(const Reference < XSimpleRegistry >& xDest,
+                                const OUString& linkName,
+                                const OUString& linkTarget,
+                                std::u16string_view implName)
+{
+    Reference < XRegistryKey > xRootKey = xDest->getRootKey();
+
+    if (xRootKey->getKeyType(linkName) == RegistryKeyType_LINK)
+    {
+        OUString oldImplName(searchImplForLink(xRootKey, linkName, implName));
+
+        if (!oldImplName.isEmpty())
+        {
+            createUniqueSubEntry(xDest->getRootKey()->createKey(
+                linkName + colon_old ), oldImplName);
+        }
+    }
+
+    if (xRootKey->isValid())
+        xRootKey->createLink(linkName, linkTarget);
+}
+
+
+//  static deleteUserLink
+
+void deletePathIfPossible(const Reference < XRegistryKey >& xRootKey,
+                                 const OUString& path)
+{
+    try
+    {
+        Sequence<OUString> keyNames(xRootKey->openKey(path)->getKeyNames());
+
+        if (!keyNames.hasElements() &&
+            xRootKey->openKey(path)->getValueType() == RegistryValueType_NOT_DEFINED)
+        {
+            xRootKey->deleteKey(path);
+
+            OUString newPath = path.copy(0, path.lastIndexOf('/'));
+
+            if (newPath.getLength() > 1)
+                deletePathIfPossible(xRootKey, newPath);
+        }
+    }
+    catch(InvalidRegistryException&)
+    {
+    }
+}
+
+
+//  static deleteUserLink
+
+void deleteUserLink(const Reference < XRegistryKey >& xRootKey,
+                               const OUString& linkName,
+                               std::u16string_view linkTarget,
+                               const OUString& implName)
+    // throw ( InvalidRegistryException, RuntimeException )
+{
+    bool bClean = false;
+
+    if (xRootKey->getKeyType(linkName) == RegistryKeyType_LINK)
+    {
+        OUString tmpTarget = xRootKey->getLinkTarget(linkName);
+
+        if (tmpTarget == linkTarget)
+        {
+            xRootKey->deleteLink(linkName);
+        }
+    }
+
+    Reference < XRegistryKey > xOldKey = xRootKey->openKey(
+        linkName + colon_old );
+    if (xOldKey.is())
+    {
+        if (xOldKey->getValueType() == RegistryValueType_ASCIILIST)
+        {
+            const Sequence<OUString> implEntries = xOldKey->getAsciiListValue();
+            sal_Int32 length = implEntries.getLength();
+            sal_Int32 equals = static_cast<sal_Int32>(std::count(implEntries.begin(), implEntries.end(), implName));
+            bool hasNoImplementations = false;
+
+            if (equals == length)
+            {
+                hasNoImplementations = true;
+            } else
+            {
+                OUString oldImpl;
+
+                if (length > equals + 1)
+                {
+                    Sequence<OUString> implEntriesNew(length - equals - 1);
+                    auto pNewArray = implEntriesNew.getArray();
+
+                    sal_Int32 j = 0;
+                    bool first = true;
+                    for (sal_Int32 i = 0; i < length; i++)
+                    {
+                        if (implEntries[i] != implName)
+                        {
+                            if (first)
+                            {
+                                oldImpl = implEntries[i];
+                                first = false;
+                            } else
+                            {
+                                pNewArray[j++] = implEntries[i];
+                            }
+                        }
+                    }
+
+                    xOldKey->setAsciiListValue(implEntriesNew);
+                } else
+                {
+                    oldImpl = implEntries[0];
+                    OUString path(xOldKey->getKeyName());
+                    xOldKey->closeKey();
+                    xRootKey->deleteKey(path);
+                }
+
+                OUString oldTarget = searchLinkTargetForImpl(xRootKey, linkName, oldImpl);
+                if (!oldTarget.isEmpty())
+                {
+                    xRootKey->createLink(linkName, oldTarget);
+                }
+            }
+
+            if (hasNoImplementations)
+            {
+                bClean = true;
+                OUString path(xOldKey->getKeyName());
+                xOldKey->closeKey();
+                xRootKey->deleteKey(path);
+            }
+        }
+    } else
+    {
+        bClean = true;
+    }
+
+    if (bClean)
+    {
+        OUString path = linkName.copy(0, linkName.lastIndexOf('/'));
+        deletePathIfPossible(xRootKey, path);
+    }
+}
+
+
+//  static prepareUserKeys
+
+void prepareUserKeys(const Reference < XSimpleRegistry >& xDest,
+                                const Reference < XRegistryKey >& xUnoKey,
+                                const Reference < XRegistryKey >& xKey,
+                                const OUString& implName,
+                                bool bRegister)
+{
+    bool hasSubKeys = false;
+
+    Sequence<OUString> keyNames = xKey->getKeyNames();
+
+    OUString relativKey;
+    if (keyNames.hasElements())
+        relativKey = keyNames.getConstArray()[0].copy(xKey->getKeyName().getLength()+1);
+
+    if (keyNames.getLength() == 1 &&
+        xKey->getKeyType(relativKey) == RegistryKeyType_LINK)
+    {
+        hasSubKeys = true;
+
+        OUString linkTarget = xKey->getLinkTarget(relativKey);
+        OUString linkName(xKey->getKeyName().copy(xUnoKey->getKeyName().getLength()));
+
+        linkName += "/" + relativKey;
+
+        if (bRegister)
+        {
+            prepareUserLink(xDest, linkName, linkTarget, implName);
+        } else
+        {
+            deleteUserLink(xDest->getRootKey(), linkName, linkTarget, implName);
+        }
+    } else
+    {
+        const Sequence< Reference < XRegistryKey> > subKeys = xKey->openKeys();
+
+        if (subKeys.hasElements())
+        {
+            hasSubKeys = true;
+
+            for (const Reference < XRegistryKey > & rSubKey : subKeys)
+            {
+                prepareUserKeys(xDest, xUnoKey, rSubKey, implName, bRegister);
+            }
+        }
+    }
+
+    if (hasSubKeys)
+        return;
+
+    OUString keyName(xKey->getKeyName().copy(xUnoKey->getKeyName().getLength()));
+
+    Reference < XRegistryKey > xRootKey = xDest->getRootKey();
+    if (bRegister)
+    {
+        createUniqueSubEntry(xRootKey->createKey(keyName), implName);
+    }
+    else
+    {
+        Reference< XRegistryKey > rKey = xRootKey->openKey(keyName);
+        if( rKey.is() )
+        {
+            deleteSubEntry(rKey, implName);
+            xRootKey->deleteKey(keyName);
+        }
+
+        OUString path = keyName.copy(0, keyName.lastIndexOf('/'));
+        if( !path.isEmpty() )
+        {
+            deletePathIfPossible(xRootKey, path);
+        }
+    }
+}
+
+
+//  static deleteAllImplementations
+
+void deleteAllImplementations(   const Reference < XSimpleRegistry >& xReg,
+                                        const Reference < XRegistryKey >& xSource,
+                                        std::u16string_view locationUrl,
+                                        std::vector<OUString> & implNames)
+    // throw (InvalidRegistryException, RuntimeException)
+{
+    Sequence < Reference < XRegistryKey > > subKeys = xSource->openKeys();
+
+    if (subKeys.hasElements())
+    {
+        bool hasLocationUrl = false;
+
+        for (const Reference < XRegistryKey> & xImplKey : std::as_const(subKeys))
+        {
+            Reference < XRegistryKey > xKey = xImplKey->openKey(
+                slash_UNO_slash_LOCATION );
+
+            if (xKey.is() && (xKey->getValueType() == RegistryValueType_ASCII))
+            {
+                if (xKey->getAsciiValue() == locationUrl)
+                {
+                    hasLocationUrl = true;
+
+                    OUString implName(xImplKey->getKeyName().copy(1));
+                    sal_Int32 firstDot = implName.indexOf('/');
+
+                    if (firstDot >= 0)
+                        implName = implName.copy(firstDot + 1);
+
+                    implNames.push_back(implName);
+
+                    deleteAllLinkReferences(xReg, xImplKey);
+
+                    xKey = xImplKey->openKey( slash_UNO );
+                    if (xKey.is())
+                    {
+                        const Sequence< Reference < XRegistryKey > > subKeys2 = xKey->openKeys();
+
+                        for (const Reference < XRegistryKey > & rSubKey2 : subKeys2)
+                        {
+                            if (rSubKey2->getKeyName() != OUStringConcatenation(xImplKey->getKeyName() + slash_UNO_slash_SERVICES ) &&
+                                rSubKey2->getKeyName() != OUStringConcatenation(xImplKey->getKeyName() + slash_UNO_slash_REGISTRY_LINKS ) &&
+                                rSubKey2->getKeyName() != OUStringConcatenation(xImplKey->getKeyName() + slash_UNO_slash_ACTIVATOR ) &&
+                                rSubKey2->getKeyName() != OUStringConcatenation(xImplKey->getKeyName() + slash_UNO_slash_SINGLETONS ) &&
+                                rSubKey2->getKeyName() != OUStringConcatenation(xImplKey->getKeyName() + slash_UNO_slash_LOCATION) )
+                            {
+                                prepareUserKeys(xReg, xKey, rSubKey2, implName, false);
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (hasLocationUrl)
+            {
+                hasLocationUrl = false;
+                OUString path(xImplKey->getKeyName());
+                xImplKey->closeKey();
+                xReg->getRootKey()->deleteKey(path);
+            }
+        }
+
+        subKeys = xSource->openKeys();
+        if (!subKeys.hasElements())
+        {
+            OUString path(xSource->getKeyName());
+            xSource->closeKey();
+            xReg->getRootKey()->deleteKey(path);
+        }
+    } else
+    {
+        OUString path(xSource->getKeyName());
+        xSource->closeKey();
+        xReg->getRootKey()->deleteKey(path);
+    }
+}
+
+
+void delete_all_singleton_entries(
+    Reference < registry::XRegistryKey > const & xSingletons_section,
+    ::std::vector< OUString > const & impl_names )
+    // throw (InvalidRegistryException, RuntimeException)
+{
+    Sequence< Reference< registry::XRegistryKey > > singletons( xSingletons_section->openKeys() );
+    Reference< registry::XRegistryKey > const * subkeys = singletons.getConstArray();
+    for ( sal_Int32 nPos = singletons.getLength(); nPos--; )
+    {
+        Reference< registry::XRegistryKey > const & xSingleton = subkeys[ nPos ];
+        Reference< registry::XRegistryKey > xRegisteredImplNames(
+            xSingleton->openKey( "REGISTERED_BY" ) );
+        if (xRegisteredImplNames.is() && xRegisteredImplNames->isValid())
+        {
+            Sequence< OUString > registered_implnames;
+            try
+            {
+                registered_implnames = xRegisteredImplNames->getAsciiListValue();
+            }
+            catch (registry::InvalidValueException &)
+            {
+            }
+            auto aNonConstRange = asNonConstRange(registered_implnames);
+            sal_Int32 nOrigRegLength = registered_implnames.getLength();
+            sal_Int32 nNewLength = nOrigRegLength;
+            for ( sal_Int32 n = nOrigRegLength; n--; )
+            {
+                OUString const & registered_implname = registered_implnames[ n ];
+
+                for (auto const& impl_name : impl_names)
+                {
+                    if (impl_name == registered_implname)
+                    {
+                        aNonConstRange[ n ] = registered_implnames[ nNewLength -1 ];
+                        --nNewLength;
+                    }
+                }
+            }
+
+            if (nNewLength != nOrigRegLength)
+            {
+                if (0 == nNewLength)
+                {
+                    // remove whole entry
+                    xRegisteredImplNames->closeKey();
+                    xSingleton->deleteKey( "REGISTERED_BY" );
+                    // registry key cannot provide its relative name, only absolute :(
+                    OUString abs( xSingleton->getKeyName() );
+                    xSingletons_section->deleteKey( abs.copy( abs.lastIndexOf( '/' ) +1 ) );
+                }
+                else
+                {
+                    registered_implnames.realloc( nNewLength );
+                    xRegisteredImplNames->setAsciiListValue( registered_implnames );
+                }
+            }
+        }
+    }
+}
+
+
+//  static deleteAllServiceEntries
+
+void deleteAllServiceEntries(    const Reference < XSimpleRegistry >& xReg,
+                                        const Reference < XRegistryKey >& xSource,
+                                        const OUString& implName)
+    // throw ( InvalidRegistryException, RuntimeException )
+{
+    Sequence< Reference < XRegistryKey > > subKeys = xSource->openKeys();
+
+    if (subKeys.hasElements())
+    {
+        bool hasNoImplementations = false;
+
+        for (const Reference < XRegistryKey > & xServiceKey : std::as_const(subKeys))
+        {
+            if (xServiceKey->getValueType() == RegistryValueType_ASCIILIST)
+            {
+                const Sequence<OUString> implEntries = xServiceKey->getAsciiListValue();
+                sal_Int32 length = implEntries.getLength();
+                sal_Int32 equals = static_cast<sal_Int32>(std::count(implEntries.begin(), implEntries.end(), implName));
+
+                if (equals == length)
+                {
+                    hasNoImplementations = true;
+                } else
+                {
+                    if (equals > 0)
+                    {
+                        Sequence<OUString> implEntriesNew(length-equals);
+
+                        std::copy_if(implEntries.begin(), implEntries.end(), implEntriesNew.getArray(),
+                            [&implName](const OUString& rEntry) { return rEntry != implName; });
+
+                        xServiceKey->setAsciiListValue(implEntriesNew);
+                    }
+                }
+            }
+
+            if (hasNoImplementations)
+            {
+                hasNoImplementations = false;
+                OUString path(xServiceKey->getKeyName());
+                xServiceKey->closeKey();
+                xReg->getRootKey()->deleteKey(path);
+            }
+        }
+
+        subKeys = xSource->openKeys();
+        if (!subKeys.hasElements())
+        {
+            OUString path(xSource->getKeyName());
+            xSource->closeKey();
+            xReg->getRootKey()->deleteKey(path);
+        }
+    } else
+    {
+        OUString path(xSource->getKeyName());
+        xSource->closeKey();
+        xReg->getRootKey()->deleteKey(path);
+    }
+}
+
+
+bool is_supported_service(
+    OUString const & service_name,
+    Reference< reflection::XServiceTypeDescription > const & xService_td )
+{
+    if (xService_td->getName() == service_name)
+        return true;
+    const Sequence< Reference< reflection::XServiceTypeDescription > > seq(
+        xService_td->getMandatoryServices() );
+    return std::any_of(seq.begin(), seq.end(), [&service_name](const auto& rService) {
+        return is_supported_service( service_name, rService ); });
+}
+
+
+void insert_singletons(
+    Reference< registry::XSimpleRegistry > const & xDest,
+    Reference< registry::XRegistryKey > const & xImplKey,
+    Reference< XComponentContext > const & xContext )
+    // throw( registry::InvalidRegistryException, registry::CannotRegisterImplementationException, RuntimeException )
+{
+    // singletons
+    Reference< registry::XRegistryKey > xKey( xImplKey->openKey( "UNO/SINGLETONS" ) );
+    if (!(xKey.is() && xKey->isValid()))
+        return;
+
+    OUString implname( xImplKey->getKeyName().copy( sizeof ("/IMPLEMENTATIONS/") -1 ) );
+    // singleton entries
+    Sequence< Reference< registry::XRegistryKey > > xSingletons_section( xKey->openKeys() );
+    Reference< registry::XRegistryKey > const * p = xSingletons_section.getConstArray();
+    for ( sal_Int32 nPos = xSingletons_section.getLength(); nPos--; )
+    {
+        Reference< registry::XRegistryKey > const & xSingleton = p[ nPos ];
+        OUString singleton_name(
+            xSingleton->getKeyName().copy(
+                implname.getLength() + sizeof ("/IMPLEMENTATIONS//UNO/SINGLETONS/") -1 ) );
+        OUString service_name( xSingleton->getStringValue() );
+
+        OUString keyname( "/SINGLETONS/" + singleton_name );
+        Reference< registry::XRegistryKey > xKey2( xDest->getRootKey()->openKey( keyname ) );
+        if (xKey2.is() && xKey2->isValid())
+        {
+            try
+            {
+                OUString existing_name( xKey2->getStringValue() );
+                if ( existing_name != service_name )
+                {
+                    Reference< container::XHierarchicalNameAccess > xTDMgr;
+                    OUString the_tdmgr =
+                        "/singletons/com.sun.star.reflection.theTypeDescriptionManager";
+                    xContext->getValueByName( the_tdmgr ) >>= xTDMgr;
+                    if (! xTDMgr.is())
+                    {
+                        throw RuntimeException( "cannot get singleton " + the_tdmgr );
+                    }
+                    try
+                    {
+                        Reference< reflection::XServiceTypeDescription > xExistingService_td;
+                        xTDMgr->getByHierarchicalName( existing_name ) >>= xExistingService_td;
+                        if (! xExistingService_td.is())
+                        {
+                            throw RuntimeException( "cannot get service type description: " + existing_name );
+                        }
+
+                        // everything's fine if existing service entry supports the one
+                        // to be registered
+                        if (! is_supported_service( service_name, xExistingService_td ))
+                        {
+                            throw registry::CannotRegisterImplementationException(
+                                "existing singleton service (" + singleton_name + "=" + existing_name + ") "
+                                " does not support given one: " + service_name);
+                        }
+                    }
+                    catch (const container::NoSuchElementException & exc)
+                    {
+                        css::uno::Any anyEx = cppu::getCaughtException();
+                        throw css::lang::WrappedTargetRuntimeException(
+                                "cannot get service type description: " + exc.Message,
+                                nullptr, anyEx );
+                    }
+                }
+            }
+            catch (registry::InvalidValueException &)
+            {
+                // repair
+                xKey2->setStringValue( service_name );
+            }
+        }
+        else
+        {
+            // insert singleton entry
+            xKey2 = xDest->getRootKey()->createKey( keyname );
+            xKey2->setStringValue( service_name );
+        }
+
+        Reference< registry::XRegistryKey > xRegisteredImplNames(
+            xKey2->openKey( "REGISTERED_BY" ) );
+        if (!xRegisteredImplNames.is() || !xRegisteredImplNames->isValid())
+        {
+            // create
+            xRegisteredImplNames = xKey2->createKey( "REGISTERED_BY" );
+        }
+
+        Sequence< OUString > implnames;
+        try
+        {
+            implnames = xRegisteredImplNames->getAsciiListValue();
+        }
+        catch (registry::InvalidValueException &)
+        {
+        }
+        // check implname is already in
+        if (comphelper::findValue(implnames, implname) == -1)
+        {
+            // append and write back
+            implnames.realloc( implnames.getLength() +1 );
+            implnames.getArray()[ implnames.getLength() -1 ] = implname;
+            xRegisteredImplNames->setAsciiListValue( implnames );
+        }
+    }
+}
+
+
+//  static prepareRegistry
+
+void prepareRegistry(
+    const Reference < XSimpleRegistry >& xDest,
+    const Reference < XRegistryKey >& xSource,
+    const OUString& implementationLoaderUrl,
+    const OUString& locationUrl,
+    Reference< XComponentContext > const & xContext )
+    // throw ( InvalidRegistryException, CannotRegisterImplementationException, RuntimeException )
+{
+    const Sequence< Reference < XRegistryKey > > subKeys = xSource->openKeys();
+
+    if (!subKeys.hasElements())
+    {
+        throw InvalidRegistryException(
+            "prepareRegistry(): source registry is empty" );
+    }
+
+    for (const Reference < XRegistryKey >& xImplKey : subKeys)
+    {
+        Reference < XRegistryKey >  xKey = xImplKey->openKey(
+            slash_UNO_slash_SERVICES );
+
+        if (xKey.is())
+        {
+            // update entries in SERVICES section
+            const Sequence< Reference < XRegistryKey > > serviceKeys = xKey->openKeys();
+
+            OUString implName = xImplKey->getKeyName().copy(1);
+            sal_Int32 firstDot = implName.indexOf('/');
+
+            if (firstDot >= 0)
+                implName = implName.copy(firstDot + 1);
+
+            sal_Int32 offset = xKey->getKeyName().getLength() + 1;
+
+            for (const Reference < XRegistryKey >& rServiceKey : serviceKeys)
+            {
+                OUString serviceName = rServiceKey->getKeyName().copy(offset);
+
+                createUniqueSubEntry(
+                    xDest->getRootKey()->createKey(
+                        slash_SERVICES + serviceName ),
+                    implName);
+            }
+
+            xKey = xImplKey->openKey( slash_UNO );
+            if (xKey.is())
+            {
+                const Sequence< Reference < XRegistryKey > > subKeys2 = xKey->openKeys();
+
+                for (const Reference < XRegistryKey >& rSubKey2 : subKeys2)
+                {
+                    if (rSubKey2->getKeyName() != OUStringConcatenation(xImplKey->getKeyName() + slash_UNO_slash_SERVICES) &&
+                        rSubKey2->getKeyName() != OUStringConcatenation(xImplKey->getKeyName() + slash_UNO_slash_REGISTRY_LINKS ) &&
+                        rSubKey2->getKeyName() != OUStringConcatenation(xImplKey->getKeyName() + slash_UNO_slash_SINGLETONS ))
+                    {
+                        prepareUserKeys(xDest, xKey, rSubKey2, implName, true);
+                    }
+                }
+            }
+        }
+
+        // update LOCATION entry
+        xKey = xImplKey->createKey( slash_UNO_slash_LOCATION );
+
+        if (xKey.is())
+        {
+            xKey->setAsciiValue(locationUrl);
+        }
+
+        // update ACTIVATOR entry
+        xKey = xImplKey->createKey( slash_UNO_slash_ACTIVATOR );
+
+        if (xKey.is())
+        {
+            xKey->setAsciiValue(implementationLoaderUrl);
+        }
+
+        xKey = xImplKey->openKey( slash_UNO_slash_SERVICES );
+
+        if (xKey.is() && (xKey->getValueType() == RegistryValueType_ASCIILIST))
+        {
+            // update link entries in REGISTRY_LINKS section
+            const Sequence<OUString> linkNames = xKey->getAsciiListValue();
+
+            for (const OUString& rLinkName : linkNames)
+            {
+                prepareLink(xDest, xImplKey, rLinkName);
+            }
+        }
+
+        insert_singletons( xDest, xImplKey, xContext );
+    }
+}
+
+
+void findImplementations(    const Reference < XRegistryKey > & xSource,
+                                    std::vector<OUString>& implNames)
+{
+    bool isImplKey = false;
+
+    try
+    {
+        Reference < XRegistryKey > xKey = xSource->openKey(
+            slash_UNO_slash_SERVICES );
+
+        if (xKey.is() && xKey->getKeyNames().hasElements())
+        {
+            isImplKey = true;
+
+            OUString implName = xSource->getKeyName().copy(1).replace('/', '.');
+            sal_Int32 firstDot = implName.indexOf('.');
+
+            if (firstDot >= 0)
+                implName = implName.copy(firstDot + 1);
+
+            implNames.push_back(implName);
+        }
+    }
+    catch(InvalidRegistryException&)
+    {
+    }
+
+    if (isImplKey) return;
+
+    try
+    {
+        const Sequence< Reference < XRegistryKey > > subKeys = xSource->openKeys();
+
+        for (const Reference < XRegistryKey >& rSubKey : subKeys)
+        {
+            findImplementations(rSubKey, implNames);
+        }
+    }
+    catch(InvalidRegistryException&)
+    {
+    }
+}
+
+
+class ImplementationRegistration
+    : public WeakImplHelper< XImplementationRegistration2, XServiceInfo, XInitialization >
+{
+public:
+    explicit ImplementationRegistration( const Reference < XComponentContext > & rSMgr );
+
+    // XServiceInfo
+    OUString                        SAL_CALL getImplementationName() override;
+    sal_Bool                        SAL_CALL supportsService(const OUString& ServiceName) override;
+    Sequence< OUString >            SAL_CALL getSupportedServiceNames() override;
+
+    // XImplementationRegistration
+    virtual void SAL_CALL registerImplementation(
+        const OUString& implementationLoader,
+        const OUString& location,
+        const Reference < XSimpleRegistry > & xReg) override;
+
+    virtual sal_Bool SAL_CALL revokeImplementation(
+        const OUString& location,
+        const Reference < XSimpleRegistry >& xReg) override;
+
+    virtual Sequence< OUString > SAL_CALL getImplementations(
+        const OUString& implementationLoader,
+        const OUString& location) override;
+    virtual Sequence< OUString > SAL_CALL checkInstantiation(
+        const OUString& implementationName) override;
+
+    // XImplementationRegistration2
+    virtual void SAL_CALL registerImplementationWithLocation(
+        const OUString& implementationLoader,
+        const OUString& location,
+        const OUString& registeredLocation,
+        const Reference < XSimpleRegistry > & xReg) override;
+
+    // XInitialization
+    virtual void SAL_CALL initialize(
+        const css::uno::Sequence< css::uno::Any >& aArguments ) override;
+
+private: // helper methods
+    void prepareRegister(
+        const OUString& implementationLoader,
+        const OUString& location,
+        const OUString& registeredLocation,
+        const Reference < XSimpleRegistry > & xReg);
+    // throw( CannotRegisterImplementationException, RuntimeException )
+
+    static void doRegister( const Reference < XMultiComponentFactory >& xSMgr,
+                            const Reference < XComponentContext > &xCtx,
+                            const Reference < XImplementationLoader >& xAct,
+                            const Reference < XSimpleRegistry >& xDest,
+                            const OUString& implementationLoaderUrl,
+                            const OUString& locationUrl,
+                            const OUString& registeredLocationUrl);
+        /* throw ( InvalidRegistryException,
+                   MergeConflictException,
+                   CannotRegisterImplementationException, RuntimeException ) */
+
+    static void doRevoke( const Reference < XSimpleRegistry >& xDest,
+                          std::u16string_view locationUrl );
+        // throw( InvalidRegistryException, RuntimeException )
+    Reference< XSimpleRegistry > getRegistryFromServiceManager() const;
+
+    static Reference< XSimpleRegistry > createTemporarySimpleRegistry(
+        const Reference< XMultiComponentFactory > &rSMgr,
+        const Reference < XComponentContext > & rCtx );
+
+private: // members
+    Reference < XMultiComponentFactory >    m_xSMgr;
+    Reference < XComponentContext >         m_xCtx;
+};
+
+
+// ImplementationRegistration()
+
+ImplementationRegistration::ImplementationRegistration( const Reference < XComponentContext > & xCtx )
+    : m_xSMgr( xCtx->getServiceManager() )
+    , m_xCtx( xCtx )
+{}
+
+// XServiceInfo
+OUString ImplementationRegistration::getImplementationName()
+{
+    return "com.sun.star.comp.stoc.ImplementationRegistration";
+}
+
+// XServiceInfo
+sal_Bool ImplementationRegistration::supportsService(const OUString& ServiceName)
+{
+    return cppu::supportsService(this, ServiceName);
+}
+
+// XServiceInfo
+Sequence< OUString > ImplementationRegistration::getSupportedServiceNames()
+{
+    return { "com.sun.star.registry.ImplementationRegistration" };
+}
+
+Reference< XSimpleRegistry > ImplementationRegistration::getRegistryFromServiceManager() const
+{
+    Reference < XPropertySet > xPropSet( m_xSMgr, UNO_QUERY );
+    Reference < XSimpleRegistry > xRegistry;
+
+    if( xPropSet.is() ) {
+
+        try {  // the implementation does not support XIntrospectionAccess !
+
+            Any aAny = xPropSet->getPropertyValue( Registry );
+
+            if( aAny.getValueType().getTypeClass() == TypeClass_INTERFACE ) {
+                aAny >>= xRegistry;
+            }
+         }
+         catch( UnknownPropertyException & ) {
+             // empty reference is error signal !
+        }
+    }
+
+    return xRegistry;
+}
+
+
+// XInitialization
+
+void ImplementationRegistration::initialize(
+    const css::uno::Sequence< css::uno::Any >& aArgs )
+{
+
+    if( aArgs.getLength() != 4 ) {
+        throw IllegalArgumentException(
+            "ImplementationRegistration::initialize() expects 4 parameters, got "  + OUString::number( aArgs.getLength() ),
+            Reference<XInterface > (), 0 );
+    }
+
+    Reference< XImplementationLoader > rLoader;
+    OUString loaderServiceName;
+    OUString locationUrl;
+    Reference< XSimpleRegistry > rReg;
+
+    // 1st argument : An instance of an implementation loader
+    if( aArgs.getConstArray()[0].getValueType().getTypeClass() == TypeClass_INTERFACE ) {
+        aArgs.getConstArray()[0] >>= rLoader;
+    }
+    if( !rLoader.is()) {
+        throw IllegalArgumentException(
+            "ImplementationRegistration::initialize() invalid first parameter,"
+            "expected " + cppu::UnoType<decltype(rLoader)>::get().getTypeName() +
+            ", got " + aArgs.getConstArray()[0].getValueTypeName(),
+            Reference< XInterface > (), 0 );
+    }
+
+    // 2nd argument : The service name of the loader. This name is written into the registry
+    if( aArgs.getConstArray()[1].getValueType().getTypeClass() == TypeClass_STRING ) {
+        aArgs.getConstArray()[1] >>= loaderServiceName;
+    }
+    if( loaderServiceName.isEmpty() ) {
+        throw IllegalArgumentException(
+            "ImplementationRegistration::initialize() invalid second parameter,"
+            "expected string, got " + aArgs.getConstArray()[1].getValueTypeName(),
+            Reference< XInterface > (), 0 );
+    }
+
+    // 3rd argument : The file name of the dll, that contains the loader
+    if( aArgs.getConstArray()[2].getValueType().getTypeClass() == TypeClass_STRING ) {
+        aArgs.getConstArray()[2] >>= locationUrl;
+    }
+    if( locationUrl.isEmpty() ) {
+        throw IllegalArgumentException(
+            "ImplementationRegistration::initialize() invalid third parameter,"
+            "expected string, got " + aArgs.getConstArray()[2].getValueTypeName(),
+            Reference< XInterface > (), 0 );
+    }
+
+    // 4th argument : The registry, the service should be written to
+    if( aArgs.getConstArray()[3].getValueType().getTypeClass() == TypeClass_INTERFACE ) {
+        aArgs.getConstArray()[3] >>= rReg;
+    }
+
+    if( !rReg.is() ) {
+        rReg = getRegistryFromServiceManager();
+        if( !rReg.is() ) {
+            throw IllegalArgumentException(
+                "ImplementationRegistration::initialize() invalid fourth parameter,"
+                "expected " + cppu::UnoType<decltype(rReg)>::get().getTypeName() +
+                ", got " + aArgs.getConstArray()[3].getValueTypeName(),
+                Reference< XInterface > (), 0 );
+        }
+    }
+
+    doRegister(m_xSMgr, m_xCtx, rLoader , rReg, loaderServiceName , locationUrl, locationUrl);
+}
+
+
+// virtual function registerImplementationWithLocation of XImplementationRegistration2
+
+void ImplementationRegistration::registerImplementationWithLocation(
+    const OUString& implementationLoaderUrl,
+    const OUString& locationUrl,
+    const OUString& registeredLocationUrl,
+    const Reference < XSimpleRegistry > & xReg)
+{
+    prepareRegister(
+        implementationLoaderUrl, locationUrl, registeredLocationUrl, xReg);
+}
+
+// helper function
+void ImplementationRegistration::prepareRegister(
+    const OUString& implementationLoaderUrl,
+    const OUString& locationUrl,
+    const OUString& registeredLocationUrl,
+    const Reference < XSimpleRegistry > & xReg)
+    // throw( CannotRegisterImplementationException, RuntimeException )
+{
+    OUString activatorName;
+
+    if (!implementationLoaderUrl.isEmpty())
+    {
+        activatorName = implementationLoaderUrl.getToken(0, ':');
+    } else
+    {
+        // check locationUrl to find out what kind of loader is needed
+        // set implLoaderUrl
+    }
+
+    if( !m_xSMgr.is() )    {
+        throw CannotRegisterImplementationException(
+                "ImplementationRegistration::registerImplementation() "
+                "no componentcontext available to instantiate loader" );
+    }
+
+    try
+    {
+        Reference < XImplementationLoader > xAct(
+            m_xSMgr->createInstanceWithContext(activatorName, m_xCtx) , UNO_QUERY );
+        if (!xAct.is())
+        {
+            throw CannotRegisterImplementationException(
+                "ImplementationRegistration::registerImplementation() - The service "
+                + activatorName + " cannot be instantiated" );
+        }
+
+        Reference < XSimpleRegistry > xRegistry;
+
+        if (xReg.is())
+        {
+            // registry supplied by user
+            xRegistry = xReg;
+        }
+        else
+        {
+            xRegistry = getRegistryFromServiceManager();
+        }
+
+        if ( xRegistry.is())
+        {
+            doRegister(m_xSMgr, m_xCtx, xAct, xRegistry, implementationLoaderUrl,
+                       locationUrl, registeredLocationUrl);
+        }
+
+    }
+    catch( CannotRegisterImplementationException & )
+    {
+        throw;
+    }
+    catch( const InvalidRegistryException & e )
+    {
+        throw CannotRegisterImplementationException(
+            "ImplementationRegistration::registerImplementation() "
+            "InvalidRegistryException during registration (" + e.Message + ")" );
+    }
+    catch( const MergeConflictException & e )
+    {
+        throw CannotRegisterImplementationException(
+            "ImplementationRegistration::registerImplementation() "
+            "MergeConflictException during registration (" + e.Message + ")" );
+    }
+
+}
+
+
+// virtual function registerImplementation of XImplementationRegistration
+
+void ImplementationRegistration::registerImplementation(
+    const OUString& implementationLoaderUrl,
+    const OUString& locationUrl,
+    const Reference < XSimpleRegistry > & xReg)
+{
+    prepareRegister(implementationLoaderUrl, locationUrl, locationUrl, xReg);
+}
+
+
+// virtual function revokeImplementation of XImplementationRegistration
+
+sal_Bool ImplementationRegistration::revokeImplementation(const OUString& location,
+                                                      const Reference < XSimpleRegistry >& xReg)
+{
+    bool ret = false;
+
+    Reference < XSimpleRegistry > xRegistry;
+
+    if (xReg.is()) {
+        xRegistry = xReg;
+    }
+    else {
+        Reference < XPropertySet > xPropSet( m_xSMgr, UNO_QUERY );
+        if( xPropSet.is() ) {
+            try {
+                Any aAny = xPropSet->getPropertyValue( Registry );
+
+                if( aAny.getValueType().getTypeClass() == TypeClass_INTERFACE )
+                {
+                    aAny >>= xRegistry;
+                }
+            }
+            catch ( UnknownPropertyException & ) {
+            }
+        }
+    }
+
+    if (xRegistry.is())
+    {
+        try
+        {
+            doRevoke(xRegistry, location);
+            ret = true;
+        }
+        catch( InvalidRegistryException & )
+        {
+            // no way to transport the error, as no exception is specified and a runtime
+            // exception is not appropriate.
+            OSL_FAIL( "InvalidRegistryException during revokeImplementation" );
+        }
+    }
+
+    return ret;
+}
+
+
+// virtual function getImplementations of XImplementationRegistration
+
+Sequence< OUString > ImplementationRegistration::getImplementations(
+    const OUString & implementationLoaderUrl,
+    const OUString & locationUrl)
+{
+    OUString activatorName;
+
+    if (!implementationLoaderUrl.isEmpty())
+    {
+        activatorName = implementationLoaderUrl.getToken(0, ':');
+    } else
+    {
+        // check locationUrl to find out what kind of loader is needed
+        // set implementationLoaderUrl
+    }
+
+    if( m_xSMgr.is() ) {
+
+        Reference < XImplementationLoader > xAct(
+            m_xSMgr->createInstanceWithContext( activatorName, m_xCtx ), UNO_QUERY );
+
+        if (xAct.is())
+        {
+
+            Reference < XSimpleRegistry > xReg =
+                createTemporarySimpleRegistry( m_xSMgr, m_xCtx);
+
+            if (xReg.is())
+            {
+                try
+                {
+                    xReg->open(OUString() /* in mem */, false, true);
+                    Reference < XRegistryKey > xImpl;
+
+                    { // only necessary for deleting the temporary variable of rootkey
+                        xImpl = xReg->getRootKey()->createKey( slash_IMPLEMENTATIONS );
+                    }
+                    if (xAct->writeRegistryInfo(xImpl, implementationLoaderUrl, locationUrl))
+                    {
+                        std::vector<OUString> implNames;
+
+                        findImplementations(xImpl, implNames);
+
+                        if (!implNames.empty())
+                        {
+                            Sequence<OUString> seqImpl(comphelper::containerToSequence(implNames));
+                            xImpl->closeKey();
+                            return seqImpl;
+                        }
+                    }
+
+                    xImpl->closeKey();
+                }
+                catch(MergeConflictException&)
+                {
+                }
+                catch(InvalidRegistryException&)
+                {
+                }
+            }
+        }
+    }
+
+    return Sequence<OUString>();
+}
+
+
+// virtual function checkInstantiation of XImplementationRegistration
+
+Sequence< OUString > ImplementationRegistration::checkInstantiation(const OUString&)
+{
+    OSL_FAIL( "ImplementationRegistration::checkInstantiation not implemented" );
+    return Sequence<OUString>();
+}
+
+
+// helper function doRegistration
+
+
+void ImplementationRegistration::doRevoke(
+    const Reference < XSimpleRegistry >& xDest,
+    std::u16string_view locationUrl)
+    // throw ( InvalidRegistryException, RuntimeException )
+{
+    if( !xDest.is() )
+        return;
+
+    std::vector<OUString> aNames;
+
+    Reference < XRegistryKey > xRootKey( xDest->getRootKey() );
+
+    Reference < XRegistryKey > xKey =
+        xRootKey->openKey( slash_IMPLEMENTATIONS );
+    if (xKey.is() && xKey->isValid())
+    {
+        deleteAllImplementations(xDest, xKey, locationUrl, aNames);
+    }
+
+    xKey = xRootKey->openKey( slash_SERVICES );
+    if (xKey.is())
+    {
+        for (auto const& name : aNames)
+        {
+            deleteAllServiceEntries(xDest, xKey, name);
+        }
+    }
+
+    xKey = xRootKey->openKey( "/SINGLETONS" );
+    if (xKey.is() && xKey->isValid())
+    {
+        delete_all_singleton_entries( xKey, aNames );
+    }
+
+    if (xRootKey.is())
+        xRootKey->closeKey();
+    if (xKey.is() && xKey->isValid() )
+        xKey->closeKey();
+}
+
+void ImplementationRegistration::doRegister(
+    const Reference< XMultiComponentFactory > & xSMgr,
+    const Reference< XComponentContext > &xCtx,
+    const Reference < XImplementationLoader > & xAct,
+    const Reference < XSimpleRegistry >& xDest,
+    const OUString& implementationLoaderUrl,
+    const OUString& locationUrl,
+    const OUString& registeredLocationUrl)
+    /* throw ( InvalidRegistryException,
+               MergeConflictException,
+               CannotRegisterImplementationException, RuntimeException ) */
+{
+    Reference < XSimpleRegistry >   xReg =
+        createTemporarySimpleRegistry( xSMgr, xCtx );
+    Reference < XRegistryKey >      xSourceKey;
+
+    if (!(xAct.is() && xReg.is() && xDest.is()))
+        return;
+
+    try
+    {
+        xReg->open(OUString() /* in mem */, false, true);
+
+        { // only necessary for deleting the temporary variable of rootkey
+            xSourceKey = xReg->getRootKey()->createKey( slash_IMPLEMENTATIONS );
+        }
+
+        bool bSuccess =
+            xAct->writeRegistryInfo(xSourceKey, implementationLoaderUrl, locationUrl);
+        if ( !bSuccess )
+        {
+            throw CannotRegisterImplementationException(
+                "ImplementationRegistration::doRegistration() component registration signaled failure" );
+        }
+
+        prepareRegistry(xDest, xSourceKey, implementationLoaderUrl, registeredLocationUrl, xCtx);
+
+        xSourceKey->closeKey();
+
+        xSourceKey = xReg->getRootKey();
+        Reference < XRegistryKey > xDestKey = xDest->getRootKey();
+        stoc_impreg::mergeKeys( xDestKey, xSourceKey );
+        xDestKey->closeKey();
+        xSourceKey->closeKey();
+
+
+        // Cleanup Source registry.
+        if ( xSourceKey->isValid() )
+            xSourceKey->closeKey();
+    }
+    catch(CannotRegisterImplementationException&)
+    {
+        if ( xSourceKey->isValid() )
+            xSourceKey->closeKey();
+        // and throw again
+        throw;
+    }
+}
+
+
+Reference< XSimpleRegistry > ImplementationRegistration::createTemporarySimpleRegistry(
+    const Reference< XMultiComponentFactory > &rSMgr,
+    const Reference < XComponentContext > & xCtx)
+{
+
+    Reference < XSimpleRegistry > xReg(
+        rSMgr->createInstanceWithContext(
+            com_sun_star_registry_SimpleRegistry,   xCtx ),
+        UNO_QUERY);
+    OSL_ASSERT( xReg.is() );
+    return xReg;
+}
+
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_comp_stoc_ImplementationRegistration_get_implementation(
+    css::uno::XComponentContext *context,
+    css::uno::Sequence<css::uno::Any> const &)
+{
+    return cppu::acquire(new ImplementationRegistration(context));
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */