    /* -*- 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 <sal/config.h>
    #include <sal/log.hxx>

    #include <osl/diagnose.h>
    #include <sfx2/Metadatable.hxx>
    #include <sfx2/XmlIdRegistry.hxx>

    #include <vcl/svapp.hxx>
    #include <com/sun/star/lang/IllegalArgumentException.hpp>
    #include <comphelper/random.hxx>

    #include <algorithm>
    #include <list>
    #include <memory>
    #include <unordered_map>
    #if OSL_DEBUG_LEVEL > 0
    #include <typeinfo>
    #endif

    /** XML ID handling.

        There is an abstract base class <type>XmlIdRegistry</type>, with
        2 subclasses <type>XmlIdRegistryDocument</type> for "normal" documents,
        and <type>XmlIdRegistryClipboard</type> for clipboard documents.
        These classes are responsible for managing XML IDs for all elements
        of the model. Only the implementation of the <type>Metadatable</type>
        base class needs to know the registries, so they are not in the header.

        The handling of XML IDs differs between clipboard and non-clipboard
        documents in several aspects. Most importantly, non-clipboard documents
        can have several elements associated with one XML ID.
        This is necessary because of the weird undo implementation:
        deleting a text node moves the deleted node to the undo array, but
        executing undo will then create a <em>copy</em> of that node in the
        document array. These 2 nodes must have the same XML ID, because
        we cannot know whether the user will do a redo next, or something else.

        Because we need to have a mechanism for several objects per XML ID anyway,
        we use that also to enable some usability features:
        The document registry has a list of Metadatables per XML ID.
        This list is sorted by priority, i.e., the first element has highest
        priority. When inserting copies, care must be taken that they are inserted
        at the right position: either before or after the source.
        This is done by <method>Metadatable::RegisterAsCopyOf</method>.
        When a text node is split, then both resulting text nodes are inserted
        into the list. If the user then deletes one text node, the other one
        will have the XML ID.
        Also, when a Metadatable is copied to the clipboard and then pasted,
        the copy is inserted into the list. If the user then deletes the source,
        the XML ID is not lost.
        The goal is that it should be hard to lose an XML ID by accident, which
        is especially important as long as we do not have an UI that displays them.

        There are two subclasses of <type>Metadatable</type>:
        <ul><li><type>MetadatableClipboard</type>: for copies in the clipboard</li>
            <li><type>MetadatableUndo</type>: for undo, because a Metadatable
            may be destroyed on delete and a new one created on undo.</li></ul>
        These serve only to track the position in an XML ID list in a document
        registry, so that future actions can insert objects at the right position.
        Unfortunately, inserting dummy objects seems to be necessary:
        <ul><li>it is not sufficient to just remember the saved id, because then
                the relative priorities might change when executing the undo</li>
            <li>it is not sufficient to record the position as an integer, because
                if we delete a text node and then undo, the node will be copied(!),
                and we will have one more node in the list.<li>
            <li>it is not sufficient to record the pointer of the previous/next
                Metadatable, because if we delete a text node, undo, and then
                do something to clear the redo array, the original text node is
                destroyed, and is replaced by the copy created by undo</li></ul>

        If content from a non-clipboard document is copied into a clipboard
        document, a dummy <type>MetadatableClipboard</type> is inserted into the
        non-clipboard document registry in order to track the position of the
        source element.  When the clipboard content is pasted back into the source
        document, this dummy object is used to associate the pasted element with
        that same XML ID.

        If a <type>Metadatable</type> is deleted or merged,
        <method>Metadatable::CreateUndo</method> is called, and returns a
        <type>MetadatableUndo<type> instance, which can be used to undo the action
        by passing it to <method>Metadatable::RestoreMetadata</method>.

     */

    using namespace ::com::sun::star;

    using ::sfx2::isValidXmlId;

    namespace sfx2 {

    static const char s_content [] = "content.xml";
    static const char s_styles  [] = "styles.xml";

    static bool isContentFile(OUString const & i_rPath)
    {
        return i_rPath == s_content;
    }

    static bool isStylesFile (OUString const & i_rPath)
    {
        return i_rPath == s_styles;
    }

    // XML ID handling ---------------------------------------------------

    /** handles registration of XMetadatable.

        This class is responsible for guaranteeing that XMetadatable objects
        always have XML IDs that are unique within a stream.

        This is an abstract base class; see subclasses XmlIdRegistryDocument and
        XmlIdRegistryClipboard.

        @see SwDoc::GetXmlIdRegistry
        @see SwDocShell::GetXmlIdRegistry
     */
    class XmlIdRegistry : public sfx2::IXmlIdRegistry
    {

    public:
        XmlIdRegistry();

        /** get the ODF element with the given metadata reference. */
        virtual css::uno::Reference< css::rdf::XMetadatable >
            GetElementByMetadataReference(
                const css::beans::StringPair & i_rReference) const
            override;

        /** register an ODF element at a newly generated, unique metadata reference.

            <p>
            Find a fresh XML ID, and register it for the element.
            The generated ID does not occur in any stream of the document.
            </p>
         */
        virtual void RegisterMetadatableAndCreateID(Metadatable& i_xObject) = 0;

        /** try to register an ODF element at a given XML ID, or update its
            registration to a different XML ID.

            <p>
            If the given new metadata reference is not already occupied in the
            document, unregister the element at its old metadata reference if
            it has one, and register the new metadata reference for the element.
            Note that this method only ensures that XML IDs are unique per stream,
            so using the same XML ID in both content.xml and styles.xml is allowed.
            </p>

            @returns
                true iff the element has successfully been registered
         */
        virtual bool TryRegisterMetadatable(Metadatable& i_xObject,
            OUString const& i_rStreamName, OUString const& i_rIdref)
            = 0;

        /** unregister an ODF element.

            <p>
            Unregister the element at its metadata reference.
            Does not remove the metadata reference from the element.
            </p>

            @see RemoveXmlIdForElement
         */
        virtual void UnregisterMetadatable(Metadatable const&) = 0;

        /** get the metadata reference for the given element. */
        css::beans::StringPair
            GetXmlIdForElement(Metadatable const&) const;

        /** remove the metadata reference for the given element. */
        virtual void RemoveXmlIdForElement(Metadatable const&) = 0;

    protected:

        virtual bool LookupXmlId(const Metadatable& i_xObject,
            OUString & o_rStream, OUString & o_rIdref) const = 0;

        virtual Metadatable* LookupElement(const OUString & i_rStreamName,
            const OUString & i_rIdref) const = 0;
    };

    // XmlIdRegistryDocument ---------------------------------------------

    /** non-clipboard documents */
    class XmlIdRegistryDocument : public XmlIdRegistry
    {

    public:
        XmlIdRegistryDocument();

        virtual ~XmlIdRegistryDocument() override;

        virtual void RegisterMetadatableAndCreateID(Metadatable& i_xObject) override;

        virtual bool TryRegisterMetadatable(Metadatable& i_xObject,
            OUString const& i_rStreamName, OUString const& i_rIdref) override;

        virtual void UnregisterMetadatable(Metadatable const&) override;

        virtual void RemoveXmlIdForElement(Metadatable const&) override;

        /** register i_rCopy as a copy of i_rSource,
            with precedence iff i_bCopyPrecedesSource is true */
        void RegisterCopy(Metadatable const& i_rSource, Metadatable & i_rCopy,
            const bool i_bCopyPrecedesSource);

        /** create a Undo Metadatable for i_rObject. */
        static std::shared_ptr<MetadatableUndo> CreateUndo(
            Metadatable const& i_rObject);

        /** merge i_rMerged and i_rOther into i_rMerged. */
        void JoinMetadatables(Metadatable & i_rMerged, Metadatable const& i_rOther);

        // unfortunately public, Metadatable::RegisterAsCopyOf needs this
        virtual bool LookupXmlId(const Metadatable& i_xObject,
            OUString & o_rStream, OUString & o_rIdref) const override;

    private:

        virtual Metadatable* LookupElement(const OUString & i_rStreamName,
            const OUString & i_rIdref) const override;

        struct XmlIdRegistry_Impl;
        ::std::unique_ptr<XmlIdRegistry_Impl> m_pImpl;
    };

    // MetadatableUndo ---------------------------------------------------

    /** the horrible Undo Metadatable: is inserted into lists to track position */
    class MetadatableUndo : public Metadatable
    {
        /// as determined by the stream of the source in original document
        const bool m_isInContent;
    public:
        explicit MetadatableUndo(const bool i_isInContent)
            : m_isInContent(i_isInContent) { }
        virtual ::sfx2::XmlIdRegistry& GetRegistry() override
        {
            // N.B. for Undo, m_pReg is initialized by registering this as copy in
            // CreateUndo; it is never cleared
            OSL_ENSURE(m_pReg, "no m_pReg in MetadatableUndo ?");
            return *m_pReg;
        }
        virtual bool IsInClipboard() const override { return false; }
        virtual bool IsInUndo() const override { return true; }
        virtual bool IsInContent() const override { return m_isInContent; }
        virtual css::uno::Reference< css::rdf::XMetadatable > MakeUnoObject() override
        { OSL_FAIL("MetadatableUndo::MakeUnoObject"); throw; }
    };

    // MetadatableClipboard ----------------------------------------------

    /** the horrible Clipboard Metadatable: inserted into lists to track position */
    class MetadatableClipboard : public Metadatable
    {
        /// as determined by the stream of the source in original document
        const bool m_isInContent;
    public:
        explicit MetadatableClipboard(const bool i_isInContent)
            : m_isInContent(i_isInContent) { }
        virtual ::sfx2::XmlIdRegistry& GetRegistry() override
        {
            // N.B. for Clipboard, m_pReg is initialized by registering this as copy in
            // RegisterAsCopyOf; it is only cleared by OriginNoLongerInBusinessAnymore
            assert(m_pReg && "no m_pReg in MetadatableClipboard ?");
            return *m_pReg;
        }
        virtual bool IsInClipboard() const override { return true; }
        virtual bool IsInUndo() const override { return false; }
        virtual bool IsInContent() const override { return m_isInContent; }
        virtual css::uno::Reference< css::rdf::XMetadatable > MakeUnoObject() override
        { OSL_FAIL("MetadatableClipboard::MakeUnoObject"); throw; }
        void OriginNoLongerInBusinessAnymore() { m_pReg = nullptr; }
    };

    // XmlIdRegistryClipboard --------------------------------------------

    class XmlIdRegistryClipboard : public XmlIdRegistry
    {

    public:
        XmlIdRegistryClipboard();

        virtual void RegisterMetadatableAndCreateID(Metadatable& i_xObject) override;

        virtual bool TryRegisterMetadatable(Metadatable& i_xObject,
            OUString const& i_rStreamName, OUString const& i_rIdref) override;

        virtual void UnregisterMetadatable(Metadatable const&) override;

        virtual void RemoveXmlIdForElement(Metadatable const&) override;

        /** register i_rCopy as a copy of i_rSource */
        MetadatableClipboard & RegisterCopyClipboard(Metadatable & i_rCopy,
            beans::StringPair const & i_rReference,
            const bool i_isLatent);

        /** get the Metadatable that links i_rObject to its origin registry */
        MetadatableClipboard const* SourceLink(Metadatable const& i_rObject);

    private:
        virtual bool LookupXmlId(const Metadatable& i_xObject,
            OUString & o_rStream, OUString & o_rIdref) const override;

        virtual Metadatable* LookupElement(const OUString & i_rStreamName,
            const OUString & i_rIdref) const override;

        /** create a Clipboard Metadatable for i_rObject. */
        static std::shared_ptr<MetadatableClipboard> CreateClipboard(
            const bool i_isInContent);

        struct XmlIdRegistry_Impl;
        ::std::unique_ptr<XmlIdRegistry_Impl> m_pImpl;
    };

    // XmlIdRegistry

    ::sfx2::IXmlIdRegistry * createXmlIdRegistry(const bool i_DocIsClipboard)
    {
        return i_DocIsClipboard
            ? static_cast<XmlIdRegistry*>( new XmlIdRegistryClipboard )
            : static_cast<XmlIdRegistry*>( new XmlIdRegistryDocument );
    }

    XmlIdRegistry::XmlIdRegistry()
    {
    }

    css::uno::Reference< css::rdf::XMetadatable >
    XmlIdRegistry::GetElementByMetadataReference(
        const beans::StringPair & i_rReference) const
    {
        Metadatable* pObject( LookupElement(i_rReference.First,
            i_rReference.Second) );
        return pObject ? pObject->MakeUnoObject() : nullptr;
    }

    beans::StringPair
    XmlIdRegistry::GetXmlIdForElement(const Metadatable& i_rObject) const
    {
        OUString path;
        OUString idref;
        if (LookupXmlId(i_rObject, path, idref))
        {
            if (LookupElement(path, idref) == &i_rObject)
            {
                return beans::StringPair(path, idref);
            }
        }
        return beans::StringPair();
    }

    /// generate unique xml:id
    template< typename T >
    /*static*/ OUString create_id(const
        std::unordered_map< OUString, T > & i_rXmlIdMap)
    {
        static bool bHack = (getenv("LIBO_ONEWAY_STABLE_ODF_EXPORT") != nullptr);
        static const char prefix[] = "id";  // prefix for generated xml:id
        typename std::unordered_map< OUString, T >
            ::const_iterator iter;
        OUString id;

        if (bHack)
        {
            static sal_Int64 nIdCounter = SAL_CONST_INT64(4000000000);
            do
            {
                id = prefix + OUString::number(nIdCounter++);
                iter = i_rXmlIdMap.find(id);
            }
            while (iter != i_rXmlIdMap.end());
        }
        else
        {
            do
            {
                unsigned int const n(comphelper::rng::uniform_uint_distribution(0,
                                        std::numeric_limits<unsigned int>::max()));
                id = prefix + OUString::number(n);
                iter = i_rXmlIdMap.find(id);
            }
            while (iter != i_rXmlIdMap.end());
        }
        return id;
    }

    // Document XML ID Registry (_Impl)

    /// element list
    typedef ::std::vector< Metadatable* > XmlIdVector_t;

    /// Idref -> (content.xml element list, styles.xml element list)
    typedef std::unordered_map< OUString,
        ::std::pair< XmlIdVector_t, XmlIdVector_t > > XmlIdMap_t;

    /// pointer hash template
    template<typename T> struct PtrHash
    {
        size_t operator() (T const * i_pT) const
        {
            return reinterpret_cast<size_t>(i_pT);
        }
    };

    /// element -> (stream name, idref)
    typedef std::unordered_map< const Metadatable*,
        ::std::pair< OUString, OUString>, PtrHash<Metadatable> >
        XmlIdReverseMap_t;

    struct XmlIdRegistryDocument::XmlIdRegistry_Impl
    {
        XmlIdRegistry_Impl()
            : m_XmlIdMap(), m_XmlIdReverseMap() { }

        bool TryInsertMetadatable(Metadatable& i_xObject,
            const OUString & i_rStream, const OUString & i_rIdref);

        bool LookupXmlId(const Metadatable& i_xObject,
            OUString & o_rStream, OUString & o_rIdref) const;

        Metadatable* LookupElement(const OUString & i_rStreamName,
            const OUString & i_rIdref) const;

        const XmlIdVector_t * LookupElementVector(
            const OUString & i_rStreamName,
            const OUString & i_rIdref) const;

              XmlIdVector_t * LookupElementVector(
            const OUString & i_rStreamName,
            const OUString & i_rIdref)
        {
            return const_cast<XmlIdVector_t*>(
                const_cast<const XmlIdRegistry_Impl*>(this)
                    ->LookupElementVector(i_rStreamName, i_rIdref));
        }

        XmlIdMap_t m_XmlIdMap;
        XmlIdReverseMap_t m_XmlIdReverseMap;
    };

    static void
    rmIter(XmlIdMap_t & i_rXmlIdMap, XmlIdMap_t::iterator const& i_rIter,
        OUString const & i_rStream, Metadatable const& i_rObject)
    {
        if (i_rIter != i_rXmlIdMap.end())
        {
            XmlIdVector_t & rVector( isContentFile(i_rStream)
                ? i_rIter->second.first : i_rIter->second.second );
            rVector.erase(std::remove(rVector.begin(), rVector.end(), &const_cast<Metadatable&>(i_rObject)));
            if (i_rIter->second.first.empty() && i_rIter->second.second.empty())
            {
                i_rXmlIdMap.erase(i_rIter);
            }
        }
    }

    const XmlIdVector_t *
    XmlIdRegistryDocument::XmlIdRegistry_Impl::LookupElementVector(
        const OUString & i_rStreamName,
        const OUString & i_rIdref) const
    {
        const XmlIdMap_t::const_iterator iter( m_XmlIdMap.find(i_rIdref) );
        if (iter != m_XmlIdMap.end())
        {
            OSL_ENSURE(!iter->second.first.empty() || !iter->second.second.empty(),
                "null entry in m_XmlIdMap");
            return (isContentFile(i_rStreamName))
                ?  &iter->second.first
                :  &iter->second.second;
        }
        else
        {
            return nullptr;
        }
    }

    Metadatable*
    XmlIdRegistryDocument::XmlIdRegistry_Impl::LookupElement(
        const OUString & i_rStreamName,
        const OUString & i_rIdref) const
    {
        if (!isValidXmlId(i_rStreamName, i_rIdref))
        {
            throw lang::IllegalArgumentException("illegal XmlId", nullptr, 0);
        }

        const XmlIdVector_t * pList( LookupElementVector(i_rStreamName, i_rIdref) );
        if (pList)
        {
            const XmlIdVector_t::const_iterator iter(
                ::std::find_if(pList->begin(), pList->end(),
                    [](Metadatable* item)->bool {
                        return !(item->IsInUndo() || item->IsInClipboard());
                        } ) ) ;
            if (iter != pList->end())
            {
                return *iter;
            }
        }
        return nullptr;
    }

    bool
    XmlIdRegistryDocument::XmlIdRegistry_Impl::LookupXmlId(
        const Metadatable& i_rObject,
        OUString & o_rStream, OUString & o_rIdref) const
    {
        const XmlIdReverseMap_t::const_iterator iter(
            m_XmlIdReverseMap.find(&i_rObject) );
        if (iter != m_XmlIdReverseMap.end())
        {
            OSL_ENSURE(!iter->second.first.isEmpty(),
                "null stream in m_XmlIdReverseMap");
            OSL_ENSURE(!iter->second.second.isEmpty(),
                "null id in m_XmlIdReverseMap");
            o_rStream = iter->second.first;
            o_rIdref  = iter->second.second;
            return true;
        }
        else
        {
            return false;
        }
    }

    bool
    XmlIdRegistryDocument::XmlIdRegistry_Impl::TryInsertMetadatable(
        Metadatable & i_rObject,
        const OUString & i_rStreamName, const OUString & i_rIdref)
    {
        const bool bContent( isContentFile(i_rStreamName) );
        OSL_ENSURE(isContentFile(i_rStreamName) || isStylesFile(i_rStreamName),
            "invalid stream");

        XmlIdVector_t * pList( LookupElementVector(i_rStreamName, i_rIdref) );
        if (pList)
        {
            if (pList->empty())
            {
                pList->push_back( &i_rObject );
                return true;
            }
            else
            {
                // this is only called from TryRegister now, so check
                // if all elements in the list are deleted (in undo) or
                // placeholders, then "steal" the id from them
                if ( std::none_of(pList->begin(), pList->end(),
                    [](Metadatable* item)->bool {
                        return !(item->IsInUndo() || item->IsInClipboard());
                        } ) )
                {
                    pList->insert(pList->begin(), &i_rObject );
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }
        else
        {
            m_XmlIdMap.insert(::std::make_pair(i_rIdref, bContent
                ? ::std::make_pair( XmlIdVector_t( 1, &i_rObject ), XmlIdVector_t() )
                : ::std::make_pair( XmlIdVector_t(), XmlIdVector_t( 1, &i_rObject ) )));
            return true;
        }
    }

    // Document XML ID Registry

    XmlIdRegistryDocument::XmlIdRegistryDocument()
        :   m_pImpl( new XmlIdRegistry_Impl )
    {
    }

    static void
    removeLink(Metadatable* i_pObject)
    {
        OSL_ENSURE(i_pObject, "null in list ???");
        if (!i_pObject) return;
        if (i_pObject->IsInClipboard())
        {
            MetadatableClipboard* pLink(
                dynamic_cast<MetadatableClipboard*>( i_pObject ) );
            OSL_ENSURE(pLink, "IsInClipboard, but no MetadatableClipboard ?");
            if (pLink)
            {
                pLink->OriginNoLongerInBusinessAnymore();
            }
        }
    }

    XmlIdRegistryDocument::~XmlIdRegistryDocument()
    {
        // notify all list elements that are actually in the clipboard
        for (auto& aXmlId : m_pImpl->m_XmlIdMap) {
            for (auto aLink : aXmlId.second.first)
                removeLink(aLink);
            for (auto aLink : aXmlId.second.second)
                removeLink(aLink);
        }
    }

    bool
    XmlIdRegistryDocument::LookupXmlId(
        const Metadatable& i_rObject,
        OUString & o_rStream, OUString & o_rIdref) const
    {
        return m_pImpl->LookupXmlId(i_rObject, o_rStream, o_rIdref);
    }

    Metadatable*
    XmlIdRegistryDocument::LookupElement(
        const OUString & i_rStreamName,
        const OUString & i_rIdref) const
    {
        return m_pImpl->LookupElement(i_rStreamName, i_rIdref);
    }

    bool
    XmlIdRegistryDocument::TryRegisterMetadatable(Metadatable & i_rObject,
        OUString const& i_rStreamName, OUString const& i_rIdref)
    {
        SAL_INFO("sfx", "TryRegisterMetadatable: " << &i_rObject << " (" << i_rStreamName << "#" << i_rIdref << ")");

        OSL_ENSURE(!dynamic_cast<MetadatableUndo*>(&i_rObject),
            "TryRegisterMetadatable called for MetadatableUndo?");
        OSL_ENSURE(!dynamic_cast<MetadatableClipboard*>(&i_rObject),
            "TryRegisterMetadatable called for MetadatableClipboard?");

        if (!isValidXmlId(i_rStreamName, i_rIdref))
        {
            throw lang::IllegalArgumentException("illegal XmlId", nullptr, 0);
        }
        if (i_rObject.IsInContent()
            ?   !isContentFile(i_rStreamName)
            :   !isStylesFile(i_rStreamName))
        {
            throw lang::IllegalArgumentException("illegal XmlId: wrong stream", nullptr, 0);
        }

        OUString old_path;
        OUString old_idref;
        m_pImpl->LookupXmlId(i_rObject, old_path, old_idref);
        if (old_path  == i_rStreamName && old_idref == i_rIdref)
        {
            return (m_pImpl->LookupElement(old_path, old_idref) == &i_rObject);
        }
        XmlIdMap_t::iterator old_id( m_pImpl->m_XmlIdMap.end() );
        if (!old_idref.isEmpty())
        {
            old_id = m_pImpl->m_XmlIdMap.find(old_idref);
            OSL_ENSURE(old_id != m_pImpl->m_XmlIdMap.end(), "old id not found");
        }
        if (m_pImpl->TryInsertMetadatable(i_rObject, i_rStreamName, i_rIdref))
        {
            rmIter(m_pImpl->m_XmlIdMap, old_id, old_path, i_rObject);
            m_pImpl->m_XmlIdReverseMap[&i_rObject] =
                ::std::make_pair(i_rStreamName, i_rIdref);
            return true;
        }
        else
        {
            return false;
        }
    }

    void
    XmlIdRegistryDocument::RegisterMetadatableAndCreateID(Metadatable & i_rObject)
    {
        SAL_INFO("sfx", "RegisterMetadatableAndCreateID: " << &i_rObject);

        OSL_ENSURE(!dynamic_cast<MetadatableUndo*>(&i_rObject),
            "RegisterMetadatableAndCreateID called for MetadatableUndo?");
        OSL_ENSURE(!dynamic_cast<MetadatableClipboard*>(&i_rObject),
            "RegisterMetadatableAndCreateID called for MetadatableClipboard?");

        const bool isInContent( i_rObject.IsInContent() );
        const OUString stream( OUString::createFromAscii(
            isInContent ? s_content : s_styles ) );
        // check if we have a latent xmlid, and if yes, remove it
        OUString old_path;
        OUString old_idref;
        m_pImpl->LookupXmlId(i_rObject, old_path, old_idref);

        XmlIdMap_t::iterator old_id( m_pImpl->m_XmlIdMap.end() );
        if (!old_idref.isEmpty())
        {
            old_id = m_pImpl->m_XmlIdMap.find(old_idref);
            OSL_ENSURE(old_id != m_pImpl->m_XmlIdMap.end(), "old id not found");
            if (m_pImpl->LookupElement(old_path, old_idref) == &i_rObject)
            {
                return;
            }
            else
            {
                // remove latent xmlid
                rmIter(m_pImpl->m_XmlIdMap, old_id, old_path, i_rObject);
            }
        }

        // create id
        const OUString id( create_id(m_pImpl->m_XmlIdMap) );
        OSL_ENSURE(m_pImpl->m_XmlIdMap.find(id) == m_pImpl->m_XmlIdMap.end(),
            "created id is in use");
        m_pImpl->m_XmlIdMap.insert(::std::make_pair(id, isInContent
            ? ::std::make_pair( XmlIdVector_t( 1, &i_rObject ), XmlIdVector_t() )
            : ::std::make_pair( XmlIdVector_t(), XmlIdVector_t( 1, &i_rObject ) )));
        m_pImpl->m_XmlIdReverseMap[&i_rObject] = ::std::make_pair(stream, id);
    }

    void XmlIdRegistryDocument::UnregisterMetadatable(const Metadatable& i_rObject)
    {
        SAL_INFO("sfx", "UnregisterMetadatable: " << &i_rObject);

        OUString path;
        OUString idref;
        if (!m_pImpl->LookupXmlId(i_rObject, path, idref))
        {
            OSL_FAIL("unregister: no xml id?");
            return;
        }
        const XmlIdMap_t::iterator iter( m_pImpl->m_XmlIdMap.find(idref) );
        if (iter != m_pImpl->m_XmlIdMap.end())
        {
            rmIter(m_pImpl->m_XmlIdMap, iter, path, i_rObject);
        }
    }

    void XmlIdRegistryDocument::RemoveXmlIdForElement(const Metadatable& i_rObject)
    {
        SAL_INFO("sfx", "RemoveXmlIdForElement: " << &i_rObject);

        const XmlIdReverseMap_t::iterator iter(
            m_pImpl->m_XmlIdReverseMap.find(&i_rObject) );
        if (iter != m_pImpl->m_XmlIdReverseMap.end())
        {
            OSL_ENSURE(!iter->second.second.isEmpty(),
                "null id in m_XmlIdReverseMap");
            m_pImpl->m_XmlIdReverseMap.erase(iter);
        }
    }

    void XmlIdRegistryDocument::RegisterCopy(Metadatable const& i_rSource,
        Metadatable & i_rCopy, const bool i_bCopyPrecedesSource)
    {
        SAL_INFO("sfx", "RegisterCopy: " << &i_rSource << " -> " << &i_rCopy << " (" << i_bCopyPrecedesSource << ")");

        // potential sources: clipboard, undo array, splitNode
        // assumption: stream change can only happen via clipboard, and is handled
        // by Metadatable::RegisterAsCopyOf
        OSL_ENSURE(i_rSource.IsInUndo() || i_rCopy.IsInUndo() ||
            (i_rSource.IsInContent() == i_rCopy.IsInContent()),
            "RegisterCopy: not in same stream?");

        OUString path;
        OUString idref;
        if (!m_pImpl->LookupXmlId( i_rSource, path, idref ))
        {
            OSL_FAIL("no xml id?");
            return;
        }
        XmlIdVector_t * pList ( m_pImpl->LookupElementVector(path, idref) );
        OSL_ENSURE( ::std::find( pList->begin(), pList->end(), &i_rCopy )
            == pList->end(), "copy already registered???");
        XmlIdVector_t::iterator srcpos(
            ::std::find( pList->begin(), pList->end(), &i_rSource ) );
        OSL_ENSURE(srcpos != pList->end(), "source not in list???");
        if (srcpos == pList->end())
        {
            return;
        }
        if (i_bCopyPrecedesSource)
        {
            pList->insert( srcpos, &i_rCopy );
        }
        else
        {
            // for undo push_back does not work! must insert right after source
            pList->insert( ++srcpos, &i_rCopy );
        }
        m_pImpl->m_XmlIdReverseMap.insert(::std::make_pair(&i_rCopy,
            ::std::make_pair(path, idref)));
    }

    std::shared_ptr<MetadatableUndo>
    XmlIdRegistryDocument::CreateUndo(Metadatable const& i_rObject)
    {
        SAL_INFO("sfx", "CreateUndo: " << &i_rObject);

        return std::make_shared<MetadatableUndo>(
                    i_rObject.IsInContent() );
    }

    /*
    i_rMerged is both a source and the target node of the merge
    i_rOther is the other source, and will be deleted after the merge

    dimensions: none|latent|actual empty|nonempty
    i_rMerged(1)    i_rOther(2)        result
         *|empty         *|empty    => 1|2 (arbitrary)
         *|empty         *|nonempty => 2
         *|nonempty      *|empty    => 1
      none|nonempty   none|nonempty => none
      none|nonempty latent|nonempty => 2
    latent|nonempty   none|nonempty => 1
    latent|nonempty latent|nonempty => 1|2
         *|nonempty actual|nonempty => 2
    actual|nonempty      *|nonempty => 1
    actual|nonempty actual|nonempty => 1|2
    */
    void
    XmlIdRegistryDocument::JoinMetadatables(
        Metadatable & i_rMerged, Metadatable const & i_rOther)
    {
        SAL_INFO("sfx", "JoinMetadatables: " << &i_rMerged << " <- " << &i_rOther);

        bool mergedOwnsRef;
        OUString path;
        OUString idref;
        if (m_pImpl->LookupXmlId(i_rMerged, path, idref))
        {
            mergedOwnsRef = (m_pImpl->LookupElement(path, idref) == &i_rMerged);
        }
        else
        {
            OSL_FAIL("JoinMetadatables: no xmlid?");
            return;
        }
        if (!mergedOwnsRef)
        {
            i_rMerged.RemoveMetadataReference();
            i_rMerged.RegisterAsCopyOf(i_rOther, true);
            return;
        }
        // other cases: merged has actual ref and is nonempty,
        // other has latent/actual ref and is nonempty: other loses => nothing to do
    }

    // Clipboard XML ID Registry (_Impl)

    struct RMapEntry
    {
        RMapEntry() : m_xLink() { }
        RMapEntry(OUString const& i_rStream,
                OUString const& i_rXmlId,
                std::shared_ptr<MetadatableClipboard> const& i_pLink
                    = std::shared_ptr<MetadatableClipboard>())
            :   m_Stream(i_rStream), m_XmlId(i_rXmlId), m_xLink(i_pLink)
            {}
        OUString m_Stream;
        OUString m_XmlId;
        // this would have been an auto_ptr, if only that would have compiled...
        std::shared_ptr<MetadatableClipboard> m_xLink;
    };

    /// element -> (stream name, idref, source)
    typedef std::unordered_map< const Metadatable*,
        struct RMapEntry,
        PtrHash<Metadatable> >
        ClipboardXmlIdReverseMap_t;

    /// Idref -> (content.xml element, styles.xml element)
    typedef std::unordered_map< OUString,
        ::std::pair< Metadatable*, Metadatable* > >
        ClipboardXmlIdMap_t;

    struct XmlIdRegistryClipboard::XmlIdRegistry_Impl
    {
        XmlIdRegistry_Impl()
            : m_XmlIdMap(), m_XmlIdReverseMap() { }

        bool TryInsertMetadatable(Metadatable& i_xObject,
            const OUString & i_rStream, const OUString & i_rIdref);

        bool LookupXmlId(const Metadatable& i_xObject,
            OUString & o_rStream, OUString & o_rIdref,
            MetadatableClipboard const* &o_rpLink) const;

        Metadatable* LookupElement(const OUString & i_rStreamName,
            const OUString & i_rIdref) const;

        Metadatable* const* LookupEntry(const OUString & i_rStreamName,
            const OUString & i_rIdref) const;

        ClipboardXmlIdMap_t m_XmlIdMap;
        ClipboardXmlIdReverseMap_t m_XmlIdReverseMap;
    };

    static void
    rmIter(ClipboardXmlIdMap_t & i_rXmlIdMap,
        ClipboardXmlIdMap_t::iterator const& i_rIter,
        OUString const & i_rStream, Metadatable const& i_rObject)
    {
        if (i_rIter != i_rXmlIdMap.end())
        {
            Metadatable *& rMeta = isContentFile(i_rStream)
                ? i_rIter->second.first : i_rIter->second.second;
            if (rMeta == &i_rObject)
            {
                rMeta = nullptr;
            }
            if (!i_rIter->second.first && !i_rIter->second.second)
            {
                i_rXmlIdMap.erase(i_rIter);
            }
        }
    }

    Metadatable* const*
    XmlIdRegistryClipboard::XmlIdRegistry_Impl::LookupEntry(
        const OUString & i_rStreamName,
        const OUString & i_rIdref) const
    {
        if (!isValidXmlId(i_rStreamName, i_rIdref))
        {
            throw lang::IllegalArgumentException("illegal XmlId", nullptr, 0);
        }

        const ClipboardXmlIdMap_t::const_iterator iter( m_XmlIdMap.find(i_rIdref) );
        if (iter != m_XmlIdMap.end())
        {
            OSL_ENSURE(iter->second.first || iter->second.second,
                "null entry in m_XmlIdMap");
            return (isContentFile(i_rStreamName))
                ?  &iter->second.first
                :  &iter->second.second;
        }
        else
        {
            return nullptr;
        }
    }

    Metadatable*
    XmlIdRegistryClipboard::XmlIdRegistry_Impl::LookupElement(
        const OUString & i_rStreamName,
        const OUString & i_rIdref) const
    {
        Metadatable * const * ppEntry = LookupEntry(i_rStreamName, i_rIdref);
        return ppEntry ? *ppEntry : nullptr;
    }

    bool
    XmlIdRegistryClipboard::XmlIdRegistry_Impl::LookupXmlId(
        const Metadatable& i_rObject,
        OUString & o_rStream, OUString & o_rIdref,
        MetadatableClipboard const* &o_rpLink) const
    {
        const ClipboardXmlIdReverseMap_t::const_iterator iter(
            m_XmlIdReverseMap.find(&i_rObject) );
        if (iter != m_XmlIdReverseMap.end())
        {
            OSL_ENSURE(!iter->second.m_Stream.isEmpty(),
                "null stream in m_XmlIdReverseMap");
            OSL_ENSURE(!iter->second.m_XmlId.isEmpty(),
                "null id in m_XmlIdReverseMap");
            o_rStream = iter->second.m_Stream;
            o_rIdref  = iter->second.m_XmlId;
            o_rpLink  = iter->second.m_xLink.get();
            return true;
        }
        else
        {
            return false;
        }
    }

    bool
    XmlIdRegistryClipboard::XmlIdRegistry_Impl::TryInsertMetadatable(
        Metadatable & i_rObject,
        const OUString & i_rStreamName, const OUString & i_rIdref)
    {
        bool bContent( isContentFile(i_rStreamName) );
        OSL_ENSURE(isContentFile(i_rStreamName) || isStylesFile(i_rStreamName),
            "invalid stream");

        Metadatable ** ppEntry = const_cast<Metadatable**>(LookupEntry(i_rStreamName, i_rIdref));
        if (ppEntry)
        {
            if (*ppEntry)
            {
                return false;
            }
            else
            {
                *ppEntry = &i_rObject;
                return true;
            }
        }
        else
        {
            m_XmlIdMap.insert(::std::make_pair(i_rIdref, bContent
                ? ::std::make_pair( &i_rObject, static_cast<Metadatable*>(nullptr) )
                : ::std::make_pair( static_cast<Metadatable*>(nullptr), &i_rObject )));
            return true;
        }
    }

    // Clipboard XML ID Registry

    XmlIdRegistryClipboard::XmlIdRegistryClipboard()
        :   m_pImpl( new XmlIdRegistry_Impl )
    {
    }

    bool
    XmlIdRegistryClipboard::LookupXmlId(
        const Metadatable& i_rObject,
        OUString & o_rStream, OUString & o_rIdref) const
    {
        const MetadatableClipboard * pLink;
        return m_pImpl->LookupXmlId(i_rObject, o_rStream, o_rIdref, pLink);
    }

    Metadatable*
    XmlIdRegistryClipboard::LookupElement(
        const OUString & i_rStreamName,
        const OUString & i_rIdref) const
    {
        return m_pImpl->LookupElement(i_rStreamName, i_rIdref);
    }

    bool
    XmlIdRegistryClipboard::TryRegisterMetadatable(Metadatable & i_rObject,
        OUString const& i_rStreamName, OUString const& i_rIdref)
    {
        SAL_INFO("sfx", "TryRegisterMetadatable: " << &i_rObject << " (" << i_rStreamName << "#" << i_rIdref <<")");

        OSL_ENSURE(!dynamic_cast<MetadatableUndo*>(&i_rObject),
            "TryRegisterMetadatable called for MetadatableUndo?");
        OSL_ENSURE(!dynamic_cast<MetadatableClipboard*>(&i_rObject),
            "TryRegisterMetadatable called for MetadatableClipboard?");

        if (!isValidXmlId(i_rStreamName, i_rIdref))
        {
            throw lang::IllegalArgumentException("illegal XmlId", nullptr, 0);
        }
        if (i_rObject.IsInContent()
            ?   !isContentFile(i_rStreamName)
            :   !isStylesFile(i_rStreamName))
        {
            throw lang::IllegalArgumentException("illegal XmlId: wrong stream", nullptr, 0);
        }

        OUString old_path;
        OUString old_idref;
        const MetadatableClipboard * pLink;
        m_pImpl->LookupXmlId(i_rObject, old_path, old_idref, pLink);
        if (old_path  == i_rStreamName && old_idref == i_rIdref)
        {
            return (m_pImpl->LookupElement(old_path, old_idref) == &i_rObject);
        }
        ClipboardXmlIdMap_t::iterator old_id( m_pImpl->m_XmlIdMap.end() );
        if (!old_idref.isEmpty())
        {
            old_id = m_pImpl->m_XmlIdMap.find(old_idref);
            OSL_ENSURE(old_id != m_pImpl->m_XmlIdMap.end(), "old id not found");
        }
        if (m_pImpl->TryInsertMetadatable(i_rObject, i_rStreamName, i_rIdref))
        {
            rmIter(m_pImpl->m_XmlIdMap, old_id, old_path, i_rObject);
            m_pImpl->m_XmlIdReverseMap[&i_rObject] =
                RMapEntry(i_rStreamName, i_rIdref);
            return true;
        }
        else
        {
            return false;
        }
    }

    void
    XmlIdRegistryClipboard::RegisterMetadatableAndCreateID(Metadatable & i_rObject)
    {
        SAL_INFO("sfx", "RegisterMetadatableAndCreateID: " << &i_rObject);

        OSL_ENSURE(!dynamic_cast<MetadatableUndo*>(&i_rObject),
            "RegisterMetadatableAndCreateID called for MetadatableUndo?");
        OSL_ENSURE(!dynamic_cast<MetadatableClipboard*>(&i_rObject),
            "RegisterMetadatableAndCreateID called for MetadatableClipboard?");

        bool isInContent( i_rObject.IsInContent() );
        OUString stream( OUString::createFromAscii(
            isInContent ? s_content : s_styles ) );

        OUString old_path;
        OUString old_idref;
        LookupXmlId(i_rObject, old_path, old_idref);
        if (!old_idref.isEmpty() &&
            (m_pImpl->LookupElement(old_path, old_idref) == &i_rObject))
        {
            return;
        }

        // create id
        const OUString id( create_id(m_pImpl->m_XmlIdMap) );
        OSL_ENSURE(m_pImpl->m_XmlIdMap.find(id) == m_pImpl->m_XmlIdMap.end(),
            "created id is in use");
        m_pImpl->m_XmlIdMap.insert(::std::make_pair(id, isInContent
            ? ::std::make_pair( &i_rObject, static_cast<Metadatable*>(nullptr) )
            : ::std::make_pair( static_cast<Metadatable*>(nullptr), &i_rObject )));
        // N.B.: if i_rObject had a latent XmlId, then we implicitly delete the
        // MetadatableClipboard and thus the latent XmlId here
        m_pImpl->m_XmlIdReverseMap[&i_rObject] = RMapEntry(stream, id);
    }

    void XmlIdRegistryClipboard::UnregisterMetadatable(const Metadatable& i_rObject)
    {
        SAL_INFO("sfx", "UnregisterMetadatable: " << &i_rObject);

        OUString path;
        OUString idref;
        const MetadatableClipboard * pLink;
        if (!m_pImpl->LookupXmlId(i_rObject, path, idref, pLink))
        {
            OSL_FAIL("unregister: no xml id?");
            return;
        }
        const ClipboardXmlIdMap_t::iterator iter( m_pImpl->m_XmlIdMap.find(idref) );
        if (iter != m_pImpl->m_XmlIdMap.end())
        {
            rmIter(m_pImpl->m_XmlIdMap, iter, path, i_rObject);
        }
    }

    void XmlIdRegistryClipboard::RemoveXmlIdForElement(const Metadatable& i_rObject)
    {
        SAL_INFO("sfx", "RemoveXmlIdForElement: " << &i_rObject);

        ClipboardXmlIdReverseMap_t::iterator iter(
            m_pImpl->m_XmlIdReverseMap.find(&i_rObject) );
        if (iter != m_pImpl->m_XmlIdReverseMap.end())
        {
            OSL_ENSURE(!iter->second.m_XmlId.isEmpty(),
                "null id in m_XmlIdReverseMap");
            m_pImpl->m_XmlIdReverseMap.erase(iter);
        }
    }

    std::shared_ptr<MetadatableClipboard>
    XmlIdRegistryClipboard::CreateClipboard(const bool i_isInContent)
    {
        SAL_INFO("sfx", "CreateClipboard:");

        return std::make_shared<MetadatableClipboard>(
            i_isInContent );
    }

    MetadatableClipboard &
    XmlIdRegistryClipboard::RegisterCopyClipboard(Metadatable & i_rCopy,
        beans::StringPair const & i_rReference,
        const bool i_isLatent)
    {
        SAL_INFO("sfx", "RegisterCopyClipboard: " << &i_rCopy
                  << " -> (" << i_rReference.First << "#" << i_rReference.Second << ") (" << i_isLatent << ")");

        // N.B.: when copying to the clipboard, the selection is always inserted
        //       into the body, even if the source is a header/footer!
        //       so we do not check whether the stream is right in this function

        if (!isValidXmlId(i_rReference.First, i_rReference.Second))
        {
            throw lang::IllegalArgumentException("illegal XmlId", nullptr, 0);
        }

        if (!i_isLatent)
        {
            // this should succeed assuming clipboard has a single source document
            const bool success( m_pImpl->TryInsertMetadatable(i_rCopy,
                    i_rReference.First, i_rReference.Second) );
            OSL_ENSURE(success, "RegisterCopyClipboard: TryInsert failed?");
        }
        const std::shared_ptr<MetadatableClipboard> xLink(
            CreateClipboard( isContentFile(i_rReference.First)) );
        m_pImpl->m_XmlIdReverseMap.insert(::std::make_pair(&i_rCopy,
            RMapEntry(i_rReference.First, i_rReference.Second, xLink)));
        return *xLink.get();
    }

    MetadatableClipboard const*
    XmlIdRegistryClipboard::SourceLink(Metadatable const& i_rObject)
    {
        OUString path;
        OUString idref;
        const MetadatableClipboard * pLink( nullptr );
        m_pImpl->LookupXmlId(i_rObject, path, idref, pLink);
        return pLink;
    }

    // Metadatable mixin

    Metadatable::~Metadatable()
    {
        RemoveMetadataReference();
    }

    void Metadatable::RemoveMetadataReference()
    {
        try
        {
            if (m_pReg)
            {
                m_pReg->UnregisterMetadatable( *this );
                m_pReg->RemoveXmlIdForElement( *this );
                m_pReg = nullptr;
            }
        }
        catch (const uno::Exception &)
        {
            OSL_FAIL("Metadatable::RemoveMetadataReference: exception");
        }
    }

    // css::rdf::XMetadatable:
    beans::StringPair
    Metadatable::GetMetadataReference() const
    {
        if (m_pReg)
        {
            return m_pReg->GetXmlIdForElement(*this);
        }
        return beans::StringPair();
    }

    void Metadatable::SetMetadataReference( const css::beans::StringPair & i_rReference)
    {
        if (i_rReference.Second.isEmpty())
        {
            RemoveMetadataReference();
        }
        else
        {
            OUString streamName( i_rReference.First );
            if (streamName.isEmpty())
            {
                // handle empty stream name as auto-detect.
                // necessary for importing flat file format.
                streamName = OUString::createFromAscii(
                                IsInContent() ? s_content : s_styles );
            }
            XmlIdRegistry & rReg( dynamic_cast<XmlIdRegistry&>( GetRegistry() ) );
            if (!rReg.TryRegisterMetadatable(*this, streamName, i_rReference.Second))
            {
                throw lang::IllegalArgumentException(
                    "Metadatable::SetMetadataReference: argument is invalid", /*this*/nullptr, 0);
            }

            m_pReg = &rReg;
        }
    }

    void Metadatable::EnsureMetadataReference()
    {
        XmlIdRegistry& rReg(
            m_pReg ? *m_pReg : dynamic_cast<XmlIdRegistry&>( GetRegistry() ) );
        rReg.RegisterMetadatableAndCreateID( *this );
        m_pReg = &rReg;
    }

    const ::sfx2::IXmlIdRegistry& GetRegistryConst(Metadatable const& i_rObject)
    {
        return const_cast< Metadatable& >( i_rObject ).GetRegistry();
    }

    void
    Metadatable::RegisterAsCopyOf(Metadatable const & i_rSource,
        const bool i_bCopyPrecedesSource)
    {
        OSL_ENSURE(typeid(*this) == typeid(i_rSource)
            || typeid(i_rSource) == typeid(MetadatableUndo)
            || typeid(*this)     == typeid(MetadatableUndo)
            || typeid(i_rSource) == typeid(MetadatableClipboard)
            || typeid(*this)     == typeid(MetadatableClipboard),
            "RegisterAsCopyOf element with different class?");
        OSL_ENSURE(!m_pReg, "RegisterAsCopyOf called on element with XmlId?");

        if (m_pReg)
        {
            RemoveMetadataReference();
        }

        try
        {
            if (i_rSource.m_pReg)
            {
                XmlIdRegistry & rReg(
                    dynamic_cast<XmlIdRegistry&>( GetRegistry() ) );
                if (i_rSource.m_pReg == &rReg)
                {
                    OSL_ENSURE(!IsInClipboard(),
                        "RegisterAsCopy: both in clipboard?");
                    if (!IsInClipboard())
                    {
                        XmlIdRegistryDocument & rRegDoc(
                            dynamic_cast<XmlIdRegistryDocument&>( rReg ) );
                        rRegDoc.RegisterCopy(i_rSource, *this,
                            i_bCopyPrecedesSource);
                        m_pReg = &rRegDoc;
                    }
                    return;
                }
                // source is in different document
                XmlIdRegistryDocument  * pRegDoc(
                    dynamic_cast<XmlIdRegistryDocument *>(&rReg) );
                XmlIdRegistryClipboard * pRegClp(
                    dynamic_cast<XmlIdRegistryClipboard*>(&rReg) );

                if (pRegClp)
                {
                    beans::StringPair SourceRef(
                        i_rSource.m_pReg->GetXmlIdForElement(i_rSource) );
                    bool isLatent( SourceRef.Second.isEmpty() );
                    XmlIdRegistryDocument * pSourceRegDoc(
                        dynamic_cast<XmlIdRegistryDocument*>(i_rSource.m_pReg) );
                    OSL_ENSURE(pSourceRegDoc, "RegisterAsCopyOf: 2 clipboards?");
                    if (!pSourceRegDoc) return;
                    // this is a copy _to_ the clipboard
                    if (isLatent)
                    {
                        pSourceRegDoc->LookupXmlId(i_rSource,
                            SourceRef.First, SourceRef.Second);
                    }
                    Metadatable & rLink(
                        pRegClp->RegisterCopyClipboard(*this, SourceRef, isLatent));
                    m_pReg = pRegClp;
                    // register as copy in the non-clipboard registry
                    pSourceRegDoc->RegisterCopy(i_rSource, rLink,
                        false); // i_bCopyPrecedesSource);
                    rLink.m_pReg = pSourceRegDoc;
                }
                else if (pRegDoc)
                {
                    XmlIdRegistryClipboard * pSourceRegClp(
                        dynamic_cast<XmlIdRegistryClipboard*>(i_rSource.m_pReg) );
                    OSL_ENSURE(pSourceRegClp,
                        "RegisterAsCopyOf: 2 non-clipboards?");
                    if (!pSourceRegClp) return;
                    const MetadatableClipboard * pLink(
                        pSourceRegClp->SourceLink(i_rSource) );
                    // may happen if src got its id via UNO call
                    if (!pLink) return;
                    // only register copy if clipboard content is from this SwDoc!
                    if (pLink && (&GetRegistryConst(*pLink) == pRegDoc))
                    {
                        // this is a copy _from_ the clipboard; check if the
                        // element is still in the same stream
                        // N.B.: we check the stream of pLink, not of i_rSource!
                        bool srcInContent( pLink->IsInContent() );
                        bool tgtInContent( IsInContent() );
                        if (srcInContent == tgtInContent)
                        {
                            pRegDoc->RegisterCopy(*pLink, *this,
                                true); // i_bCopyPrecedesSource);
                            m_pReg = pRegDoc;
                        }
                        // otherwise: stream change! do not register!
                    }
                }
                else
                {
                    OSL_FAIL("neither RegDoc nor RegClp cannot happen");
                }
            }
        }
        catch (const uno::Exception &)
        {
            OSL_FAIL("Metadatable::RegisterAsCopyOf: exception");
        }
    }

    std::shared_ptr<MetadatableUndo> Metadatable::CreateUndo() const
    {
        OSL_ENSURE(!IsInUndo(), "CreateUndo called for object in undo?");
        OSL_ENSURE(!IsInClipboard(), "CreateUndo called for object in clipboard?");
        try
        {
            if (!IsInClipboard() && !IsInUndo() && m_pReg)
            {
                XmlIdRegistryDocument * pRegDoc(
                    dynamic_cast<XmlIdRegistryDocument*>( m_pReg ) );
                std::shared_ptr<MetadatableUndo> xUndo(
                    sfx2::XmlIdRegistryDocument::CreateUndo(*this) );
                pRegDoc->RegisterCopy(*this, *xUndo, false);
                xUndo->m_pReg = pRegDoc;
                return xUndo;
            }
        }
        catch (const uno::Exception &)
        {
            OSL_FAIL("Metadatable::CreateUndo: exception");
        }
        return std::shared_ptr<MetadatableUndo>();
    }

    std::shared_ptr<MetadatableUndo> Metadatable::CreateUndoForDelete()
    {
        std::shared_ptr<MetadatableUndo> const xUndo( CreateUndo() );
        RemoveMetadataReference();
        return xUndo;
    }

    void Metadatable::RestoreMetadata(
        std::shared_ptr<MetadatableUndo> const& i_pUndo)
    {
        OSL_ENSURE(!IsInUndo(), "RestoreMetadata called for object in undo?");
        OSL_ENSURE(!IsInClipboard(),
            "RestoreMetadata called for object in clipboard?");
        if (IsInClipboard() || IsInUndo()) return;
        RemoveMetadataReference();
        if (i_pUndo)
        {
            RegisterAsCopyOf(*i_pUndo, true);
        }
    }

    void
    Metadatable::JoinMetadatable(Metadatable const & i_rOther,
        const bool i_isMergedEmpty, const bool i_isOtherEmpty)
    {
        OSL_ENSURE(!IsInUndo(), "JoinMetadatables called for object in undo?");
        OSL_ENSURE(!IsInClipboard(),
            "JoinMetadatables called for object in clipboard?");
        if (IsInClipboard() || IsInUndo()) return;

        if (i_isOtherEmpty && !i_isMergedEmpty)
        {
            // other is empty, thus loses => nothing to do
            return;
        }
        if (i_isMergedEmpty && !i_isOtherEmpty)
        {
            RemoveMetadataReference();
            RegisterAsCopyOf(i_rOther, true);
            return;
        }

        if (!i_rOther.m_pReg)
        {
            // other doesn't have xmlid, thus loses => nothing to do
            return;
        }
        if (!m_pReg)
        {
            RegisterAsCopyOf(i_rOther, true);
            // assumption: i_rOther will be deleted, so don't unregister it here
            return;
        }
        try
        {
            XmlIdRegistryDocument * pRegDoc(
                dynamic_cast<XmlIdRegistryDocument*>( m_pReg ) );
            OSL_ENSURE(pRegDoc, "JoinMetadatable: no pRegDoc?");
            if (pRegDoc)
            {
                pRegDoc->JoinMetadatables(*this, i_rOther);
            }
        }
        catch (const uno::Exception &)
        {
            OSL_FAIL("Metadatable::JoinMetadatable: exception");
        }
    }

    // XMetadatable mixin

    // css::rdf::XNode:
    OUString SAL_CALL MetadatableMixin::getStringValue()
    {
        return getNamespace() + getLocalName();
    }

    // css::rdf::XURI:
    OUString SAL_CALL MetadatableMixin::getLocalName()
    {
        SolarMutexGuard aGuard;
        beans::StringPair mdref( getMetadataReference() );
        if (mdref.Second.isEmpty())
        {
            ensureMetadataReference(); // N.B.: side effect!
            mdref = getMetadataReference();
        }
        OUStringBuffer buf;
        buf.append(mdref.First);
        buf.append('#');
        buf.append(mdref.Second);
        return buf.makeStringAndClear();
    }

    OUString SAL_CALL MetadatableMixin::getNamespace()
    {
        SolarMutexGuard aGuard;
        const uno::Reference< frame::XModel > xModel( GetModel() );
        const uno::Reference< rdf::XURI > xDMA( xModel, uno::UNO_QUERY_THROW );
        return xDMA->getStringValue();
    }

    // css::rdf::XMetadatable:
    beans::StringPair SAL_CALL
    MetadatableMixin::getMetadataReference()
    {
        SolarMutexGuard aGuard;

        Metadatable *const pObject( GetCoreObject() );
        if (!pObject)
        {
            throw uno::RuntimeException(
                "MetadatableMixin: cannot get core object; not inserted?",
                *this);
        }
        return pObject->GetMetadataReference();
    }

    void SAL_CALL
    MetadatableMixin::setMetadataReference(
        const beans::StringPair & i_rReference)
    {
        SolarMutexGuard aGuard;

        Metadatable *const pObject( GetCoreObject() );
        if (!pObject)
        {
            throw uno::RuntimeException(
                "MetadatableMixin: cannot get core object; not inserted?",
                *this);
        }
        return pObject->SetMetadataReference(i_rReference);
    }

    void SAL_CALL MetadatableMixin::ensureMetadataReference()
    {
        SolarMutexGuard aGuard;

        Metadatable *const pObject( GetCoreObject() );
        if (!pObject)
        {
            throw uno::RuntimeException(
                "MetadatableMixin: cannot get core object; not inserted?",
                *this);
        }
        return pObject->EnsureMetadataReference();
    }

    } // namespace sfx2

    /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

↑ V560 A part of conditional expression is always true: pLink.

↑ V522 There might be dereferencing of a potential null pointer 'pRegDoc'.