unotools/source/config/configvaluecontainer.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 <sal/log.hxx>
  23 #include <unotools/configvaluecontainer.hxx>
  24 #include <unotools/confignode.hxx>
  25 #include <uno/data.h>
  26 #include <algorithm>
  27 #include <utility>
  28 #include <vector>
  29
  30 namespace utl
  31 {
  32
  33     using namespace ::com::sun::star::uno;
  34
  35     //= NodeValueAccessor
  36
  37     namespace {
  38
  39     enum class LocationType
  40     {
  41         SimplyObjectInstance,
  42         Unbound
  43     };
  44
  45     }
  46
  47     struct NodeValueAccessor
  48     {
  49     private:
  50         OUString            sRelativePath;      // the relative path of the node
  51         LocationType        eLocationType;      // the type of location where the value is stored
  52         void*               pLocation;          // the pointer to the location
  53         Type                aDataType;          // the type object pointed to by pLocation
  54
  55     public:
  56         explicit NodeValueAccessor( OUString _aNodePath );
  57
  58         void bind( void* _pLocation, const Type& _rType );
  59
  60         bool                    isBound( ) const        { return ( LocationType::Unbound != eLocationType ) && ( nullptr != pLocation ); }
  61         const OUString&  getPath( ) const        { return sRelativePath; }
  62         LocationType            getLocType( ) const     { return eLocationType; }
  63         void*                   getLocation( ) const    { return pLocation; }
  64         const Type&             getDataType( ) const    { return aDataType; }
  65
  66         bool operator == ( const NodeValueAccessor& rhs ) const;
  67     };
  68
  69     NodeValueAccessor::NodeValueAccessor( OUString _aNodePath )
  70         :sRelativePath(std::move( _aNodePath ))
  71         ,eLocationType( LocationType::Unbound )
  72         ,pLocation( nullptr )
  73     {
  74     }
  75
  76     bool NodeValueAccessor::operator == ( const NodeValueAccessor& rhs ) const
  77     {
  78         return  (   sRelativePath   ==  rhs.sRelativePath   )
  79             &&  (   eLocationType   ==  rhs.eLocationType   )
  80             &&  (   pLocation       ==  rhs.pLocation       );
  81     }
  82
  83     void NodeValueAccessor::bind( void* _pLocation, const Type& _rType )
  84     {
  85         SAL_WARN_IF(isBound(), "unotools.config", "NodeValueAccessor::bind: already bound!");
  86
  87         eLocationType = LocationType::SimplyObjectInstance;
  88         pLocation = _pLocation;
  89         aDataType = _rType;
  90     }
  91
  92     static
  93     void lcl_copyData( const NodeValueAccessor& _rAccessor, const Any& _rData, std::mutex& _rMutex )
  94     {
  95         std::unique_lock aGuard( _rMutex );
  96
  97         SAL_WARN_IF(!_rAccessor.isBound(), "unotools.config", "::utl::lcl_copyData: invalid accessor!");
  98         switch ( _rAccessor.getLocType() )
  99         {
 100             case LocationType::SimplyObjectInstance:
 101             {
 102                 if ( _rData.hasValue() )
 103                 {
 104                     // assign the value
 105                     bool bSuccess = uno_type_assignData(
 106                         _rAccessor.getLocation(), _rAccessor.getDataType().getTypeLibType(),
 107                         const_cast< void* >( _rData.getValue() ), _rData.getValueType().getTypeLibType(),
 108                         cpp_queryInterface, cpp_acquire, cpp_release
 109                     );
 110                     SAL_WARN_IF(!bSuccess, "unotools.config",
 111                         "::utl::lcl_copyData( Accessor, Any ): could not assign the data (node path: \"" << _rAccessor.getPath() << "\"");
 112                 }
 113                 else {
 114                     SAL_INFO("unotools.config", "::utl::lcl_copyData: NULL value lost!");
 115                 }
 116             }
 117             break;
 118             default:
 119                 break;
 120         }
 121     }
 122
 123     static
 124     void lcl_copyData( Any& _rData, const NodeValueAccessor& _rAccessor, std::mutex& _rMutex )
 125     {
 126         std::unique_lock aGuard( _rMutex );
 127
 128         SAL_WARN_IF(!_rAccessor.isBound(), "unotools.config", "::utl::lcl_copyData: invalid accessor!" );
 129         switch ( _rAccessor.getLocType() )
 130         {
 131             case LocationType::SimplyObjectInstance:
 132                 // a simple setValue...
 133                 _rData.setValue( _rAccessor.getLocation(), _rAccessor.getDataType() );
 134                 break;
 135
 136             default:
 137                 break;
 138         }
 139     }
 140
 141     //= functors on NodeValueAccessor instances
 142
 143     namespace {
 144
 145     /// base class for functors synchronizing between exchange locations and config sub nodes
 146     struct SubNodeAccess
 147     {
 148     protected:
 149         const OConfigurationNode&   m_rRootNode;
 150         std::mutex&                 m_rMutex;
 151
 152     public:
 153         SubNodeAccess( const OConfigurationNode& _rRootNode, std::mutex& _rMutex )
 154             :m_rRootNode( _rRootNode )
 155             ,m_rMutex( _rMutex )
 156         {
 157         }
 158     };
 159
 160     struct UpdateFromConfig : public SubNodeAccess
 161     {
 162     public:
 163         UpdateFromConfig( const OConfigurationNode& _rRootNode, std::mutex& _rMutex ) : SubNodeAccess( _rRootNode, _rMutex ) { }
 164
 165         void operator() ( NodeValueAccessor const & _rAccessor )
 166         {
 167             ::utl::lcl_copyData( _rAccessor, m_rRootNode.getNodeValue( _rAccessor.getPath( ) ), m_rMutex );
 168         }
 169     };
 170
 171     struct UpdateToConfig : public SubNodeAccess
 172     {
 173     public:
 174         UpdateToConfig( const OConfigurationNode& _rRootNode, std::mutex& _rMutex ) : SubNodeAccess( _rRootNode, _rMutex ) { }
 175
 176         void operator() ( NodeValueAccessor const & _rAccessor )
 177         {
 178             Any aNewValue;
 179             lcl_copyData( aNewValue, _rAccessor, m_rMutex );
 180             m_rRootNode.setNodeValue( _rAccessor.getPath( ), aNewValue );
 181         }
 182     };
 183
 184     }
 185
 186     //= OConfigurationValueContainerImpl
 187
 188     struct OConfigurationValueContainerImpl
 189     {
 190         Reference< XComponentContext >          xORB;           // the service factory
 191         std::mutex&                             rMutex;         // the mutex for accessing the data containers
 192         OConfigurationTreeRoot                  aConfigRoot;    // the configuration node we're accessing
 193
 194         std::vector<NodeValueAccessor>          aAccessors;     // the accessors to the node values
 195
 196         OConfigurationValueContainerImpl( const Reference< XComponentContext >& _rxORB, std::mutex& _rMutex )
 197             :xORB( _rxORB )
 198             ,rMutex( _rMutex )
 199         {
 200         }
 201     };
 202
 203     //= OConfigurationValueContainer
 204
 205     OConfigurationValueContainer::OConfigurationValueContainer(
 206             const Reference< XComponentContext >& _rxORB, std::mutex& _rAccessSafety,
 207             const OUString& _rConfigLocation, const sal_Int32 _nLevels )
 208         :m_pImpl( new OConfigurationValueContainerImpl( _rxORB, _rAccessSafety ) )
 209     {
 210         implConstruct( _rConfigLocation, _nLevels );
 211     }
 212
 213     OConfigurationValueContainer::~OConfigurationValueContainer()
 214     {
 215     }
 216
 217     void OConfigurationValueContainer::implConstruct( const OUString& _rConfigLocation,
 218         const sal_Int32 _nLevels )
 219     {
 220         SAL_WARN_IF(m_pImpl->aConfigRoot.isValid(), "unotools.config", "OConfigurationValueContainer::implConstruct: already initialized!");
 221
 222         // create the configuration node we're about to work with
 223         m_pImpl->aConfigRoot = OConfigurationTreeRoot::createWithComponentContext(
 224             m_pImpl->xORB,
 225             _rConfigLocation,
 226             _nLevels
 227         );
 228         SAL_WARN_IF(!m_pImpl->aConfigRoot.isValid(), "unotools.config",
 229             "Could not access the configuration node located at " << _rConfigLocation);
 230     }
 231
 232     void OConfigurationValueContainer::registerExchangeLocation( const OUString& _rRelativePath,
 233         void* _pContainer, const Type& _rValueType )
 234     {
 235         // checks...
 236         SAL_WARN_IF(!_pContainer, "unotools.config",
 237             "OConfigurationValueContainer::registerExchangeLocation: invalid container location!");
 238         SAL_WARN_IF(!( (TypeClass_CHAR      ==  _rValueType.getTypeClass( ) )
 239                 ||  (   TypeClass_BOOLEAN   ==  _rValueType.getTypeClass( ) )
 240                 ||  (   TypeClass_BYTE      ==  _rValueType.getTypeClass( ) )
 241                 ||  (   TypeClass_SHORT     ==  _rValueType.getTypeClass( ) )
 242                 ||  (   TypeClass_LONG      ==  _rValueType.getTypeClass( ) )
 243                 ||  (   TypeClass_DOUBLE    ==  _rValueType.getTypeClass( ) )
 244                 ||  (   TypeClass_STRING    ==  _rValueType.getTypeClass( ) )
 245                 ||  (   TypeClass_SEQUENCE  ==  _rValueType.getTypeClass( ) )),
 246             "unotools.config",
 247             "OConfigurationValueContainer::registerExchangeLocation: invalid type!" );
 248
 249         // build an accessor for this container
 250         NodeValueAccessor aNewAccessor( _rRelativePath );
 251         aNewAccessor.bind( _pContainer, _rValueType );
 252
 253         // insert it into our structure
 254         implRegisterExchangeLocation( aNewAccessor );
 255     }
 256
 257     void OConfigurationValueContainer::read( )
 258     {
 259         std::for_each(
 260             m_pImpl->aAccessors.begin(),
 261             m_pImpl->aAccessors.end(),
 262             UpdateFromConfig( m_pImpl->aConfigRoot, m_pImpl->rMutex )
 263         );
 264     }
 265
 266     void OConfigurationValueContainer::commit()
 267     {
 268         // write the current values in the exchange locations
 269         std::for_each(
 270             m_pImpl->aAccessors.begin(),
 271             m_pImpl->aAccessors.end(),
 272             UpdateToConfig( m_pImpl->aConfigRoot, m_pImpl->rMutex )
 273         );
 274
 275         // commit the changes done
 276         m_pImpl->aConfigRoot.commit( );
 277     }
 278
 279     void OConfigurationValueContainer::implRegisterExchangeLocation( const NodeValueAccessor& _rAccessor )
 280     {
 281         // some checks
 282         SAL_WARN_IF(m_pImpl->aConfigRoot.isValid() && !m_pImpl->aConfigRoot.hasByHierarchicalName(_rAccessor.getPath()),
 283             "unotools.config",
 284             "OConfigurationValueContainer::implRegisterExchangeLocation: invalid relative path!" );
 285
 286         // another check (should be the first container for this node)
 287         SAL_WARN_IF(!(m_pImpl->aAccessors.end() == ::std::find(
 288             m_pImpl->aAccessors.begin(),
 289             m_pImpl->aAccessors.end(),
 290             _rAccessor)),
 291             "unotools.config",
 292             "OConfigurationValueContainer::implRegisterExchangeLocation: already registered a container for this subnode!" );
 293
 294         // remember the accessor
 295         m_pImpl->aAccessors.push_back( _rAccessor );
 296
 297         // and initially fill the value
 298         lcl_copyData( _rAccessor, m_pImpl->aConfigRoot.getNodeValue( _rAccessor.getPath() ), m_pImpl->rMutex );
 299     }
 300
 301 }   // namespace utl
 302
 303 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */