configmgr/source/configurationregistry.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
  24 #include <com/sun/star/beans/NamedValue.hpp>
  25 #include <com/sun/star/container/NoSuchElementException.hpp>
  26 #include <com/sun/star/container/XHierarchicalNameAccess.hpp>
  27 #include <com/sun/star/container/XNamed.hpp>
  28 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  29 #include <com/sun/star/lang/XServiceInfo.hpp>
  30 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
  31 #include <com/sun/star/registry/InvalidRegistryException.hpp>
  32 #include <com/sun/star/registry/InvalidValueException.hpp>
  33 #include <com/sun/star/registry/RegistryKeyType.hpp>
  34 #include <com/sun/star/registry/RegistryValueType.hpp>
  35 #include <com/sun/star/registry/XRegistryKey.hpp>
  36 #include <com/sun/star/registry/XSimpleRegistry.hpp>
  37 #include <com/sun/star/uno/Any.hxx>
  38 #include <com/sun/star/uno/DeploymentException.hpp>
  39 #include <com/sun/star/uno/Exception.hpp>
  40 #include <com/sun/star/uno/Reference.hxx>
  41 #include <com/sun/star/uno/RuntimeException.hpp>
  42 #include <com/sun/star/uno/Sequence.hxx>
  43 #include <com/sun/star/uno/Type.hxx>
  44 #include <com/sun/star/uno/TypeClass.hpp>
  45 #include <com/sun/star/uno/XComponentContext.hpp>
  46 #include <com/sun/star/uno/XInterface.hpp>
  47 #include <com/sun/star/util/XFlushable.hpp>
  48 #include <cppu/unotype.hxx>
  49 #include <cppuhelper/exc_hlp.hxx>
  50 #include <cppuhelper/implbase.hxx>
  51 #include <cppuhelper/supportsservice.hxx>
  52 #include <cppuhelper/weak.hxx>
  53 #include <mutex>
  54 #include <rtl/ustring.hxx>
  55 #include <utility>
  56 #include <sal/types.h>
  57
  58 namespace com::sun::star::util {
  59     class XFlushListener;
  60 }
  61
  62 namespace configmgr::configuration_registry {
  63
  64 namespace {
  65
  66 class Service:
  67     public cppu::WeakImplHelper<
  68         css::lang::XServiceInfo, css::registry::XSimpleRegistry,
  69         css::util::XFlushable >
  70 {
  71 public:
  72     explicit Service(css::uno::Reference< css::uno::XComponentContext > const & context);
  73
  74 private:
  75     Service(const Service&) = delete;
  76     Service& operator=(const Service&) = delete;
  77
  78     virtual ~Service() override {}
  79
  80     virtual OUString SAL_CALL getImplementationName() override
  81     { return u"com.sun.star.comp.configuration.ConfigurationRegistry"_ustr; }
  82
  83     virtual sal_Bool SAL_CALL supportsService(OUString const & ServiceName) override
  84     { return cppu::supportsService(this, ServiceName); }
  85
  86     virtual css::uno::Sequence< OUString > SAL_CALL
  87     getSupportedServiceNames() override
  88     { return { u"com.sun.star.configuration.ConfigurationRegistry"_ustr }; }
  89
  90     virtual OUString SAL_CALL getURL() override;
  91
  92     virtual void SAL_CALL open(
  93         OUString const & rURL, sal_Bool bReadOnly, sal_Bool) override;
  94
  95     virtual sal_Bool SAL_CALL isValid() override;
  96
  97     virtual void SAL_CALL close() override;
  98
  99     virtual void SAL_CALL destroy() override;
 100
 101     virtual css::uno::Reference< css::registry::XRegistryKey > SAL_CALL
 102     getRootKey() override;
 103
 104     virtual sal_Bool SAL_CALL isReadOnly() override;
 105
 106     virtual void SAL_CALL mergeKey(OUString const &, OUString const &) override;
 107
 108     virtual void SAL_CALL flush() override;
 109
 110     virtual void SAL_CALL addFlushListener(
 111         css::uno::Reference< css::util::XFlushListener > const &) override;
 112
 113     virtual void SAL_CALL removeFlushListener(
 114         css::uno::Reference< css::util::XFlushListener > const &) override;
 115
 116     void checkValid();
 117
 118     void checkValid_RuntimeException();
 119
 120     void doClose();
 121
 122     css::uno::Reference< css::lang::XMultiServiceFactory > provider_;
 123     std::mutex mutex_;
 124     css::uno::Reference< css::uno::XInterface > access_;
 125     OUString url_;
 126     bool readOnly_;
 127
 128     friend class RegistryKey;
 129 };
 130
 131 class RegistryKey:
 132     public cppu::WeakImplHelper< css::registry::XRegistryKey >
 133 {
 134 public:
 135     RegistryKey(Service & service, css::uno::Any value):
 136         service_(service), value_(std::move(value)) {}
 137
 138 private:
 139     RegistryKey(const RegistryKey&) = delete;
 140     RegistryKey& operator=(const RegistryKey&) = delete;
 141
 142     virtual ~RegistryKey() override {}
 143
 144     virtual OUString SAL_CALL getKeyName() override;
 145
 146     virtual sal_Bool SAL_CALL isReadOnly() override;
 147
 148     virtual sal_Bool SAL_CALL isValid() override;
 149
 150     virtual css::registry::RegistryKeyType SAL_CALL getKeyType(
 151         OUString const &) override;
 152
 153     virtual css::registry::RegistryValueType SAL_CALL getValueType() override;
 154
 155     virtual sal_Int32 SAL_CALL getLongValue() override;
 156
 157     virtual void SAL_CALL setLongValue(sal_Int32) override;
 158
 159     virtual css::uno::Sequence< sal_Int32 > SAL_CALL getLongListValue() override;
 160
 161     virtual void SAL_CALL setLongListValue(
 162         css::uno::Sequence< sal_Int32 > const &) override;
 163
 164     virtual OUString SAL_CALL getAsciiValue() override;
 165
 166     virtual void SAL_CALL setAsciiValue(OUString const &) override;
 167
 168     virtual css::uno::Sequence< OUString > SAL_CALL getAsciiListValue() override;
 169
 170     virtual void SAL_CALL setAsciiListValue(
 171         css::uno::Sequence< OUString > const &) override;
 172
 173     virtual OUString SAL_CALL getStringValue() override;
 174
 175     virtual void SAL_CALL setStringValue(OUString const &) override;
 176
 177     virtual css::uno::Sequence< OUString > SAL_CALL getStringListValue() override;
 178
 179     virtual void SAL_CALL setStringListValue(
 180         css::uno::Sequence< OUString > const &) override;
 181
 182     virtual css::uno::Sequence< sal_Int8 > SAL_CALL getBinaryValue() override;
 183
 184     virtual void SAL_CALL setBinaryValue(css::uno::Sequence< sal_Int8 > const &) override;
 185
 186     virtual css::uno::Reference< css::registry::XRegistryKey > SAL_CALL openKey(
 187         OUString const & aKeyName) override;
 188
 189     virtual css::uno::Reference< css::registry::XRegistryKey > SAL_CALL
 190     createKey(OUString const &) override;
 191
 192     virtual void SAL_CALL closeKey() override;
 193
 194     virtual void SAL_CALL deleteKey(OUString const &) override;
 195
 196     virtual
 197     css::uno::Sequence< css::uno::Reference< css::registry::XRegistryKey > >
 198     SAL_CALL openKeys() override;
 199
 200     virtual css::uno::Sequence< OUString > SAL_CALL getKeyNames() override;
 201
 202     virtual sal_Bool SAL_CALL createLink(
 203         OUString const &, OUString const &) override;
 204
 205     virtual void SAL_CALL deleteLink(OUString const &) override;
 206
 207     virtual OUString SAL_CALL getLinkTarget(OUString const &) override;
 208
 209     virtual OUString SAL_CALL getResolvedName(
 210         OUString const & aKeyName) override;
 211
 212     Service & service_;
 213     css::uno::Any value_;
 214 };
 215
 216 Service::Service(
 217     css::uno::Reference< css::uno::XComponentContext > const & context)
 218     : readOnly_(false)
 219 {
 220     assert(context.is());
 221     try {
 222         provider_.set(
 223             context->getServiceManager()->createInstanceWithContext(
 224                 u"com.sun.star.configuration.DefaultProvider"_ustr, context),
 225             css::uno::UNO_QUERY_THROW);
 226     } catch (css::uno::RuntimeException &) {
 227         throw;
 228     } catch (css::uno::Exception & e) {
 229         throw css::uno::DeploymentException(
 230             ("component context fails to supply service"
 231              " com.sun.star.configuration.DefaultProvider of type"
 232              " com.sun.star.lang.XMultiServiceFactory: " + e.Message),
 233             context);
 234     }
 235 }
 236
 237 OUString Service::getURL() {
 238     std::unique_lock g(mutex_);
 239     checkValid_RuntimeException();
 240     return url_;
 241 }
 242
 243 void Service::open(OUString const & rURL, sal_Bool bReadOnly, sal_Bool)
 244 {
 245     //TODO: bCreate
 246     std::unique_lock g(mutex_);
 247     if (access_.is()) {
 248         doClose();
 249     }
 250     css::uno::Sequence< css::uno::Any > args{ css::uno::Any(
 251         css::beans::NamedValue(u"nodepath"_ustr, css::uno::Any(rURL))) };
 252     try {
 253         access_ = provider_->createInstanceWithArguments(
 254             (bReadOnly
 255              ? u"com.sun.star.configuration.ConfigurationAccess"_ustr
 256              : u"com.sun.star.configuration.ConfigurationUpdateAccess"_ustr),
 257             args);
 258     } catch (css::uno::RuntimeException &) {
 259         throw;
 260     } catch (css::uno::Exception & e) {
 261         css::uno::Any anyEx = cppu::getCaughtException();
 262         throw css::lang::WrappedTargetRuntimeException(
 263             "com.sun.star.configuration.ConfigurationRegistry: open failed: " +
 264             e.Message,
 265             getXWeak(), anyEx );
 266     }
 267     url_ = rURL;
 268     readOnly_ = bReadOnly;
 269 }
 270
 271 sal_Bool Service::isValid() {
 272     std::unique_lock g(mutex_);
 273     return access_.is();
 274 }
 275
 276 void Service::close()
 277 {
 278     std::unique_lock g(mutex_);
 279     checkValid();
 280     doClose();
 281 }
 282
 283 void Service::destroy()
 284 {
 285     throw css::uno::RuntimeException(
 286         u"com.sun.star.configuration.ConfigurationRegistry: not implemented"_ustr,
 287         getXWeak());
 288 }
 289
 290 css::uno::Reference< css::registry::XRegistryKey > Service::getRootKey()
 291 {
 292     std::unique_lock g(mutex_);
 293     checkValid();
 294     return new RegistryKey(*this, css::uno::Any(access_));
 295 }
 296
 297 sal_Bool Service::isReadOnly() {
 298     std::unique_lock g(mutex_);
 299     checkValid_RuntimeException();
 300     return readOnly_;
 301 }
 302
 303 void Service::mergeKey(OUString const &, OUString const &)
 304 {
 305     throw css::uno::RuntimeException(
 306         u"com.sun.star.configuration.ConfigurationRegistry: not implemented"_ustr,
 307         getXWeak());
 308 }
 309
 310 void Service::flush()
 311 {
 312     throw css::uno::RuntimeException(
 313         u"com.sun.star.configuration.ConfigurationRegistry: not implemented"_ustr,
 314         getXWeak());
 315 }
 316
 317 void Service::addFlushListener(
 318     css::uno::Reference< css::util::XFlushListener > const &)
 319 {
 320     throw css::uno::RuntimeException(
 321         u"com.sun.star.configuration.ConfigurationRegistry: not implemented"_ustr,
 322         getXWeak());
 323 }
 324
 325 void Service::removeFlushListener(
 326     css::uno::Reference< css::util::XFlushListener > const &)
 327 {
 328     throw css::uno::RuntimeException(
 329         u"com.sun.star.configuration.ConfigurationRegistry: not implemented"_ustr,
 330         getXWeak());
 331 }
 332
 333 void Service::checkValid() {
 334     if (!access_.is()) {
 335         throw css::registry::InvalidRegistryException(
 336             u"com.sun.star.configuration.ConfigurationRegistry: not valid"_ustr,
 337             getXWeak());
 338     }
 339 }
 340
 341 void Service::checkValid_RuntimeException() {
 342     if (!access_.is()) {
 343         throw css::uno::RuntimeException(
 344             u"com.sun.star.configuration.ConfigurationRegistry: not valid"_ustr,
 345             getXWeak());
 346     }
 347 }
 348
 349 void Service::doClose() {
 350     access_.clear();
 351 }
 352
 353 OUString RegistryKey::getKeyName() {
 354     std::unique_lock g(service_.mutex_);
 355     service_.checkValid_RuntimeException();
 356     css::uno::Reference< css::container::XNamed > named;
 357     if (value_ >>= named) {
 358         return named->getName();
 359     }
 360     throw css::uno::RuntimeException(
 361         u"com.sun.star.configuration.ConfigurationRegistry: not implemented"_ustr,
 362         getXWeak());
 363 }
 364
 365 sal_Bool RegistryKey::isReadOnly()
 366 {
 367     std::unique_lock g(service_.mutex_);
 368     service_.checkValid_RuntimeException();
 369     return service_.readOnly_; //TODO: read-only sub-nodes in update access?
 370 }
 371
 372 sal_Bool RegistryKey::isValid() {
 373     return service_.isValid();
 374 }
 375
 376 css::registry::RegistryKeyType RegistryKey::getKeyType(OUString const &)
 377 {
 378     std::unique_lock g(service_.mutex_);
 379     service_.checkValid();
 380     return css::registry::RegistryKeyType_KEY;
 381 }
 382
 383 css::registry::RegistryValueType RegistryKey::getValueType()
 384 {
 385     std::unique_lock g(service_.mutex_);
 386     service_.checkValid();
 387     css::uno::Type t(value_.getValueType());
 388     switch (t.getTypeClass()) {
 389     case css::uno::TypeClass_LONG:
 390         return css::registry::RegistryValueType_LONG;
 391     case css::uno::TypeClass_STRING:
 392         return css::registry::RegistryValueType_STRING;
 393     case css::uno::TypeClass_SEQUENCE:
 394         if (t == cppu::UnoType< css::uno::Sequence< sal_Int8 > >::get()) {
 395             return css::registry::RegistryValueType_BINARY;
 396         } else if (t == cppu::UnoType< css::uno::Sequence< sal_Int32 > >::get())
 397         {
 398             return css::registry::RegistryValueType_LONGLIST;
 399         } else if (t ==
 400                    cppu::UnoType< css::uno::Sequence< OUString > >::get())
 401         {
 402             return css::registry::RegistryValueType_STRINGLIST;
 403         }
 404         [[fallthrough]];
 405     default:
 406         return css::registry::RegistryValueType_NOT_DEFINED;
 407     }
 408 }
 409
 410 sal_Int32 RegistryKey::getLongValue()
 411 {
 412     std::unique_lock g(service_.mutex_);
 413     service_.checkValid();
 414     sal_Int32 v = 0;
 415     if (value_ >>= v) {
 416         return v;
 417     }
 418     throw css::registry::InvalidValueException(
 419         u"com.sun.star.configuration.ConfigurationRegistry"_ustr,
 420         getXWeak());
 421 }
 422
 423 void RegistryKey::setLongValue(sal_Int32)
 424 {
 425     throw css::uno::RuntimeException(
 426         u"com.sun.star.configuration.ConfigurationRegistry: not implemented"_ustr,
 427         getXWeak());
 428 }
 429
 430 css::uno::Sequence< sal_Int32 > RegistryKey::getLongListValue()
 431 {
 432     std::unique_lock g(service_.mutex_);
 433     service_.checkValid();
 434     css::uno::Sequence< sal_Int32 > v;
 435     if (value_ >>= v) {
 436         return v;
 437     }
 438     throw css::registry::InvalidValueException(
 439         u"com.sun.star.configuration.ConfigurationRegistry"_ustr,
 440         getXWeak());
 441 }
 442
 443 void RegistryKey::setLongListValue(css::uno::Sequence< sal_Int32 > const &)
 444 {
 445     throw css::uno::RuntimeException(
 446         u"com.sun.star.configuration.ConfigurationRegistry: not implemented"_ustr,
 447         getXWeak());
 448 }
 449
 450 OUString RegistryKey::getAsciiValue()
 451 {
 452     std::unique_lock g(service_.mutex_);
 453     service_.checkValid();
 454     OUString v;
 455     if (value_ >>= v) {
 456         return v;
 457     }
 458     throw css::registry::InvalidValueException(
 459         u"com.sun.star.configuration.ConfigurationRegistry"_ustr,
 460         getXWeak());
 461 }
 462
 463 void RegistryKey::setAsciiValue(OUString const &)
 464 {
 465     throw css::uno::RuntimeException(
 466         u"com.sun.star.configuration.ConfigurationRegistry: not implemented"_ustr,
 467         getXWeak());
 468 }
 469
 470 css::uno::Sequence< OUString > RegistryKey::getAsciiListValue()
 471 {
 472     std::unique_lock g(service_.mutex_);
 473     service_.checkValid();
 474     css::uno::Sequence< OUString > v;
 475     if (value_ >>= v) {
 476         return v;
 477     }
 478     throw css::registry::InvalidValueException(
 479         u"com.sun.star.configuration.ConfigurationRegistry"_ustr,
 480         getXWeak());
 481 }
 482
 483 void RegistryKey::setAsciiListValue(css::uno::Sequence< OUString > const &)
 484 {
 485     throw css::uno::RuntimeException(
 486         u"com.sun.star.configuration.ConfigurationRegistry: not implemented"_ustr,
 487         getXWeak());
 488 }
 489
 490 OUString RegistryKey::getStringValue()
 491 {
 492     std::unique_lock g(service_.mutex_);
 493     service_.checkValid();
 494     OUString v;
 495     if (value_ >>= v) {
 496         return v;
 497     }
 498     throw css::registry::InvalidValueException(
 499         u"com.sun.star.configuration.ConfigurationRegistry"_ustr,
 500         getXWeak());
 501 }
 502
 503 void RegistryKey::setStringValue(OUString const &)
 504 {
 505     throw css::uno::RuntimeException(
 506         u"com.sun.star.configuration.ConfigurationRegistry: not implemented"_ustr,
 507         getXWeak());
 508 }
 509
 510 css::uno::Sequence< OUString > RegistryKey::getStringListValue()
 511 {
 512     std::unique_lock g(service_.mutex_);
 513     service_.checkValid();
 514     css::uno::Sequence< OUString > v;
 515     if (value_ >>= v) {
 516         return v;
 517     }
 518     throw css::registry::InvalidValueException(
 519         u"com.sun.star.configuration.ConfigurationRegistry"_ustr,
 520         getXWeak());
 521 }
 522
 523 void RegistryKey::setStringListValue(
 524     css::uno::Sequence< OUString > const &)
 525 {
 526     throw css::uno::RuntimeException(
 527         u"com.sun.star.configuration.ConfigurationRegistry: not implemented"_ustr,
 528         getXWeak());
 529 }
 530
 531 css::uno::Sequence< sal_Int8 > RegistryKey::getBinaryValue()
 532 {
 533     std::unique_lock g(service_.mutex_);
 534     service_.checkValid();
 535     css::uno::Sequence< sal_Int8 > v;
 536     if (value_ >>= v) {
 537         return v;
 538     }
 539     throw css::registry::InvalidValueException(
 540         u"com.sun.star.configuration.ConfigurationRegistry"_ustr,
 541         getXWeak());
 542 }
 543
 544 void RegistryKey::setBinaryValue(css::uno::Sequence< sal_Int8 > const &)
 545 {
 546     throw css::uno::RuntimeException(
 547         u"com.sun.star.configuration.ConfigurationRegistry: not implemented"_ustr,
 548         getXWeak());
 549 }
 550
 551 css::uno::Reference< css::registry::XRegistryKey > RegistryKey::openKey(
 552     OUString const & aKeyName)
 553 {
 554     std::unique_lock g(service_.mutex_);
 555     service_.checkValid_RuntimeException();
 556     css::uno::Reference< css::container::XHierarchicalNameAccess > access;
 557     if (value_ >>= access) {
 558         try {
 559             return new RegistryKey(
 560                 service_, access->getByHierarchicalName(aKeyName));
 561         } catch (css::container::NoSuchElementException &) {}
 562     }
 563     return css::uno::Reference< css::registry::XRegistryKey >();
 564 }
 565
 566 css::uno::Reference< css::registry::XRegistryKey > RegistryKey::createKey(
 567     OUString const &)
 568 {
 569     throw css::uno::RuntimeException(
 570         u"com.sun.star.configuration.ConfigurationRegistry: not implemented"_ustr,
 571         getXWeak());
 572 }
 573
 574 void RegistryKey::closeKey()
 575 {
 576     std::unique_lock g(service_.mutex_);
 577     service_.checkValid_RuntimeException();
 578 }
 579
 580 void RegistryKey::deleteKey(OUString const &)
 581 {
 582     throw css::uno::RuntimeException(
 583         u"com.sun.star.configuration.ConfigurationRegistry: not implemented"_ustr,
 584         getXWeak());
 585 }
 586
 587 css::uno::Sequence< css::uno::Reference< css::registry::XRegistryKey > >
 588 RegistryKey::openKeys()
 589 {
 590     throw css::uno::RuntimeException(
 591         u"com.sun.star.configuration.ConfigurationRegistry: not implemented"_ustr,
 592         getXWeak());
 593 }
 594
 595 css::uno::Sequence< OUString > RegistryKey::getKeyNames()
 596 {
 597     throw css::uno::RuntimeException(
 598         u"com.sun.star.configuration.ConfigurationRegistry: not implemented"_ustr,
 599         getXWeak());
 600 }
 601
 602 sal_Bool RegistryKey::createLink(OUString const &, OUString const &)
 603 {
 604     std::unique_lock g(service_.mutex_);
 605     service_.checkValid_RuntimeException();
 606     return false;
 607 }
 608
 609 void RegistryKey::deleteLink(OUString const &)
 610 {
 611     std::unique_lock g(service_.mutex_);
 612     service_.checkValid_RuntimeException();
 613 }
 614
 615 OUString RegistryKey::getLinkTarget(OUString const &)
 616 {
 617     std::unique_lock g(service_.mutex_);
 618     service_.checkValid_RuntimeException();
 619     return OUString();
 620 }
 621
 622 OUString RegistryKey::getResolvedName(OUString const & aKeyName)
 623 {
 624     std::unique_lock g(service_.mutex_);
 625     service_.checkValid_RuntimeException();
 626     return aKeyName;
 627 }
 628
 629 }
 630
 631 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 632 com_sun_star_comp_configuration_ConfigurationRegistry_get_implementation(
 633     css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const&)
 634 {
 635     return cppu::acquire(new Service(context));
 636 }
 637
 638 }
 639
 640 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */