framework/source/jobs/configaccess.cxx

   1     /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_framework.hxx"
  30
  31 //________________________________
  32 //  my own includes
  33 #include <jobs/configaccess.hxx>
  34 #include <threadhelp/readguard.hxx>
  35 #include <threadhelp/writeguard.hxx>
  36 #include <threadhelp/resetableguard.hxx>
  37 #include <general.h>
  38 #include <services.h>
  39
  40 //________________________________
  41 //  interface includes
  42 #include <com/sun/star/beans/XPropertySet.hpp>
  43 #include <com/sun/star/beans/XMultiHierarchicalPropertySet.hpp>
  44 #include <com/sun/star/container/XNameAccess.hpp>
  45 #include <com/sun/star/beans/PropertyValue.hpp>
  46 #include <com/sun/star/util/XChangesBatch.hpp>
  47
  48 //________________________________
  49 //  includes of other projects
  50 #include <unotools/configpathes.hxx>
  51 #include <rtl/ustrbuf.hxx>
  52
  53 //________________________________
  54 //  namespace
  55
  56 namespace framework{
  57
  58 //________________________________
  59 //  non exported const
  60
  61 //________________________________
  62 //  non exported definitions
  63
  64 //________________________________
  65 //  declarations
  66
  67 //________________________________
  68 /**
  69     @short  open the configuration of this job
  70     @descr  We open the configuration of this job only. Not the whole package or the whole
  71             job set. We are interested on our own properties only.
  72             We set the opened configuration access as our member. So any following method,
  73             which needs cfg access, can use it. That prevent us against multiple open/close requests.
  74             But you can use this method to upgrade an already opened configuration too.
  75
  76     @param  eMode
  77                 force opening of the configuration access in readonly or in read/write mode
  78  */
  79 ConfigAccess::ConfigAccess( /*IN*/ const css::uno::Reference< css::lang::XMultiServiceFactory >& xSMGR ,
  80                             /*IN*/ const ::rtl::OUString&                                        sRoot )
  81     : ThreadHelpBase(          )
  82     , m_xSMGR       ( xSMGR    )
  83     , m_sRoot       ( sRoot    )
  84     , m_eMode       ( E_CLOSED )
  85 {
  86 }
  87
  88 //________________________________
  89 /**
  90     @short  last chance to close an open configuration access point
  91     @descr  In case our user forgot to close this configuration point
  92             in the right way, normaly he will run into some trouble -
  93             e.g. losing data.
  94  */
  95 ConfigAccess::~ConfigAccess()
  96 {
  97     close();
  98 }
  99
 100 //________________________________
 101 /**
 102     @short  return the internal mode of this instance
 103     @descr  May be the outside user need any information about successfully opened
 104             or closed config access point objects. He can control the internal mode to do so.
 105
 106     @return The internal open state of this object.
 107  */
 108 ConfigAccess::EOpenMode ConfigAccess::getMode() const
 109 {
 110     /* SAFE { */
 111     ReadGuard aReadLock(m_aLock);
 112     return m_eMode;
 113     /* } SAFE */
 114 }
 115
 116 //________________________________
 117 /**
 118     @short  open the configuration access in the specified mode
 119     @descr  We set the opened configuration access as our member. So any following method,
 120             which needs cfg access, can use it. That prevent us against multiple open/close requests.
 121             But you can use this method to upgrade an already opened configuration too.
 122             It's possible to open a config access in READONLY mode first and "open" it at a second
 123             time within the mode READWRITE. Then we will upgrade it. Dowgrade will be possible too.
 124
 125             But note: closing will be done explicitly by calling method close() ... not by
 126             downgrading with mode CLOSED!
 127
 128     @param  eMode
 129                 force (re)opening of the configuration access in readonly or in read/write mode
 130  */
 131 void ConfigAccess::open( /*IN*/ EOpenMode eMode )
 132 {
 133     /* SAFE { */
 134     // We must lock the whole method to be shure, that nobody
 135     // outside uses our internal member m_xAccess!
 136     WriteGuard aWriteLock(m_aLock);
 137
 138     // check if configuration is already open in the right mode.
 139     // By the way: Don't allow closing by using this method!
 140     if (
 141         (eMode  !=E_CLOSED) &&
 142         (m_eMode!=eMode   )
 143        )
 144     {
 145         // We have to close the old access point without any question here.
 146         // It will be open again using the new mode.
 147         // can be called without checks! It does the checks by itself ...
 148         // e.g. for already closed or not opened configuration.
 149         // Flushing of all made changes will be done here too.
 150         close();
 151
 152         // create the configuration provider, which provides sub access points
 153         css::uno::Reference< css::lang::XMultiServiceFactory > xConfigProvider(m_xSMGR->createInstance(SERVICENAME_CFGPROVIDER), css::uno::UNO_QUERY);
 154         if (xConfigProvider.is())
 155         {
 156             css::beans::PropertyValue aParam;
 157             aParam.Name    = DECLARE_ASCII("nodepath");
 158             aParam.Value <<= m_sRoot;
 159
 160             css::uno::Sequence< css::uno::Any > lParams(1);
 161             lParams[0] <<= aParam;
 162
 163             // open it
 164             try
 165             {
 166                 if (eMode==E_READONLY)
 167                     m_xConfig = xConfigProvider->createInstanceWithArguments(SERVICENAME_CFGREADACCESS  , lParams);
 168                 else
 169                 if (eMode==E_READWRITE)
 170                     m_xConfig = xConfigProvider->createInstanceWithArguments(SERVICENAME_CFGUPDATEACCESS, lParams);
 171             }
 172             catch(css::uno::Exception& ex)
 173             {
 174                 (void) ex; // avoid warning
 175                 LOG_WARNING("open config ...", U2B(ex.Message))
 176             }
 177
 178             m_eMode = E_CLOSED;
 179             if (m_xConfig.is())
 180                 m_eMode = eMode;
 181         }
 182     }
 183
 184     aWriteLock.unlock();
 185     /* } SAFE */
 186 }
 187
 188 //________________________________
 189 /**
 190     @short  close the internal opened configuration access and flush all changes
 191     @descr  It checks, if the given access is valid and react in the right way.
 192             It flushes all changes ... so nobody else must know this state.
 193  */
 194 void ConfigAccess::close()
 195 {
 196     /* SAFE { */
 197     // Lock the whole method, to be shure that nobody else uses our internal members
 198     // during this time.
 199     WriteGuard aWriteLock(m_aLock);
 200
 201     // check already closed configuration
 202     if (m_xConfig.is())
 203     {
 204         css::uno::Reference< css::util::XChangesBatch > xFlush(m_xConfig, css::uno::UNO_QUERY);
 205         if (xFlush.is())
 206             xFlush->commitChanges();
 207         m_xConfig = css::uno::Reference< css::uno::XInterface >();
 208         m_eMode   = E_CLOSED;
 209     }
 210
 211     aWriteLock.unlock();
 212     /* } SAFE */
 213 }
 214
 215 //________________________________
 216 /**
 217     @short  provides an access to the internal wrapped configuration access
 218     @descr  It's not allowed to safe this c++ (!) reference outside. You have
 219             to use it directly. Further you must use our public lock member m_aLock
 220             to synchronize your code with our internal structures and our interface
 221             methods. Acquire it before you call cfg() and release it afterwards immediatly.
 222
 223             E.g.:   ConfigAccess aAccess(...);
 224                     ReadGuard aReadLock(aAccess.m_aLock);
 225                     Reference< XPropertySet > xSet(aAccess.cfg(), UNO_QUERY);
 226                     Any aProp = xSet->getPropertyValue("...");
 227                     aReadLock.unlock();
 228
 229     @attention  During this time it's not allowed to call the methods open() or close()!
 230                 Otherwhise you will change your own referenced config access. Anything will
 231                 be possible then.
 232
 233     @return A c++(!) reference to the uno instance of the configuration access point.
 234  */
 235 const css::uno::Reference< css::uno::XInterface >& ConfigAccess::cfg()
 236 {
 237     // must be synchronized from outside!
 238     // => no lock here ...
 239     return m_xConfig;
 240 }
 241
 242 } // namespace framework