/* -*- 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 <cassert>

#include <cstdlib>

#include <utility>

#include <vector>

#include <com/sun/star/beans/Property.hpp>

#include <com/sun/star/beans/PropertyAttribute.hpp>

#include <com/sun/star/beans/PropertyChangeEvent.hpp>

#include <com/sun/star/beans/UnknownPropertyException.hpp>

#include <com/sun/star/beans/XExactName.hpp>

#include <com/sun/star/beans/XHierarchicalPropertySet.hpp>

#include <com/sun/star/beans/XHierarchicalPropertySetInfo.hpp>

#include <com/sun/star/beans/XMultiHierarchicalPropertySet.hpp>

#include <com/sun/star/beans/XMultiPropertySet.hpp>

#include <com/sun/star/beans/XPropertiesChangeListener.hpp>

#include <com/sun/star/beans/XProperty.hpp>

#include <com/sun/star/beans/XPropertyChangeListener.hpp>

#include <com/sun/star/beans/XPropertySet.hpp>

#include <com/sun/star/beans/XPropertySetInfo.hpp>

#include <com/sun/star/beans/XVetoableChangeListener.hpp>

#include <com/sun/star/container/ContainerEvent.hpp>

#include <com/sun/star/container/NoSuchElementException.hpp>

#include <com/sun/star/container/XContainer.hpp>

#include <com/sun/star/container/XContainerListener.hpp>

#include <com/sun/star/container/XElementAccess.hpp>

#include <com/sun/star/container/XHierarchicalName.hpp>

#include <com/sun/star/container/XHierarchicalNameAccess.hpp>

#include <com/sun/star/container/XHierarchicalNameReplace.hpp>

#include <com/sun/star/container/XNameAccess.hpp>

#include <com/sun/star/container/XNameContainer.hpp>

#include <com/sun/star/container/XNamed.hpp>

#include <com/sun/star/lang/DisposedException.hpp>

#include <com/sun/star/lang/EventObject.hpp>

#include <com/sun/star/lang/IllegalArgumentException.hpp>

#include <com/sun/star/lang/XComponent.hpp>

#include <com/sun/star/lang/XEventListener.hpp>

#include <com/sun/star/lang/XServiceInfo.hpp>

#include <com/sun/star/lang/XSingleServiceFactory.hpp>

#include <com/sun/star/lang/XTypeProvider.hpp>

#include <com/sun/star/uno/Any.hxx>

#include <com/sun/star/uno/Reference.hxx>

#include <com/sun/star/uno/RuntimeException.hpp>

#include <com/sun/star/uno/Sequence.hxx>

#include <com/sun/star/uno/Type.hxx>

#include <com/sun/star/uno/XInterface.hpp>

#include <com/sun/star/uno/XWeak.hpp>

#include <com/sun/star/util/ElementChange.hpp>

#include <com/sun/star/util/InvalidStateException.hpp>

#include <comphelper/sequence.hxx>

#include <comphelper/string.hxx>

#include <comphelper/lok.hxx>

#include <i18nlangtag/languagetag.hxx>

#include <cppu/unotype.hxx>

#include <cppuhelper/queryinterface.hxx>

#include <cppuhelper/supportsservice.hxx>

#include <cppuhelper/weak.hxx>

#include <osl/interlck.h>

#include <osl/mutex.hxx>

#include <rtl/character.hxx>

#include <rtl/ref.hxx>

#include <rtl/ustrbuf.hxx>

#include <rtl/ustring.hxx>

#include <sal/log.hxx>

#include <sal/types.h>

#include <o3tl/string_view.hxx>

#include "access.hxx"

#include "broadcaster.hxx"

#include "childaccess.hxx"

#include "components.hxx"

#include "data.hxx"

#include "groupnode.hxx"

#include "localizedpropertynode.hxx"

#include "localizedvaluenode.hxx"

#include "lock.hxx"

#include "modifications.hxx"

#include "node.hxx"

#include "nodemap.hxx"

#include "propertynode.hxx"

#include "rootaccess.hxx"

#include "setnode.hxx"

#include "type.hxx"

namespace configmgr {

namespace {

// Conservatively forbid what is either not an XML Char (including lone

// surrogates, even though they should not appear in well-formed UNO OUString

// instances anyway), or is a slash (as it causes problems in path syntax):

bool isValidName(std::u16string_view name, bool setMember) {

    for (std::size_t i = 0; i != name.size();) {

        sal_uInt32 c = o3tl::iterateCodePoints(name, &i);

        if ((c < 0x20 && !(c == 0x09 || c == 0x0A || c == 0x0D))

            || rtl::isSurrogate(c) || c == 0xFFFE || c == 0xFFFF

            || (!setMember && c == '/'))

        {

            return false;

        }

    }

    return !name.empty();

}

}

oslInterlockedCount Access::acquireCounting() {

    return osl_atomic_increment(&m_refCount);

}

void Access::releaseNondeleting() {

#if defined __GNUC__ && !defined __clang__ && __GNUC__ == 15

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wstringop-overflow"

#endif

    osl_atomic_decrement(&m_refCount);

#if defined __GNUC__ && !defined __clang__ && __GNUC__ == 15

#pragma GCC diagnostic pop

#endif

}

bool Access::isValue() {

    const rtl::Reference< Node > & p(getNode());

    switch (p->kind()) {

    case Node::KIND_PROPERTY:

    case Node::KIND_LOCALIZED_VALUE:

        return true;

    case Node::KIND_LOCALIZED_PROPERTY:

        return !Components::allLocales(getRootAccess()->getLocale());

    default:

        return false;

    }

}

void Access::markChildAsModified(rtl::Reference< ChildAccess > const & child) {

    assert(child.is() && child->getParentAccess() == this);

    modifiedChildren_[child->getNameInternal()] = ModifiedChild(child, true);

    for (rtl::Reference< Access > p(this);;) {

        rtl::Reference< Access > parent(p->getParentAccess());

        if (!parent.is()) {

            break;

        }

        assert(dynamic_cast< ChildAccess * >(p.get()) != nullptr);

        parent->modifiedChildren_.emplace(

                p->getNameInternal(),

                ModifiedChild(static_cast< ChildAccess * >(p.get()), false));

        p = std::move(parent);

    }

}

void Access::releaseChild(OUString const & name) {

    cachedChildren_.erase(name);

}

void Access::initBroadcaster(

    Modifications::Node const & modifications, Broadcaster * broadcaster)

{

    initBroadcasterAndChanges(modifications, broadcaster, nullptr);

}

css::uno::Sequence< css::uno::Type > Access::getTypes()

{

    assert(thisIs(IS_ANY));

    osl::MutexGuard g(*lock_);

    checkLocalizedPropertyAccess();

    std::vector< css::uno::Type > types { cppu::UnoType< css::uno::XInterface >::get(),

                                          cppu::UnoType< css::uno::XWeak >::get(),

                                          cppu::UnoType< css::lang::XTypeProvider >::get(),

                                          cppu::UnoType< css::lang::XServiceInfo >::get(),

                                          cppu::UnoType< css::lang::XComponent >::get(),

                                          cppu::UnoType< css::container::XContainer >::get(),

                                          cppu::UnoType< css::beans::XExactName >::get(),

                                          cppu::UnoType< css::container::XHierarchicalName >::get(),

                                          cppu::UnoType< css::container::XNamed >::get(),

                                          cppu::UnoType< css::beans::XProperty >::get(),

                                          cppu::UnoType< css::container::XElementAccess >::get(),

                                          cppu::UnoType< css::container::XNameAccess >::get()

                                        };

    if (getNode()->kind() == Node::KIND_GROUP) {

        types.push_back(cppu::UnoType< css::beans::XPropertySetInfo >::get());

        types.push_back(cppu::UnoType< css::beans::XPropertySet >::get());

        types.push_back(cppu::UnoType< css::beans::XMultiPropertySet >::get());

        types.push_back(

            cppu::UnoType< css::beans::XHierarchicalPropertySet >::get());

        types.push_back(

            cppu::UnoType< css::beans::XMultiHierarchicalPropertySet >::get());

        types.push_back(

            cppu::UnoType< css::beans::XHierarchicalPropertySetInfo >::get());

    }

    if (getRootAccess()->isUpdate()) {

        types.push_back(cppu::UnoType< css::container::XNameReplace >::get());

        types.push_back(

            cppu::UnoType< css::container::XHierarchicalNameReplace >::get());

        if (getNode()->kind() != Node::KIND_GROUP ||

            static_cast< GroupNode * >(getNode().get())->isExtensible())

        {

            types.push_back(

                cppu::UnoType< css::container::XNameContainer >::get());

        }

        if (getNode()->kind() == Node::KIND_SET) {

            types.push_back(

                cppu::UnoType< css::lang::XSingleServiceFactory >::get());

        }

    } else {

        types.push_back(

            cppu::UnoType< css::container::XHierarchicalNameAccess >::get());

        types.push_back(

            cppu::UnoType< css::configuration::XDocumentation >::get());

    }

    addTypes(&types);

    return comphelper::containerToSequence(types);

}

css::uno::Sequence< sal_Int8 > Access::getImplementationId()

{

    assert(thisIs(IS_ANY));

    osl::MutexGuard g(*lock_);

    checkLocalizedPropertyAccess();

    return css::uno::Sequence< sal_Int8 >();

}

OUString Access::getImplementationName()

{

    assert(thisIs(IS_ANY));

    osl::MutexGuard g(*lock_);

    checkLocalizedPropertyAccess();

    return u"org.openoffice-configmgr::Access"_ustr;

}

sal_Bool Access::supportsService(OUString const & ServiceName)

{

    return cppu::supportsService(this, ServiceName);

}

css::uno::Sequence< OUString > Access::getSupportedServiceNames()

{

    assert(thisIs(IS_ANY));

    osl::MutexGuard g(*lock_);

    checkLocalizedPropertyAccess();

    std::vector<OUString> services;

    services.emplace_back("com.sun.star.configuration.ConfigurationAccess");

    if (getRootAccess()->isUpdate()) {

        services.emplace_back("com.sun.star.configuration.ConfigurationUpdateAccess");

    }

    services.emplace_back("com.sun.star.configuration.HierarchyAccess");

    services.emplace_back("com.sun.star.configuration.HierarchyElement");

    if (getNode()->kind() == Node::KIND_GROUP) {

        services.emplace_back("com.sun.star.configuration.GroupAccess");

        services.emplace_back("com.sun.star.configuration.PropertyHierarchy");

        if (getRootAccess()->isUpdate()) {

            services.emplace_back("com.sun.star.configuration.GroupUpdate");

        }

    } else {

        services.emplace_back("com.sun.star.configuration.SetAccess");

        services.emplace_back("com.sun.star.configuration.SimpleSetAccess");

        if (getRootAccess()->isUpdate()) {

            services.emplace_back("com.sun.star.configuration.SetUpdate");

            services.emplace_back("com.sun.star.configuration.SimpleSetUpdate");

        }

    }

    addSupportedServiceNames(&services);

    return comphelper::containerToSequence(services);

}

void Access::dispose() {

    assert(thisIs(IS_ANY));

    Broadcaster bc;

    {

        osl::MutexGuard g(*lock_);

        checkLocalizedPropertyAccess();

        if (getParentAccess().is()) {

            throw css::uno::RuntimeException(

                u"configmgr dispose inappropriate Access"_ustr,

                getXWeak());

        }

        if (disposed_) {

            return;

        }

        initDisposeBroadcaster(&bc);

        clearListeners();

        disposed_ = true;

    }

    bc.send();

}

void Access::addEventListener(

    css::uno::Reference< css::lang::XEventListener > const & xListener)

{

    assert(thisIs(IS_ANY));

    {

        osl::MutexGuard g(*lock_);

        checkLocalizedPropertyAccess();

        if (!xListener.is()) {

            throw css::uno::RuntimeException(

                u"null listener"_ustr, getXWeak());

        }

        if (!disposed_) {

            disposeListeners_.insert(xListener);

            return;

        }

    }

    try {

        xListener->disposing(

            css::lang::EventObject(getXWeak()));

    } catch (css::lang::DisposedException &) {}

}

void Access::removeEventListener(

    css::uno::Reference< css::lang::XEventListener > const & aListener)

{

    assert(thisIs(IS_ANY));

    osl::MutexGuard g(*lock_);

    checkLocalizedPropertyAccess();

    auto i(disposeListeners_.find(aListener));

    if (i != disposeListeners_.end()) {

        disposeListeners_.erase(i);

    }

}

css::uno::Type Access::getElementType() {

    assert(thisIs(IS_ANY));

    osl::MutexGuard g(*lock_);

    checkLocalizedPropertyAccess();

    const rtl::Reference< Node > & p(getNode());

    switch (p->kind()) {

    case Node::KIND_LOCALIZED_PROPERTY:

        return mapType(

            static_cast< LocalizedPropertyNode * >(p.get())->getStaticType());

    case Node::KIND_GROUP:

        //TODO: Should a specific type be returned for a non-extensible group

        // with homogeneous members or for an extensible group that currently

        // has only homogeneous members?

        return cppu::UnoType<void>::get();

    case Node::KIND_SET:

        return cppu::UnoType<void>::get(); //TODO: correct?

    default:

        assert(false);

        throw css::uno::RuntimeException(

            u"this cannot happen"_ustr, getXWeak());

    }

}

sal_Bool Access::hasElements() {

    assert(thisIs(IS_ANY));

    osl::MutexGuard g(*lock_);

    checkLocalizedPropertyAccess();

    return !isAllChildrenEmpty();

}

bool Access::getByNameFast(const OUString & name, css::uno::Any & value)

{

    bool bGotValue = false;

    rtl::Reference< ChildAccess > child;

    if (getNode()->kind() != Node::KIND_LOCALIZED_PROPERTY)

    { // try to get it directly

        ModifiedChildren::iterator i(modifiedChildren_.find(name));

        if (i != modifiedChildren_.end())

        {

            child = getModifiedChild(i);

            if (child.is())

            {

                value = child->asValue();

                bGotValue = true;

            }

        }

        else

        {

            rtl::Reference< Node > node(getNode()->getMember(name));

            if (!node.is())

                return false;

            bGotValue = ChildAccess::asSimpleValue(node, value, components_);

        }

    }

    if (!bGotValue)

    {

        child = getChild(name);

        if (!child.is())

            return false;

        value = child->asValue();

    }

    return true;

}

css::uno::Any Access::getByName(OUString const & aName)

{

    assert(thisIs(IS_ANY));

    osl::MutexGuard g(*lock_);

    checkLocalizedPropertyAccess();

    css::uno::Any value;

    if (!getByNameFast(aName, value))

        throw css::container::NoSuchElementException(

            aName, getXWeak());

    return value;

}

css::uno::Sequence< OUString > Access::getElementNames()

{

    assert(thisIs(IS_ANY));

    osl::MutexGuard g(*lock_);

    checkLocalizedPropertyAccess();

    std::vector<OUString> childNames;

    forAllChildren([&childNames] (ChildAccess& rChild)

    {

        childNames.push_back(rChild.getNameInternal());

        return true;

    });

    return comphelper::containerToSequence(childNames);

}

sal_Bool Access::hasByName(OUString const & aName)

{

    assert(thisIs(IS_ANY));

    osl::MutexGuard g(*lock_);

    checkLocalizedPropertyAccess();

    return getChild(aName).is();

}

css::uno::Any Access::getByHierarchicalName(OUString const & aName)

{

    assert(thisIs(IS_ANY));

    osl::MutexGuard g(*lock_);

    checkLocalizedPropertyAccess();

    rtl::Reference< ChildAccess > child(getSubChild(aName));

    if (!child.is()) {

        throw css::container::NoSuchElementException(

            aName, getXWeak());

    }

    return child->asValue();

}

OUString Access::getDescriptionByHierarchicalName(OUString const & aName)

{

    assert(thisIs(IS_ANY));

    osl::MutexGuard g(*lock_);

    checkLocalizedPropertyAccess();

    rtl::Reference< ChildAccess > child(getSubChild(aName));

    if (!child.is()) {

        throw css::container::NoSuchElementException(

            aName, getXWeak());

    }

    return child->getNode()->getDescription();

}

css::uno::Type Access::getTypeByHierarchicalName(OUString const & aName)

{

    assert(thisIs(IS_ANY));

    osl::MutexGuard g(*lock_);

    checkLocalizedPropertyAccess();

    rtl::Reference< ChildAccess > child(getSubChild(aName));

    if (!child.is()) {

        throw css::container::NoSuchElementException(

            aName, getXWeak());

    }

    auto const & p = child->getNode();

    switch (p->kind()) {

    case Node::KIND_PROPERTY:

        return mapType(static_cast<PropertyNode *>(p.get())->getStaticType());

    case Node::KIND_LOCALIZED_PROPERTY:

        return mapType(static_cast<LocalizedPropertyNode *>(p.get())->getStaticType());

    default:

        throw css::util::InvalidStateException(

            aName, getXWeak());

    }

}

sal_Bool Access::getModifiedByHierarchicalName(OUString const & aName)

{

    assert(thisIs(IS_ANY));

    osl::MutexGuard g(*lock_);

    checkLocalizedPropertyAccess();

    rtl::Reference< ChildAccess > child(getSubChild(aName));

    if (!child.is()) {

        throw css::container::NoSuchElementException(

            aName, getXWeak());

    }

    auto const & p = child->getNode();

    switch (p->kind()) {

    case Node::KIND_PROPERTY:

        return static_cast<PropertyNode *>(p.get())->isModified();

    case Node::KIND_LOCALIZED_VALUE:

        return static_cast<LocalizedValueNode *>(p.get())->isModified();

    default:

        throw css::util::InvalidStateException(

            aName, getXWeak());

    }

}

sal_Bool Access::hasByHierarchicalName(OUString const & aName)

{

    assert(thisIs(IS_ANY));

    osl::MutexGuard g(*lock_);

    checkLocalizedPropertyAccess();

    return getSubChild(aName).is();

}

void Access::replaceByHierarchicalName(

    OUString const & aName, css::uno::Any const & aElement)

{

    //TODO: Actually support sets and combine with replaceByName:

    assert(thisIs(IS_UPDATE));

    Broadcaster bc;

    {

        osl::MutexGuard g(*lock_);

        checkLocalizedPropertyAccess();

        rtl::Reference< ChildAccess > child(getSubChild(aName));

        if (!child.is()) {

            throw css::container::NoSuchElementException(

                aName, getXWeak());

        }

        child->checkFinalized();

        rtl::Reference< Node > parent(child->getParentNode());

        assert(parent.is());

        Modifications localMods;

        switch (parent->kind()) {

        case Node::KIND_LOCALIZED_PROPERTY:

        case Node::KIND_GROUP:

            child->setProperty(aElement, &localMods);

            break;

        case Node::KIND_SET:

            throw css::lang::IllegalArgumentException(

                (u"configmgr::Access::replaceByHierarchicalName does not"

                 " currently support set members"_ustr),

                getXWeak(), 0);

        case Node::KIND_ROOT:

            throw css::lang::IllegalArgumentException(

                ("configmgr::Access::replaceByHierarchicalName does not allow"

                 " changing component " + aName),

                getXWeak(), 0);

        default:

            assert(false); // this cannot happen

            break;

        }

        getNotificationRoot()->initBroadcaster(localMods.getRoot(), &bc);

    }

    bc.send();

}

void Access::addContainerListener(

    css::uno::Reference< css::container::XContainerListener > const & xListener)

{

    assert(thisIs(IS_ANY));

    {

        osl::MutexGuard g(*lock_);

        checkLocalizedPropertyAccess();

        if (!xListener.is()) {

            throw css::uno::RuntimeException(

                u"null listener"_ustr, getXWeak());

        }

        if (!disposed_) {

            containerListeners_.insert(xListener);

            return;

        }

    }

    try {

        xListener->disposing(

            css::lang::EventObject(getXWeak()));

    } catch (css::lang::DisposedException &) {}

}

void Access::removeContainerListener(

    css::uno::Reference< css::container::XContainerListener > const & xListener)

{

    assert(thisIs(IS_ANY));

    osl::MutexGuard g(*lock_);

    checkLocalizedPropertyAccess();

    auto i(containerListeners_.find(xListener));

    if (i != containerListeners_.end()) {

        containerListeners_.erase(i);

    }

}

OUString Access::getExactName(OUString const & aApproximateName)

{

    assert(thisIs(IS_ANY));

    osl::MutexGuard g(*lock_);

    checkLocalizedPropertyAccess();

    return aApproximateName;

}

css::uno::Sequence< css::beans::Property > Access::getProperties()

{

    assert(thisIs(IS_GROUP));

    osl::MutexGuard g(*lock_);

    std::vector< css::beans::Property > properties;

    forAllChildren([&properties] (ChildAccess& rChild)

    {

        properties.push_back(rChild.asProperty());

        return true;

    });

    return comphelper::containerToSequence(properties);

}

css::beans::Property Access::getPropertyByName(OUString const & aName)

{

    assert(thisIs(IS_GROUP));

    osl::MutexGuard g(*lock_);

    rtl::Reference< ChildAccess > child(getChild(aName));

    if (!child.is()) {

        throw css::beans::UnknownPropertyException(

            aName, getXWeak());

    }

    return child->asProperty();

}

sal_Bool Access::hasPropertyByName(OUString const & Name)

{

    assert(thisIs(IS_GROUP));

    osl::MutexGuard g(*lock_);

    return getChild(Name).is();

}

OUString Access::getHierarchicalName() {

    assert(thisIs(IS_ANY));

    osl::MutexGuard g(*lock_);

    checkLocalizedPropertyAccess();

    // For backwards compatibility, return an absolute path representation where

    // available:

    OUString rootPath;

    rtl::Reference< RootAccess > root(getRootAccess());

    if (root.is()) {

        rootPath = root->getAbsolutePathRepresentation();

    }

    OUString rel(getRelativePathRepresentation());

    OUStringBuffer path(rootPath);

    if (!rootPath.isEmpty() && rootPath != "/" && !rel.isEmpty()) {

        path.append('/');

    }

    path.append(rel);

    return path.makeStringAndClear();

}

OUString Access::composeHierarchicalName(

    OUString const & aRelativeName)

{

    assert(thisIs(IS_ANY));

    osl::MutexGuard g(*lock_);

    checkLocalizedPropertyAccess();

    if (aRelativeName.isEmpty() || aRelativeName[0] == '/') {

        throw css::lang::IllegalArgumentException(

            u"configmgr composeHierarchicalName inappropriate relative name"_ustr,

            getXWeak(), -1);

    }

    OUStringBuffer path(getRelativePathRepresentation());

    if (!path.isEmpty()) {

        path.append('/');

    }

    path.append(aRelativeName);

    return path.makeStringAndClear();

}

OUString Access::getName() {

    assert(thisIs(IS_ANY));

    osl::MutexGuard g(*lock_);

    checkLocalizedPropertyAccess();

    return getNameInternal();

}

void Access::setName(OUString const & aName)

{

    assert(thisIs(IS_ANY));

    Broadcaster bc;

    {

        osl::MutexGuard g(*lock_);

        checkLocalizedPropertyAccess();

        checkFinalized();

        Modifications localMods;

        switch (getNode()->kind()) {

        case Node::KIND_GROUP:

        case Node::KIND_SET:

            {

                rtl::Reference< Access > parent(getParentAccess());

                if (parent.is()) {

                    const rtl::Reference< Node > & node(getNode());

                    if (! node->getTemplateName().isEmpty()) {

                        rtl::Reference< ChildAccess > other(

                            parent->getChild(aName));

                        if (other.get() == this) {

                            break;

                        }

                        if (node->getMandatory() == Data::NO_LAYER &&

                            !(other.is() && other->isFinalized()))

                        {

                            if (!isValidName(aName, true)) {

                                throw css::uno::RuntimeException(

                                    "invalid element name " + aName);

                            }

                            rtl::Reference< RootAccess > root(getRootAccess());

                            rtl::Reference< ChildAccess > childAccess(

                                static_cast< ChildAccess * >(this));

                            localMods.add(getRelativePath());

                            // unbind() modifies the parent chain that

                            // markChildAsModified() walks, so order is

                            // important:

                            parent->markChildAsModified(childAccess);

                                //TODO: must not throw

                            childAccess->unbind(); // must not throw

                            if (other.is()) {

                                other->unbind(); // must not throw

                            }

                            childAccess->bind(root, parent, aName);

                                // must not throw

                            parent->markChildAsModified(childAccess);

                                //TODO: must not throw

                            localMods.add(getRelativePath());

                            break;

                        }

                    }

                }

            }

            [[fallthrough]];

        case Node::KIND_LOCALIZED_PROPERTY:

            // renaming a property could only work for an extension property,

            // but a localized property is never an extension property

            throw css::uno::RuntimeException(

                u"configmgr setName inappropriate node"_ustr,

                getXWeak());

        default:

            assert(false); // this cannot happen

            break;

        }

        getNotificationRoot()->initBroadcaster(localMods.getRoot(), &bc);

    }

    bc.send();

}

css::beans::Property Access::getAsProperty()

{

    assert(thisIs(IS_ANY));

    osl::MutexGuard g(*lock_);

    checkLocalizedPropertyAccess();

    return asProperty();

}

css::uno::Reference< css::beans::XPropertySetInfo > Access::getPropertySetInfo()

{

    assert(thisIs(IS_GROUP));

    return this;

}

void Access::setPropertyValue(

    OUString const & aPropertyName, css::uno::Any const & aValue)

{

    assert(thisIs(IS_GROUP));

    Broadcaster bc;

    {

        osl::MutexGuard g(*lock_);

        if (!getRootAccess()->isUpdate()) {

            throw css::uno::RuntimeException(

                u"configmgr setPropertyValue on non-update access"_ustr,

                getXWeak());

        }

        Modifications localMods;

        if (!setChildProperty(aPropertyName, aValue, &localMods)) {

            throw css::beans::UnknownPropertyException(

                aPropertyName, getXWeak());

        }

        getNotificationRoot()->initBroadcaster(localMods.getRoot(), &bc);

    }

    bc.send();

}

css::uno::Any Access::getPropertyValue(OUString const & PropertyName)

{

    assert(thisIs(IS_GROUP));

    osl::MutexGuard g(*lock_);

    css::uno::Any value;

    if (!getByNameFast(PropertyName, value))

        throw css::beans::UnknownPropertyException(

            PropertyName, getXWeak());

    return value;

}

void Access::addPropertyChangeListener(

    OUString const & aPropertyName,

    css::uno::Reference< css::beans::XPropertyChangeListener > const &

        xListener)

{

    assert(thisIs(IS_GROUP));

    {

        osl::MutexGuard g(*lock_);

        if (!xListener.is()) {

            throw css::uno::RuntimeException(

                u"null listener"_ustr, getXWeak());

        }

        checkKnownProperty(aPropertyName);

        if (!disposed_) {

            propertyChangeListeners_[aPropertyName].insert(xListener);

            return;

        }

    }

    try {

        xListener->disposing(

            css::lang::EventObject(getXWeak()));

    } catch (css::lang::DisposedException &) {}

}

void Access::removePropertyChangeListener(

    OUString const & aPropertyName,

    css::uno::Reference< css::beans::XPropertyChangeListener > const &

        aListener)

{

    assert(thisIs(IS_GROUP));

    osl::MutexGuard g(*lock_);

    checkKnownProperty(aPropertyName);

    PropertyChangeListeners::iterator i(

        propertyChangeListeners_.find(aPropertyName));

    if (i != propertyChangeListeners_.end()) {

        auto j(i->second.find(aListener));

        if (j != i->second.end()) {

            i->second.erase(j);

            if (i->second.empty()) {

                propertyChangeListeners_.erase(i);

            }

        }

    }

}

void Access::addVetoableChangeListener(

    OUString const & PropertyName,

    css::uno::Reference< css::beans::XVetoableChangeListener > const &

        aListener)

{

    assert(thisIs(IS_GROUP));

    {

        osl::MutexGuard g(*lock_);

        if (!aListener.is()) {

            throw css::uno::RuntimeException(

                u"null listener"_ustr, getXWeak());

        }

        checkKnownProperty(PropertyName);

        if (!disposed_) {

            vetoableChangeListeners_[PropertyName].insert(aListener);

            //TODO: actually call vetoableChangeListeners_

            return;

        }

    }

    try {

        aListener->disposing(

            css::lang::EventObject(getXWeak()));

    } catch (css::lang::DisposedException &) {}

}

void Access::removeVetoableChangeListener(

    OUString const & PropertyName,

    css::uno::Reference< css::beans::XVetoableChangeListener > const &

        aListener)

{

    assert(thisIs(IS_GROUP));

    osl::MutexGuard g(*lock_);

    checkKnownProperty(PropertyName);

    VetoableChangeListeners::iterator i(

        vetoableChangeListeners_.find(PropertyName));

    if (i != vetoableChangeListeners_.end()) {

        auto j(i->second.find(aListener));

        if (j != i->second.end()) {

            i->second.erase(j);

            if (i->second.empty()) {

                vetoableChangeListeners_.erase(i);

            }

        }

    }

}

void Access::setPropertyValues(

    css::uno::Sequence< OUString > const & aPropertyNames,

    css::uno::Sequence< css::uno::Any > const & aValues)

{

    assert(thisIs(IS_GROUP));

    Broadcaster bc;

    {

        osl::MutexGuard g(*lock_);

        if (!getRootAccess()->isUpdate()) {

            throw css::uno::RuntimeException(

                u"configmgr setPropertyValues on non-update access"_ustr,

                getXWeak());

        }

        if (aPropertyNames.getLength() != aValues.getLength()) {