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