include/comphelper/configuration.hxx

   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
  10 #ifndef INCLUDED_COMPHELPER_CONFIGURATION_HXX
  11 #define INCLUDED_COMPHELPER_CONFIGURATION_HXX
  12
  13 #include <sal/config.h>
  14
  15 #include <boost/optional.hpp>
  16 #include <com/sun/star/uno/Any.hxx>
  17 #include <com/sun/star/uno/Reference.hxx>
  18 #include <comphelper/comphelperdllapi.h>
  19 #include <comphelper/processfactory.hxx>
  20 #include <sal/types.h>
  21 #include <memory>
  22
  23 namespace com { namespace sun { namespace star {
  24     namespace configuration { class XReadWriteAccess; }
  25     namespace container {
  26         class XHierarchicalNameAccess;
  27         class XHierarchicalNameReplace;
  28         class XNameAccess;
  29         class XNameContainer;
  30     }
  31     namespace uno { class XComponentContext; }
  32 } } }
  33
  34 namespace comphelper {
  35
  36 namespace detail { class ConfigurationWrapper; }
  37
  38 /// A batch of configuration changes that is committed as a whole.
  39 ///
  40 /// Client code needs to call commit explicitly; otherwise the changes are lost
  41 /// when the instance is destroyed.
  42 ///
  43 /// This is the only class from this header file that client code should use
  44 /// directly.
  45 class COMPHELPER_DLLPUBLIC ConfigurationChanges {
  46 public:
  47     static std::shared_ptr<ConfigurationChanges> create(
  48         css::uno::Reference< css::uno::XComponentContext >
  49             const & context = comphelper::getProcessComponentContext());
  50
  51     ~ConfigurationChanges();
  52
  53     void commit() const;
  54
  55 private:
  56     ConfigurationChanges(const ConfigurationChanges&) = delete;
  57     ConfigurationChanges& operator=(const ConfigurationChanges&) = delete;
  58
  59     SAL_DLLPRIVATE ConfigurationChanges(
  60         css::uno::Reference< css::uno::XComponentContext >
  61             const & context);
  62
  63     SAL_DLLPRIVATE void setPropertyValue(
  64         OUString const & path, css::uno::Any const & value)
  65         const;
  66
  67     SAL_DLLPRIVATE css::uno::Reference<
  68         css::container::XHierarchicalNameReplace >
  69     getGroup(OUString const & path) const;
  70
  71     SAL_DLLPRIVATE
  72     css::uno::Reference< css::container::XNameContainer >
  73     getSet(OUString const & path) const;
  74
  75     css::uno::Reference<
  76         css::configuration::XReadWriteAccess > access_;
  77
  78     friend class detail::ConfigurationWrapper;
  79 };
  80
  81 namespace detail {
  82
  83 /// @internal
  84 class COMPHELPER_DLLPUBLIC ConfigurationWrapper {
  85 public:
  86     static ConfigurationWrapper const & get(
  87         css::uno::Reference< css::uno::XComponentContext >
  88             const & context);
  89
  90     SAL_DLLPRIVATE explicit ConfigurationWrapper(
  91         css::uno::Reference< css::uno::XComponentContext >
  92             const & context);
  93
  94     SAL_DLLPRIVATE ~ConfigurationWrapper();
  95
  96     bool isReadOnly(OUString const & path) const;
  97
  98     css::uno::Any getPropertyValue(OUString const & path) const;
  99
 100     static void setPropertyValue(
 101         std::shared_ptr< ConfigurationChanges > const & batch,
 102         OUString const & path, css::uno::Any const & value);
 103
 104     css::uno::Any getLocalizedPropertyValue(
 105         OUString const & path) const;
 106
 107     static void setLocalizedPropertyValue(
 108         std::shared_ptr< ConfigurationChanges > const & batch,
 109         OUString const & path, css::uno::Any const & value);
 110
 111     css::uno::Reference<
 112         css::container::XHierarchicalNameAccess >
 113     getGroupReadOnly(OUString const & path) const;
 114
 115     static css::uno::Reference<
 116         css::container::XHierarchicalNameReplace >
 117     getGroupReadWrite(
 118         std::shared_ptr< ConfigurationChanges > const & batch,
 119         OUString const & path);
 120
 121     css::uno::Reference< css::container::XNameAccess >
 122     getSetReadOnly(OUString const & path) const;
 123
 124     static css::uno::Reference< css::container::XNameContainer >
 125     getSetReadWrite(
 126         std::shared_ptr< ConfigurationChanges > const & batch,
 127         OUString const & path);
 128
 129     std::shared_ptr< ConfigurationChanges > createChanges() const;
 130
 131 private:
 132     ConfigurationWrapper(const ConfigurationWrapper&) = delete;
 133     ConfigurationWrapper& operator=(const ConfigurationWrapper&) = delete;
 134
 135     css::uno::Reference< css::uno::XComponentContext >          context_;
 136
 137     css::uno::Reference< css::configuration::XReadWriteAccess > access_;
 138         // should really be an css.configuration.ReadOnlyAccess (with added
 139         // css.beans.XHierarchicalPropertySetInfo), but then
 140         // configmgr::Access::asProperty() would report all properties as
 141         // READONLY, so isReadOnly() would not work
 142 };
 143
 144 /// @internal
 145 template< typename T > struct Convert {
 146     static css::uno::Any toAny(T const & value)
 147     { return css::uno::makeAny(value); }
 148
 149     static T fromAny(css::uno::Any const & value)
 150     { return value.get< T >(); }
 151
 152 private:
 153     Convert(const Convert&) = delete;
 154     Convert& operator=(const Convert&) = delete;
 155
 156     Convert() = delete;
 157     ~Convert() = delete;
 158 };
 159
 160 /// @internal
 161 template< typename T > struct Convert< boost::optional< T > >
 162 {
 163     static css::uno::Any toAny(boost::optional< T > const & value) {
 164         return value
 165             ? css::uno::makeAny(value.get())
 166             : css::uno::Any();
 167     }
 168
 169     static boost::optional< T > fromAny(css::uno::Any const & value)
 170     {
 171         return value.hasValue()
 172             ? boost::optional< T >(value.get< T >()) : boost::optional< T >();
 173     }
 174
 175 private:
 176     Convert(const Convert&) = delete;
 177     Convert& operator=(const Convert&) = delete;
 178
 179     Convert() = delete;
 180     ~Convert() = delete;
 181 };
 182
 183 }
 184
 185 /// A type-safe wrapper around a (non-localized) configuration property.
 186 ///
 187 /// Automatically generated headers for the various configuration properties
 188 /// derive from this template and make available its member functions to access
 189 /// each given configuration property.
 190 template< typename T, typename U > struct ConfigurationProperty
 191 {
 192     /// Get the read-only status of the given (non-localized) configuration
 193     /// property.
 194     static bool isReadOnly(
 195         css::uno::Reference<css::uno::XComponentContext> const & context
 196             = comphelper::getProcessComponentContext())
 197     {
 198         return detail::ConfigurationWrapper::get(context).isReadOnly(T::path());
 199     }
 200
 201     /// Get the value of the given (non-localized) configuration property.
 202     ///
 203     /// For nillable properties, U is of type boost::optional<U'>.
 204     static U get(
 205         css::uno::Reference< css::uno::XComponentContext >
 206             const & context = comphelper::getProcessComponentContext())
 207     {
 208         // Folding this into one statement causes a bogus error at least with
 209         // Red Hat GCC 4.6.2-1:
 210         css::uno::Any a(
 211             detail::ConfigurationWrapper::get(context).getPropertyValue(
 212                 T::path()));
 213         return detail::Convert< U >::fromAny(a);
 214     }
 215
 216     /// Set the value of the given (non-localized) configuration property, via a
 217     /// given changes batch.
 218     ///
 219     /// For nillable properties, U is of type boost::optional<U'>.
 220     static void set(
 221         U const & value,
 222         std::shared_ptr< ConfigurationChanges > const & batch)
 223     {
 224         comphelper::detail::ConfigurationWrapper::setPropertyValue(
 225             batch, T::path(), detail::Convert< U >::toAny(value));
 226     }
 227
 228 private:
 229     ConfigurationProperty(const ConfigurationProperty&) = delete;
 230     ConfigurationProperty& operator=(const ConfigurationProperty&) = delete;
 231
 232     ConfigurationProperty() = delete;
 233     ~ConfigurationProperty() = delete;
 234 };
 235
 236 /// A type-safe wrapper around a localized configuration property.
 237 ///
 238 /// Automatically generated headers for the various localized configuration
 239 /// properties derive from this template and make available its member functions
 240 /// to access each given localized configuration property.
 241 template< typename T, typename U > struct ConfigurationLocalizedProperty
 242 {
 243     /// Get the value of the given localized configuration property, for the
 244     /// locale currently set at the
 245     /// com.sun.star.configuration.theDefaultProvider.
 246     ///
 247     /// For nillable properties, U is of type boost::optional<U'>.
 248     static U get(
 249         css::uno::Reference< css::uno::XComponentContext >
 250             const & context = comphelper::getProcessComponentContext())
 251     {
 252         // Folding this into one statement causes a bogus error at least with
 253         // Red Hat GCC 4.6.2-1:
 254         css::uno::Any a(
 255             detail::ConfigurationWrapper::get(context).
 256             getLocalizedPropertyValue(T::path()));
 257         return detail::Convert< U >::fromAny(a);
 258     }
 259
 260     /// Set the value of the given localized configuration property, for the
 261     /// locale currently set at the
 262     /// com.sun.star.configuration.theDefaultProvider, via a given changes
 263     /// batch.
 264     ///
 265     /// For nillable properties, U is of type boost::optional<U'>.
 266     static void set(
 267         U const & value,
 268         std::shared_ptr< ConfigurationChanges > const & batch)
 269     {
 270         comphelper::detail::ConfigurationWrapper::setLocalizedPropertyValue(
 271             batch, T::path(), detail::Convert< U >::toAny(value));
 272     }
 273
 274 private:
 275     ConfigurationLocalizedProperty(const ConfigurationLocalizedProperty&) = delete;
 276     ConfigurationLocalizedProperty& operator=(const ConfigurationLocalizedProperty&) = delete;
 277
 278     ConfigurationLocalizedProperty() = delete;
 279     ~ConfigurationLocalizedProperty() = delete;
 280 };
 281
 282 /// A type-safe wrapper around a configuration group.
 283 ///
 284 /// Automatically generated headers for the various configuration groups derive
 285 /// from this template and make available its member functions to access each
 286 /// given configuration group.
 287 template< typename T > struct ConfigurationGroup {
 288     /// Get read-only access to the given configuration group.
 289     static css::uno::Reference<
 290         css::container::XHierarchicalNameAccess >
 291     get(css::uno::Reference< css::uno::XComponentContext >
 292             const & context = comphelper::getProcessComponentContext())
 293     {
 294         return detail::ConfigurationWrapper::get(context).getGroupReadOnly(
 295             T::path());
 296     }
 297
 298     /// Get read/write access to the given configuration group, storing any
 299     /// modifications via the given changes batch.
 300     static css::uno::Reference<
 301         css::container::XHierarchicalNameReplace >
 302     get(std::shared_ptr< ConfigurationChanges > const & batch)
 303     {
 304         return comphelper::detail::ConfigurationWrapper::getGroupReadWrite(
 305             batch, T::path());
 306     }
 307
 308 private:
 309     ConfigurationGroup(const ConfigurationGroup&) = delete;
 310     ConfigurationGroup& operator=(const ConfigurationGroup&) = delete;
 311
 312     ConfigurationGroup() = delete;
 313     ~ConfigurationGroup() = delete;
 314 };
 315
 316 /// A type-safe wrapper around a configuration set.
 317 ///
 318 /// Automatically generated headers for the various configuration sets derive
 319 /// from this template and make available its member functions to access each
 320 /// given configuration set.
 321 template< typename T > struct ConfigurationSet {
 322     /// Get read-only access to the given configuration set.
 323     static
 324     css::uno::Reference< css::container::XNameAccess >
 325     get(css::uno::Reference< css::uno::XComponentContext >
 326             const & context = comphelper::getProcessComponentContext())
 327     {
 328         return detail::ConfigurationWrapper::get(context).getSetReadOnly(
 329             T::path());
 330     }
 331
 332     /// Get read/write access to the given configuration set, storing any
 333     /// modifications via the given changes batch.
 334     static
 335     css::uno::Reference< css::container::XNameContainer >
 336     get(std::shared_ptr< ConfigurationChanges > const & batch)
 337     {
 338         return comphelper::detail::ConfigurationWrapper::getSetReadWrite(
 339             batch, T::path());
 340     }
 341
 342 private:
 343     ConfigurationSet(const ConfigurationSet&) = delete;
 344     ConfigurationSet& operator=(const ConfigurationSet&) = delete;
 345
 346     ConfigurationSet() = delete;
 347     ~ConfigurationSet() = delete;
 348 };
 349
 350 }
 351
 352 #endif
 353
 354 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */