configmgr/source/rootaccess.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "sal/config.h"
  21
  22 #include <cassert>
  23 #include <vector>
  24
  25 #include "com/sun/star/lang/DisposedException.hpp"
  26 #include "com/sun/star/lang/EventObject.hpp"
  27 #include "com/sun/star/lang/WrappedTargetException.hpp"
  28 #include "com/sun/star/uno/Any.hxx"
  29 #include "com/sun/star/uno/Reference.hxx"
  30 #include "com/sun/star/uno/RuntimeException.hpp"
  31 #include "com/sun/star/uno/Type.hxx"
  32 #include "com/sun/star/uno/XInterface.hpp"
  33 #include "com/sun/star/util/ChangesEvent.hpp"
  34 #include "com/sun/star/util/ChangesSet.hpp"
  35 #include "com/sun/star/util/ElementChange.hpp"
  36 #include "com/sun/star/util/XChangesBatch.hpp"
  37 #include "com/sun/star/util/XChangesListener.hpp"
  38 #include "com/sun/star/util/XChangesNotifier.hpp"
  39 #include "comphelper/sequenceasvector.hxx"
  40 #include "cppu/unotype.hxx"
  41 #include "cppuhelper/queryinterface.hxx"
  42 #include "cppuhelper/weak.hxx"
  43 #include "osl/mutex.hxx"
  44 #include "rtl/ref.hxx"
  45 #include "rtl/ustring.h"
  46 #include "rtl/ustring.hxx"
  47
  48 #include "broadcaster.hxx"
  49 #include "childaccess.hxx"
  50 #include "components.hxx"
  51 #include "data.hxx"
  52 #include "lock.hxx"
  53 #include "modifications.hxx"
  54 #include "node.hxx"
  55 #include "path.hxx"
  56 #include "rootaccess.hxx"
  57
  58 namespace configmgr {
  59
  60 RootAccess::RootAccess(
  61     Components & components, OUString const & pathRepresentation,
  62     OUString const & locale, bool update):
  63     Access(components), pathRepresentation_(pathRepresentation),
  64     locale_(locale), update_(update), finalized_(false), alive_(true)
  65 {
  66     lock_ = lock();
  67 }
  68
  69 Path RootAccess::getAbsolutePath() {
  70     getNode();
  71     return path_;
  72 }
  73
  74 void RootAccess::initBroadcaster(
  75     Modifications::Node const & modifications, Broadcaster * broadcaster)
  76 {
  77     assert(broadcaster != 0);
  78     comphelper::SequenceAsVector< css::util::ElementChange > changes;
  79     initBroadcasterAndChanges(
  80         modifications, broadcaster, changesListeners_.empty() ? 0 : &changes);
  81     if (!changes.empty()) {
  82         css::util::ChangesSet set(changes.getAsConstList());
  83         for (ChangesListeners::iterator i(changesListeners_.begin());
  84              i != changesListeners_.end(); ++i)
  85         {
  86             cppu::OWeakObject* pSource = static_cast< cppu::OWeakObject * >(this);
  87             css::uno::Reference< css::uno::XInterface > xBase( pSource, css::uno::UNO_QUERY );
  88             broadcaster->addChangesNotification(
  89                 *i,
  90                 css::util::ChangesEvent(
  91                     pSource, makeAny( xBase ), set));
  92         }
  93     }
  94 }
  95
  96 void RootAccess::acquire() throw () {
  97     Access::acquire();
  98 }
  99
 100 void RootAccess::release() throw () {
 101     Access::release();
 102 }
 103
 104 OUString RootAccess::getAbsolutePathRepresentation() {
 105     getNode(); // turn pathRepresentation_ into canonic form
 106     return pathRepresentation_;
 107 }
 108
 109 OUString RootAccess::getLocale() const {
 110     return locale_;
 111 }
 112
 113 bool RootAccess::isUpdate() const {
 114     return update_;
 115 }
 116
 117 void RootAccess::setAlive(bool b) {
 118     alive_ = b;
 119 }
 120
 121 void RootAccess::addChangesListener(
 122     css::uno::Reference< css::util::XChangesListener > const & aListener)
 123     throw (css::uno::RuntimeException)
 124 {
 125     assert(thisIs(IS_ANY));
 126     {
 127         osl::MutexGuard g(*lock_);
 128         checkLocalizedPropertyAccess();
 129         if (!aListener.is()) {
 130             throw css::uno::RuntimeException(
 131                 OUString("null listener"),
 132                 static_cast< cppu::OWeakObject * >(this));
 133         }
 134         if (!isDisposed()) {
 135             changesListeners_.insert(aListener);
 136             return;
 137         }
 138     }
 139     try {
 140         aListener->disposing(
 141             css::lang::EventObject(static_cast< cppu::OWeakObject * >(this)));
 142     } catch (css::lang::DisposedException &) {}
 143 }
 144
 145 void RootAccess::removeChangesListener(
 146     css::uno::Reference< css::util::XChangesListener > const & aListener)
 147     throw (css::uno::RuntimeException)
 148 {
 149     assert(thisIs(IS_ANY));
 150     osl::MutexGuard g(*lock_);
 151     checkLocalizedPropertyAccess();
 152     ChangesListeners::iterator i(changesListeners_.find(aListener));
 153     if (i != changesListeners_.end()) {
 154         changesListeners_.erase(i);
 155     }
 156 }
 157
 158 void RootAccess::commitChanges()
 159     throw (css::lang::WrappedTargetException, css::uno::RuntimeException)
 160 {
 161     assert(thisIs(IS_UPDATE));
 162     if (!alive_)
 163     {
 164         return;
 165     }
 166     Broadcaster bc;
 167     {
 168         osl::MutexGuard g(*lock_);
 169
 170         checkLocalizedPropertyAccess();
 171         int finalizedLayer;
 172         Modifications globalMods;
 173         commitChildChanges(
 174             ((getComponents().resolvePathRepresentation(
 175                   pathRepresentation_, 0, 0, &finalizedLayer)
 176               == node_) &&
 177              finalizedLayer == Data::NO_LAYER),
 178             &globalMods);
 179         getComponents().writeModifications();
 180         getComponents().initGlobalBroadcaster(globalMods, this, &bc);
 181     }
 182     bc.send();
 183 }
 184
 185 sal_Bool RootAccess::hasPendingChanges() throw (css::uno::RuntimeException) {
 186     assert(thisIs(IS_UPDATE));
 187     osl::MutexGuard g(*lock_);
 188     checkLocalizedPropertyAccess();
 189     //TODO: Optimize:
 190     std::vector< css::util::ElementChange > changes;
 191     reportChildChanges(&changes);
 192     return !changes.empty();
 193 }
 194
 195 css::util::ChangesSet RootAccess::getPendingChanges()
 196     throw (css::uno::RuntimeException)
 197 {
 198     assert(thisIs(IS_UPDATE));
 199     osl::MutexGuard g(*lock_);
 200     checkLocalizedPropertyAccess();
 201     comphelper::SequenceAsVector< css::util::ElementChange > changes;
 202     reportChildChanges(&changes);
 203     return changes.getAsConstList();
 204 }
 205
 206 RootAccess::~RootAccess()
 207 {
 208     osl::MutexGuard g(*lock_);
 209     if (alive_)
 210         getComponents().removeRootAccess(this);
 211 }
 212
 213 Path RootAccess::getRelativePath() {
 214     return Path();
 215 }
 216
 217 OUString RootAccess::getRelativePathRepresentation() {
 218     return OUString();
 219 }
 220
 221 rtl::Reference< Node > RootAccess::getNode() {
 222     if (!node_.is()) {
 223         OUString canonic;
 224         int finalizedLayer;
 225         node_ = getComponents().resolvePathRepresentation(
 226             pathRepresentation_, &canonic, &path_, &finalizedLayer);
 227         if (!node_.is()) {
 228             throw css::uno::RuntimeException(
 229                 (OUString("cannot find ") +
 230                  pathRepresentation_),
 231                 0);
 232                 // RootAccess::queryInterface indirectly calls
 233                 // RootAccess::getNode, so if this RootAccess were passed out in
 234                 // RuntimeException.Context, client code that called
 235                 // queryInterface on it would cause trouble; therefore,
 236                 // RuntimeException.Context is left null here
 237         }
 238         pathRepresentation_ = canonic;
 239         assert(!path_.empty() || node_->kind() == Node::KIND_ROOT);
 240         if (!path_.empty()) {
 241             name_ = path_.back();
 242         }
 243         finalized_ = finalizedLayer != Data::NO_LAYER;
 244     }
 245     return node_;
 246 }
 247
 248 bool RootAccess::isFinalized() {
 249     getNode();
 250     return finalized_;
 251 }
 252
 253 OUString RootAccess::getNameInternal() {
 254     getNode();
 255     return name_;
 256 }
 257
 258 rtl::Reference< RootAccess > RootAccess::getRootAccess() {
 259     return this;
 260 }
 261
 262 rtl::Reference< Access > RootAccess::getParentAccess() {
 263     return rtl::Reference< Access >();
 264 }
 265
 266 void RootAccess::addTypes(std::vector< css::uno::Type > * types) const {
 267     assert(types != 0);
 268     types->push_back(cppu::UnoType< css::util::XChangesNotifier >::get());
 269     types->push_back(cppu::UnoType< css::util::XChangesBatch >::get());
 270 }
 271
 272 void RootAccess::addSupportedServiceNames(
 273     std::vector< OUString > * services)
 274 {
 275     assert(services != 0);
 276     services->push_back(
 277         OUString("com.sun.star.configuration.AccessRootElement"));
 278     if (update_) {
 279         services->push_back(
 280             OUString("com.sun.star.configuration.UpdateRootElement"));
 281     }
 282 }
 283
 284 void RootAccess::initDisposeBroadcaster(Broadcaster * broadcaster) {
 285     assert(broadcaster != 0);
 286     for (ChangesListeners::iterator i(changesListeners_.begin());
 287          i != changesListeners_.end(); ++i)
 288     {
 289         broadcaster->addDisposeNotification(
 290             i->get(),
 291             css::lang::EventObject(static_cast< cppu::OWeakObject * >(this)));
 292     }
 293     Access::initDisposeBroadcaster(broadcaster);
 294 }
 295
 296 void RootAccess::clearListeners() throw() {
 297     changesListeners_.clear();
 298     Access::clearListeners();
 299 }
 300
 301 css::uno::Any RootAccess::queryInterface(css::uno::Type const & aType)
 302     throw (css::uno::RuntimeException)
 303 {
 304     assert(thisIs(IS_ANY));
 305     osl::MutexGuard g(*lock_);
 306     checkLocalizedPropertyAccess();
 307     css::uno::Any res(Access::queryInterface(aType));
 308     if (res.hasValue()) {
 309         return res;
 310     }
 311     res = cppu::queryInterface(
 312         aType, static_cast< css::util::XChangesNotifier * >(this));
 313     if (res.hasValue()) {
 314         return res;
 315     }
 316     if (!res.hasValue() && update_) {
 317         res = cppu::queryInterface(
 318             aType, static_cast< css::util::XChangesBatch * >(this));
 319     }
 320     return res;
 321 }
 322
 323 OUString RootAccess::getImplementationName()
 324     throw (css::uno::RuntimeException)
 325 {
 326     assert(thisIs(IS_ANY));
 327     osl::MutexGuard g(*lock_);
 328     checkLocalizedPropertyAccess();
 329     return OUString("configmgr.RootAccess");
 330 }
 331
 332 }
 333
 334 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */