/************************************************************************* * * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * Copyright 2008 by Sun Microsystems, Inc. * * OpenOffice.org - a multi-platform office productivity suite * * $RCSfile: localfilelayer.hxx,v $ * $Revision: 1.13 $ * * This file is part of OpenOffice.org. * * OpenOffice.org is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License version 3 * only, as published by the Free Software Foundation. * * OpenOffice.org is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License version 3 for more details * (a copy is included in the LICENSE file that accompanied this code). * * You should have received a copy of the GNU Lesser General Public License * version 3 along with OpenOffice.org. If not, see * * for a copy of the LGPLv3 License. * ************************************************************************/ #ifndef CONFIGMGR_LOCALBE_LOCALFILELAYER_HXX_ #define CONFIGMGR_LOCALBE_LOCALFILELAYER_HXX_ #include "propertysethelper.hxx" #include #include #include #include #include #include #include #ifndef VECTOR_INCLUDED_ #define VECTOR_INCLUDED_ #include #endif // VECTOR_INCLUDED_ namespace configmgr { namespace localbe { namespace css = com::sun::star ; namespace uno = css::uno ; namespace lang = css::lang ; namespace util = css::util ; namespace backend = css::configuration::backend ; /** Basic Implementation of the readonly XLayer interfaces for a local file access. The read data is accessible through a canned implementation of an XML parser. The layer is defined by the URL of the file containing its contents. */ class BasicLocalFileLayer { protected : /** Constructor providing the base directory and the file subpath describing the file to access. An optional resource directory provides the location of sublayers of the component. @param xFactory service factory used to access canned services @param aComponentFile path describing the component file */ BasicLocalFileLayer( const uno::Reference& xFactory, const rtl::OUString& aComponentFile) ; /** Destructor */ ~BasicLocalFileLayer() ; protected : /** Describes the contents of a particular file to a handler. @param xHandler handler to describe the data to @param aFileUrl URL of the file @throws com::sun::star::configuration::backend::MalformedDataException if the file contains invalid data. @throws com::sun::star::lang::NullPointerException if pContext is NULL. @throws com::sun::star::lang::WrappedTargetException if an error occurs while accessing the data. */ void readData(backend::XLayer * pContext, const uno::Reference& xHandler, const rtl::OUString& aFileUrl) throw (backend::MalformedDataException, lang::NullPointerException, lang::WrappedTargetException, uno::RuntimeException); /** Returns an object that can be used to write a layer. */ uno::Reference createLayerWriter(); public: /** Returns a timestamp associated to a file defined by its URL. @param aFileUrl URL of the file @return timestamp */ static rtl::OUString getTimestamp(const rtl::OUString& aFileUrl) ; rtl::OUString const & getFileUrl() const { return mFileUrl; }; private : /** Service factory */ uno::Reference const mFactory ; /** URL of the file being accessed */ rtl::OUString const mFileUrl ; /** XLayer implementation used for readData */ uno::Reference mLayerReader ; } ; // provides properties for file layers class LayerPropertyHelper : public apihelper::PropertySetHelper { protected: LayerPropertyHelper(){}; virtual ~LayerPropertyHelper(){}; protected: virtual rtl::OUString const & getLayerUrl() const = 0; protected: // cppu::OPropertySetHelper virtual cppu::IPropertyArrayHelper * SAL_CALL newInfoHelper(); virtual void SAL_CALL setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const uno::Any& rValue ) throw (uno::Exception); using PropertySetHelper::getFastPropertyValue; virtual void SAL_CALL getFastPropertyValue( uno::Any& rValue, sal_Int32 nHandle ) const; }; /** Implementation of the readonly XLayer interfaces for a local file access. The read data is accessible through a canned implementation of an XML parser. The layer is defined by the URL of the file containing its contents. */ class SimpleLocalFileLayer : public BasicLocalFileLayer , public cppu::ImplInheritanceHelper2< LayerPropertyHelper, backend::XLayer, util::XTimeStamped> { public : /** Constructor providing the base directory and the file subpath describing the file to access. An optional resource directory provides the location of sublayers of the component. @param xFactory service factory used to access canned services @param aComponentFile URL describing the component file */ SimpleLocalFileLayer( const uno::Reference& xFactory, const rtl::OUString& aComponentFile) ; /** Constructor providing the base directory and the file subpath describing the file to access. An optional resource directory provides the location of sublayers of the component. @param xFactory service factory used to access canned services @param aBaseDir base directory @param aComponent subpath describing the component file */ SimpleLocalFileLayer( const uno::Reference& xFactory, const rtl::OUString& aBaseDir, const rtl::OUString& aComponent) ; /** Destructor */ ~SimpleLocalFileLayer() ; // XLayer using BasicLocalFileLayer::readData; virtual void SAL_CALL readData( const uno::Reference& xHandler) throw (backend::MalformedDataException, lang::NullPointerException, lang::WrappedTargetException, uno::RuntimeException); // XTimeStamped virtual rtl::OUString SAL_CALL getTimestamp() throw (uno::RuntimeException); protected: virtual rtl::OUString const & getLayerUrl() const { return getFileUrl(); } } ; /** Implementation of the XUpdatableLayer interface for a local file access. The read data is accessible through a canned implementation of an XML parser, and the write data is defined through a canned implementation of an XML writer. The layer is defined by the URL of the file containing its contents, and that file will be either read or updated by the access to the handlers. The timestamp is refreshed on each read operation only. */ class FlatLocalFileLayer : public BasicLocalFileLayer , public cppu::ImplInheritanceHelper2< LayerPropertyHelper, backend::XUpdatableLayer, util::XTimeStamped> { public : /** Constructor providing the base directory and the file subpath describing the file to access. @param xFactory service factory used to access canned services @param aBaseDir base directory @param aComponent subpath describing the component file */ FlatLocalFileLayer( const uno::Reference& xFactory, const rtl::OUString& aBaseDir, const rtl::OUString& aComponent) ; /** Destructor */ ~FlatLocalFileLayer(void) ; // XLayer using BasicLocalFileLayer::readData; virtual void SAL_CALL readData( const uno::Reference& xHandler) throw (backend::MalformedDataException, lang::NullPointerException, lang::WrappedTargetException, uno::RuntimeException); // XUpdatableLayer virtual void SAL_CALL replaceWith( const uno::Reference& aNewLayer) throw (backend::MalformedDataException, lang::NullPointerException, lang::WrappedTargetException, uno::RuntimeException); // XTimeStamped virtual rtl::OUString SAL_CALL getTimestamp() throw (uno::RuntimeException); protected: virtual rtl::OUString const & getLayerUrl() const { return getFileUrl(); } private : /** XLayerHandler implementation for getWriteHandler */ uno::Reference mLayerWriter ; } ; /** Implementation of the XCompositeLayer interface for a local file access. The read data is accessible through a canned implementation of an XML parser. The layer is defined by the URL of the file containing its contents, and that file will be either read or updated by the access to the handlers. The timestamp is refreshed on each read operation only. */ class BasicCompositeLocalFileLayer : public BasicLocalFileLayer { protected: /** Constructor providing the base directory and the file subpath describing the file to access. An resource directory provides the location of sublayers of the component. @param xFactory service factory used to access canned services @param aComponent path describing the component file */ BasicCompositeLocalFileLayer( const uno::Reference& xFactory, const rtl::OUString& aComponent) ; // XCompositeLayer helpers uno::Sequence SAL_CALL listSubLayerIds() throw (lang::WrappedTargetException, uno::RuntimeException) { return mSubLayers ; } void SAL_CALL readSubLayerData( backend::XCompositeLayer * context, const uno::Reference& xHandler, const rtl::OUString& aSubLayerId) throw (backend::MalformedDataException, lang::NullPointerException, lang::WrappedTargetException, lang::IllegalArgumentException, uno::RuntimeException); /** Fills the list of available sublayers. @param aResDir resource directory containing potential sublayers @param aComponent component subpath */ void fillSubLayerLists(const std::vector& aSublayerDirectories, const rtl::OUString& aComponent) ; private : /** List of available sublayers... */ uno::Sequence mSubLayers ; /** .. and the corresponding file URLs. */ std::vector mSubLayerFiles ; }; /** Implementation of the XCompositeLayer interface for a local file access. The read data is accessible through a canned implementation of an XML parser. The layer is defined by the URL of the file containing its contents, and that file will be either read or updated by the access to the handlers. The timestamp is refreshed on each read operation only. */ class CompositeLocalFileLayer : public BasicCompositeLocalFileLayer , public cppu::WeakImplHelper1< backend::XCompositeLayer> { public : /** Constructor providing the base directory and the file subpath describing the file to access. An resource directory provides the location of sublayers of the component. @param xFactory service factory used to access canned services @param aBaseDir base directory @param aComponent subpath describing the component file @param aResDir resource directory, if empty it is assumed the layer does not have sublayers. */ CompositeLocalFileLayer( const uno::Reference& xFactory, const rtl::OUString& aComponent, const std::vector& aSublayerDirectories) ; /** Destructor */ ~CompositeLocalFileLayer(void) ; // XLayer using BasicCompositeLocalFileLayer::readData; virtual void SAL_CALL readData( const uno::Reference& xHandler) throw (backend::MalformedDataException, lang::NullPointerException, lang::WrappedTargetException, uno::RuntimeException); // XCompositeLayer virtual uno::Sequence SAL_CALL listSubLayerIds() throw (lang::WrappedTargetException, uno::RuntimeException) { return BasicCompositeLocalFileLayer::listSubLayerIds() ; } using BasicCompositeLocalFileLayer::readSubLayerData; virtual void SAL_CALL readSubLayerData( const uno::Reference& xHandler, const rtl::OUString& aSubLayerId) throw (backend::MalformedDataException, lang::NullPointerException, lang::WrappedTargetException, lang::IllegalArgumentException, uno::RuntimeException); private : // not implemented: warn of attempts to use this here void getFileUrl() const; } ; /** Implementation of the XUpdatableLayer and XCompositeLayer interfaces for a local file access. The read data is accessible through a canned implementation of an XML parser, and the write data is defined through a canned implementation of an XML writer. The layer is defined by the URL of the file containing its contents, and that file will be either read or updated by the access to the handlers. The timestamp is refreshed on each read operation only. */ class FullCompositeLocalFileLayer : public BasicCompositeLocalFileLayer , public cppu::ImplInheritanceHelper3< LayerPropertyHelper, backend::XUpdatableLayer, backend::XCompositeLayer, util::XTimeStamped> { public : /** Constructor providing the base directory and the file subpath describing the file to access. An resource directory provides the location of sublayers of the component. @param xFactory service factory used to access canned services @param aBaseDir base directory @param aComponent subpath describing the component file @param aResDir resource directory, if empty it is assumed the layer does not have sublayers. */ FullCompositeLocalFileLayer( const uno::Reference& xFactory, const rtl::OUString& aBaseDir, const rtl::OUString& aComponent, const std::vector& aSublayerDirectories) ; /** Destructor */ ~FullCompositeLocalFileLayer(void) ; // XLayer using BasicCompositeLocalFileLayer::readData; virtual void SAL_CALL readData( const uno::Reference& xHandler) throw (backend::MalformedDataException, lang::NullPointerException, lang::WrappedTargetException, uno::RuntimeException); // XUpdatableLayer virtual void SAL_CALL replaceWith( const uno::Reference& aNewLayer) throw (backend::MalformedDataException, lang::NullPointerException, lang::WrappedTargetException, uno::RuntimeException); // XCompositeLayer virtual uno::Sequence SAL_CALL listSubLayerIds() throw (lang::WrappedTargetException, uno::RuntimeException) { return BasicCompositeLocalFileLayer::listSubLayerIds() ; } using BasicCompositeLocalFileLayer::readSubLayerData; virtual void SAL_CALL readSubLayerData( const uno::Reference& xHandler, const rtl::OUString& aSubLayerId) throw (backend::MalformedDataException, lang::NullPointerException, lang::WrappedTargetException, lang::IllegalArgumentException, uno::RuntimeException); // XTimeStamped virtual rtl::OUString SAL_CALL getTimestamp() throw (uno::RuntimeException); protected: virtual rtl::OUString const & getLayerUrl() const { return getFileUrl(); } private : /** XLayerHandler implementation for getWriteHandler */ uno::Reference mLayerWriter ; } ; /** Factory function to create the appropriate Flat- or Composite- LocalFileLayer for a set of parameters. Arguments provide the base directory and the file subpath describing the file to access. An optional resource directory provides the location of sublayers of the component. @param xFactory service factory used to access canned services @param aBaseDir base directory @param aComponent subpath describing the component file @param aResDir resource directory, if empty it is assumed the layer does not have sublayers. */ uno::Reference createReadonlyLocalFileLayer( const uno::Reference& xFactory, const rtl::OUString& aBaseDir, const rtl::OUString& aComponent, const rtl::OUString& aResDir) ; /** Factory function to create the appropriate Flat- or Composite- LocalFileLayer for a set of parameters. Arguments provide the base directory and the file subpath describing the file to access. An optional resource directory provides the location of sublayers of the component. @param xFactory service factory used to access canned services @param aBaseDir base directory @param aComponent subpath describing the component file @param aResDir resource directory, if empty it is assumed the layer does not have sublayers. */ uno::Reference createUpdatableLocalFileLayer( const uno::Reference& xFactory, const rtl::OUString& aBaseDir, const rtl::OUString& aComponent, const rtl::OUString& aResDir) ; } } // configmgr.localbe #endif // CONFIGMGR_LOCALBE_LOCALFILELAYER_HXX_