configmgr/source/localbe/localfilelayer.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: localfilelayer.hxx,v $
  10  * $Revision: 1.13 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #ifndef CONFIGMGR_LOCALBE_LOCALFILELAYER_HXX_
  32 #define CONFIGMGR_LOCALBE_LOCALFILELAYER_HXX_
  33
  34 #include "propertysethelper.hxx"
  35 #include <com/sun/star/configuration/backend/XUpdatableLayer.hpp>
  36 #include <com/sun/star/configuration/backend/XCompositeLayer.hpp>
  37 #include <com/sun/star/util/XTimeStamped.hpp>
  38 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  39 #include <cppuhelper/implbase3.hxx>
  40 #include <cppuhelper/implbase2.hxx>
  41 #include <cppuhelper/implbase1.hxx>
  42
  43 #ifndef VECTOR_INCLUDED_
  44 #define VECTOR_INCLUDED_
  45 #include <vector>
  46 #endif // VECTOR_INCLUDED_
  47
  48 namespace configmgr { namespace localbe {
  49
  50 namespace css = com::sun::star ;
  51 namespace uno = css::uno ;
  52 namespace lang = css::lang ;
  53 namespace util = css::util ;
  54 namespace backend = css::configuration::backend ;
  55
  56 /**
  57   Basic Implementation of the readonly XLayer interfaces for a local file access.
  58   The read data is accessible through a canned implementation of an XML parser.
  59   The layer is defined by the URL of the file containing its contents.
  60   */
  61 class BasicLocalFileLayer
  62 {
  63 protected :
  64     /**
  65       Constructor providing the base directory and the
  66       file subpath describing the file to access.
  67       An optional resource directory provides the location
  68       of sublayers of the component.
  69
  70       @param xFactory   service factory used to access canned services
  71       @param aComponentFile path describing the component file
  72       */
  73     BasicLocalFileLayer(
  74             const uno::Reference<lang::XMultiServiceFactory>& xFactory,
  75             const rtl::OUString& aComponentFile) ;
  76     /** Destructor */
  77     ~BasicLocalFileLayer() ;
  78
  79 protected :
  80     /**
  81       Describes the contents of a particular file to a handler.
  82
  83       @param xHandler   handler to describe the data to
  84       @param aFileUrl   URL of the file
  85       @throws com::sun::star::configuration::backend::MalformedDataException
  86               if the file contains invalid data.
  87       @throws com::sun::star::lang::NullPointerException
  88               if pContext is NULL.
  89       @throws com::sun::star::lang::WrappedTargetException
  90               if an error occurs while accessing the data.
  91       */
  92     void readData(backend::XLayer * pContext,
  93                   const uno::Reference<backend::XLayerHandler>& xHandler,
  94                   const rtl::OUString& aFileUrl)
  95         throw (backend::MalformedDataException, lang::NullPointerException,
  96                lang::WrappedTargetException, uno::RuntimeException);
  97
  98     /**
  99       Returns an object that can be used to write a layer.
 100       */
 101     uno::Reference<backend::XLayerHandler> createLayerWriter();
 102
 103 public:
 104     /**
 105       Returns a timestamp associated to a file defined by its URL.
 106
 107       @param aFileUrl   URL of the file
 108       @return   timestamp
 109       */
 110     static rtl::OUString getTimestamp(const rtl::OUString& aFileUrl) ;
 111
 112     rtl::OUString const & getFileUrl() const { return mFileUrl; };
 113
 114 private :
 115     /** Service factory */
 116     uno::Reference<lang::XMultiServiceFactory> const mFactory ;
 117     /** URL of the file being accessed */
 118     rtl::OUString const mFileUrl ;
 119     /** XLayer implementation used for readData */
 120     uno::Reference<backend::XLayer> mLayerReader ;
 121
 122 } ;
 123
 124 // provides properties for file layers
 125 class LayerPropertyHelper : public apihelper::PropertySetHelper
 126 {
 127 protected:
 128     LayerPropertyHelper(){};
 129     virtual ~LayerPropertyHelper(){};
 130
 131 protected:
 132     virtual rtl::OUString const & getLayerUrl() const = 0;
 133
 134 protected:
 135     // cppu::OPropertySetHelper
 136     virtual cppu::IPropertyArrayHelper * SAL_CALL newInfoHelper();
 137
 138     virtual void SAL_CALL setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const uno::Any& rValue )
 139             throw (uno::Exception);
 140
 141     using PropertySetHelper::getFastPropertyValue;
 142     virtual void SAL_CALL getFastPropertyValue( uno::Any& rValue, sal_Int32 nHandle ) const;
 143
 144 };
 145
 146 /**
 147   Implementation of the readonly XLayer interfaces for a local file access.
 148   The read data is accessible through a canned implementation of
 149   an XML parser.
 150   The layer is defined by the URL of the file containing its
 151   contents.
 152   */
 153 class SimpleLocalFileLayer  : public BasicLocalFileLayer
 154                              , public cppu::ImplInheritanceHelper2< LayerPropertyHelper,
 155                                                                     backend::XLayer,
 156                                                                     util::XTimeStamped>
 157 {
 158 public :
 159     /**
 160       Constructor providing the base directory and the
 161       file subpath describing the file to access.
 162       An optional resource directory provides the location
 163       of sublayers of the component.
 164
 165       @param xFactory   service factory used to access canned services
 166       @param aComponentFile URL describing the component file
 167       */
 168     SimpleLocalFileLayer(
 169             const uno::Reference<lang::XMultiServiceFactory>& xFactory,
 170             const rtl::OUString& aComponentFile) ;
 171     /**
 172       Constructor providing the base directory and the
 173       file subpath describing the file to access.
 174       An optional resource directory provides the location
 175       of sublayers of the component.
 176
 177       @param xFactory   service factory used to access canned services
 178       @param aBaseDir   base directory
 179       @param aComponent subpath describing the component file
 180       */
 181     SimpleLocalFileLayer(
 182             const uno::Reference<lang::XMultiServiceFactory>& xFactory,
 183             const rtl::OUString& aBaseDir,
 184             const rtl::OUString& aComponent) ;
 185
 186     /** Destructor */
 187     ~SimpleLocalFileLayer() ;
 188
 189     // XLayer
 190     using BasicLocalFileLayer::readData;
 191     virtual void SAL_CALL readData(
 192             const uno::Reference<backend::XLayerHandler>& xHandler)
 193         throw (backend::MalformedDataException, lang::NullPointerException,
 194                lang::WrappedTargetException, uno::RuntimeException);
 195
 196     // XTimeStamped
 197     virtual rtl::OUString SAL_CALL getTimestamp()
 198         throw (uno::RuntimeException);
 199
 200 protected:
 201     virtual rtl::OUString const & getLayerUrl() const
 202     { return getFileUrl(); }
 203 } ;
 204
 205 /**
 206   Implementation of the XUpdatableLayer
 207   interface for a local file access.
 208   The read data is accessible through a canned implementation of
 209   an XML parser, and the write data is defined through a canned
 210   implementation of an XML writer.
 211   The layer is defined by the URL of the file containing its
 212   contents, and that file will be either read or updated by
 213   the access to the handlers.
 214   The timestamp is refreshed on each read operation only.
 215   */
 216 class FlatLocalFileLayer : public BasicLocalFileLayer
 217                          , public cppu::ImplInheritanceHelper2< LayerPropertyHelper,
 218                                                                 backend::XUpdatableLayer,
 219                                                                 util::XTimeStamped>
 220 {
 221 public :
 222     /**
 223       Constructor providing the base directory and the
 224       file subpath describing the file to access.
 225
 226       @param xFactory   service factory used to access canned services
 227       @param aBaseDir   base directory
 228       @param aComponent subpath describing the component file
 229       */
 230     FlatLocalFileLayer(
 231             const uno::Reference<lang::XMultiServiceFactory>& xFactory,
 232             const rtl::OUString& aBaseDir,
 233             const rtl::OUString& aComponent) ;
 234     /** Destructor */
 235     ~FlatLocalFileLayer(void) ;
 236
 237     // XLayer
 238     using BasicLocalFileLayer::readData;
 239     virtual void SAL_CALL readData(
 240             const uno::Reference<backend::XLayerHandler>& xHandler)
 241         throw (backend::MalformedDataException, lang::NullPointerException,
 242                lang::WrappedTargetException, uno::RuntimeException);
 243
 244     // XUpdatableLayer
 245     virtual void SAL_CALL replaceWith(
 246             const uno::Reference<backend::XLayer>& aNewLayer)
 247         throw (backend::MalformedDataException, lang::NullPointerException,
 248                lang::WrappedTargetException, uno::RuntimeException);
 249
 250     // XTimeStamped
 251     virtual rtl::OUString SAL_CALL getTimestamp()
 252         throw (uno::RuntimeException);
 253
 254 protected:
 255     virtual rtl::OUString const & getLayerUrl() const
 256     { return getFileUrl(); }
 257
 258 private :
 259     /** XLayerHandler implementation for getWriteHandler */
 260     uno::Reference<backend::XLayerHandler> mLayerWriter ;
 261
 262 } ;
 263
 264 /**
 265   Implementation of the XCompositeLayer
 266   interface for a local file access.
 267   The read data is accessible through a canned implementation of
 268   an XML parser.
 269   The layer is defined by the URL of the file containing its
 270   contents, and that file will be either read or updated by
 271   the access to the handlers.
 272   The timestamp is refreshed on each read operation only.
 273   */
 274 class BasicCompositeLocalFileLayer : public BasicLocalFileLayer
 275 {
 276 protected:
 277     /**
 278       Constructor providing the base directory and the
 279       file subpath describing the file to access.
 280       An resource directory provides the location
 281       of sublayers of the component.
 282
 283       @param xFactory   service factory used to access canned services
 284       @param aComponent path describing the component file
 285       */
 286     BasicCompositeLocalFileLayer(
 287             const uno::Reference<lang::XMultiServiceFactory>& xFactory,
 288             const rtl::OUString& aComponent) ;
 289
 290     // XCompositeLayer helpers
 291     uno::Sequence<rtl::OUString> SAL_CALL listSubLayerIds()
 292         throw (lang::WrappedTargetException, uno::RuntimeException)
 293     { return mSubLayers ; }
 294
 295     void SAL_CALL readSubLayerData(
 296             backend::XCompositeLayer * context,
 297             const uno::Reference<backend::XLayerHandler>& xHandler,
 298             const rtl::OUString& aSubLayerId)
 299         throw (backend::MalformedDataException, lang::NullPointerException,
 300                lang::WrappedTargetException, lang::IllegalArgumentException,
 301                uno::RuntimeException);
 302
 303     /**
 304       Fills the list of available sublayers.
 305
 306       @param aResDir    resource directory containing potential sublayers
 307       @param aComponent component subpath
 308       */
 309     void fillSubLayerLists(const std::vector<rtl::OUString>& aSublayerDirectories,
 310                            const rtl::OUString& aComponent) ;
 311 private :
 312     /** List of available sublayers... */
 313     uno::Sequence<rtl::OUString> mSubLayers ;
 314     /** .. and the corresponding file URLs. */
 315     std::vector<rtl::OUString> mSubLayerFiles ;
 316
 317 };
 318
 319 /**
 320   Implementation of the XCompositeLayer
 321   interface for a local file access.
 322   The read data is accessible through a canned implementation of
 323   an XML parser.
 324   The layer is defined by the URL of the file containing its
 325   contents, and that file will be either read or updated by
 326   the access to the handlers.
 327   The timestamp is refreshed on each read operation only.
 328   */
 329 class CompositeLocalFileLayer : public BasicCompositeLocalFileLayer
 330                      , public cppu::WeakImplHelper1< backend::XCompositeLayer>
 331 {
 332 public :
 333     /**
 334       Constructor providing the base directory and the
 335       file subpath describing the file to access.
 336       An resource directory provides the location
 337       of sublayers of the component.
 338
 339       @param xFactory   service factory used to access canned services
 340       @param aBaseDir   base directory
 341       @param aComponent subpath describing the component file
 342       @param aResDir    resource directory, if empty it is
 343                         assumed the layer does not have sublayers.
 344       */
 345     CompositeLocalFileLayer(
 346             const uno::Reference<lang::XMultiServiceFactory>& xFactory,
 347             const rtl::OUString& aComponent,
 348             const std::vector<rtl::OUString>& aSublayerDirectories) ;
 349     /** Destructor */
 350     ~CompositeLocalFileLayer(void) ;
 351     // XLayer
 352     using BasicCompositeLocalFileLayer::readData;
 353     virtual void SAL_CALL readData(
 354             const uno::Reference<backend::XLayerHandler>& xHandler)
 355         throw (backend::MalformedDataException, lang::NullPointerException,
 356                lang::WrappedTargetException, uno::RuntimeException);
 357
 358     // XCompositeLayer
 359     virtual uno::Sequence<rtl::OUString> SAL_CALL listSubLayerIds()
 360         throw (lang::WrappedTargetException, uno::RuntimeException)
 361     { return BasicCompositeLocalFileLayer::listSubLayerIds() ; }
 362
 363     using BasicCompositeLocalFileLayer::readSubLayerData;
 364     virtual void SAL_CALL readSubLayerData(
 365             const uno::Reference<backend::XLayerHandler>& xHandler,
 366             const rtl::OUString& aSubLayerId)
 367         throw (backend::MalformedDataException, lang::NullPointerException,
 368                lang::WrappedTargetException, lang::IllegalArgumentException,
 369                uno::RuntimeException);
 370
 371 private :
 372     // not implemented: warn of attempts to use this here
 373     void getFileUrl() const;
 374 } ;
 375 /**
 376   Implementation of the XUpdatableLayer and XCompositeLayer
 377   interfaces for a local file access.
 378   The read data is accessible through a canned implementation of
 379   an XML parser, and the write data is defined through a canned
 380   implementation of an XML writer.
 381   The layer is defined by the URL of the file containing its
 382   contents, and that file will be either read or updated by
 383   the access to the handlers.
 384   The timestamp is refreshed on each read operation only.
 385   */
 386 class FullCompositeLocalFileLayer : public BasicCompositeLocalFileLayer
 387                                     , public cppu::ImplInheritanceHelper3<
 388                                                     LayerPropertyHelper,
 389                                                     backend::XUpdatableLayer,
 390                                                     backend::XCompositeLayer,
 391                                                     util::XTimeStamped>
 392 {
 393 public :
 394     /**
 395       Constructor providing the base directory and the
 396       file subpath describing the file to access.
 397       An resource directory provides the location
 398       of sublayers of the component.
 399
 400       @param xFactory   service factory used to access canned services
 401       @param aBaseDir   base directory
 402       @param aComponent subpath describing the component file
 403       @param aResDir    resource directory, if empty it is
 404                         assumed the layer does not have sublayers.
 405       */
 406     FullCompositeLocalFileLayer(
 407             const uno::Reference<lang::XMultiServiceFactory>& xFactory,
 408             const rtl::OUString& aBaseDir,
 409             const rtl::OUString& aComponent,
 410             const std::vector<rtl::OUString>& aSublayerDirectories) ;
 411     /** Destructor */
 412     ~FullCompositeLocalFileLayer(void) ;
 413     // XLayer
 414     using BasicCompositeLocalFileLayer::readData;
 415     virtual void SAL_CALL readData(
 416             const uno::Reference<backend::XLayerHandler>& xHandler)
 417         throw (backend::MalformedDataException, lang::NullPointerException,
 418                lang::WrappedTargetException, uno::RuntimeException);
 419
 420     // XUpdatableLayer
 421     virtual void SAL_CALL replaceWith(
 422             const uno::Reference<backend::XLayer>& aNewLayer)
 423         throw (backend::MalformedDataException, lang::NullPointerException,
 424                lang::WrappedTargetException, uno::RuntimeException);
 425
 426     // XCompositeLayer
 427     virtual uno::Sequence<rtl::OUString> SAL_CALL listSubLayerIds()
 428         throw (lang::WrappedTargetException, uno::RuntimeException)
 429     { return BasicCompositeLocalFileLayer::listSubLayerIds() ; }
 430
 431     using BasicCompositeLocalFileLayer::readSubLayerData;
 432     virtual void SAL_CALL readSubLayerData(
 433             const uno::Reference<backend::XLayerHandler>& xHandler,
 434             const rtl::OUString& aSubLayerId)
 435         throw (backend::MalformedDataException, lang::NullPointerException,
 436                lang::WrappedTargetException, lang::IllegalArgumentException,
 437                uno::RuntimeException);
 438
 439     // XTimeStamped
 440     virtual rtl::OUString SAL_CALL getTimestamp()
 441         throw (uno::RuntimeException);
 442
 443 protected:
 444     virtual rtl::OUString const & getLayerUrl() const
 445     { return getFileUrl(); }
 446
 447 private :
 448     /** XLayerHandler implementation for getWriteHandler */
 449     uno::Reference<backend::XLayerHandler> mLayerWriter ;
 450 } ;
 451 /**
 452   Factory function to create the appropriate Flat- or Composite-
 453   LocalFileLayer for a set of parameters.
 454
 455   Arguments provide the base directory and the
 456   file subpath describing the file to access.
 457   An optional resource directory provides the location
 458   of sublayers of the component.
 459
 460   @param xFactory   service factory used to access canned services
 461   @param aBaseDir   base directory
 462   @param aComponent subpath describing the component file
 463   @param aResDir    resource directory, if empty it is
 464                     assumed the layer does not have sublayers.
 465   */
 466 uno::Reference<backend::XLayer> createReadonlyLocalFileLayer(
 467         const uno::Reference<lang::XMultiServiceFactory>& xFactory,
 468         const rtl::OUString& aBaseDir,
 469         const rtl::OUString& aComponent,
 470         const rtl::OUString& aResDir) ;
 471
 472 /**
 473   Factory function to create the appropriate Flat- or Composite-
 474   LocalFileLayer for a set of parameters.
 475
 476   Arguments provide the base directory and the
 477   file subpath describing the file to access.
 478   An optional resource directory provides the location
 479   of sublayers of the component.
 480
 481   @param xFactory   service factory used to access canned services
 482   @param aBaseDir   base directory
 483   @param aComponent subpath describing the component file
 484   @param aResDir    resource directory, if empty it is
 485                     assumed the layer does not have sublayers.
 486   */
 487 uno::Reference<backend::XUpdatableLayer> createUpdatableLocalFileLayer(
 488         const uno::Reference<lang::XMultiServiceFactory>& xFactory,
 489         const rtl::OUString& aBaseDir,
 490         const rtl::OUString& aComponent,
 491         const rtl::OUString& aResDir) ;
 492
 493 } } // configmgr.localbe
 494
 495 #endif // CONFIGMGR_LOCALBE_LOCALFILELAYER_HXX_