templatefoldercache.cxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#include <sal/config.h>
 
#include <osl/file.hxx>
#include <svtools/templatefoldercache.hxx>
#include <unotools/ucbstreamhelper.hxx>
#include <com/sun/star/sdbc/XResultSet.hpp>
#include <com/sun/star/ucb/XDynamicResultSet.hpp>
#include <com/sun/star/sdbc/XRow.hpp>
#include <com/sun/star/ucb/CommandAbortedException.hpp>
#include <com/sun/star/ucb/XContentAccess.hpp>
#include <com/sun/star/uno/XComponentContext.hpp>
#include <com/sun/star/util/theOfficeInstallationDirectories.hpp>
#include <ucbhelper/content.hxx>
#include <osl/diagnose.h>
#include <rtl/ref.hxx>
#include <salhelper/simplereferenceobject.hxx>
#include <tools/time.hxx>
#include <tools/urlobj.hxx>
#include <tools/debug.hxx>
#include <comphelper/diagnose_ex.hxx>
#include <unotools/pathoptions.hxx>
 
#include <comphelper/processfactory.hxx>
 
#include <mutex>
#include <utility>
#include <vector>
#include <algorithm>
 
 
namespace svt
{
 
 
    using namespace ::utl;
    using namespace ::com::sun::star;
    using namespace ::com::sun::star::sdbc;
    using namespace ::com::sun::star::ucb;
    using namespace ::com::sun::star::uno;
 
 
    //= helpers
 
 
    static SvStream& WriteDateTime( SvStream& _rStorage, const util::DateTime& _rDate )
    {
        sal_uInt16 hundredthSeconds = static_cast< sal_uInt16 >( _rDate.NanoSeconds / tools::Time::nanoPerCenti );
        _rStorage.WriteUInt16( hundredthSeconds );
 
        _rStorage.WriteUInt16( _rDate.Seconds );
        _rStorage.WriteUInt16( _rDate.Minutes );
        _rStorage.WriteUInt16( _rDate.Hours );
        _rStorage.WriteUInt16( _rDate.Day );
        _rStorage.WriteUInt16( _rDate.Month );
        _rStorage.WriteInt16( _rDate.Year );
 
        return _rStorage;
    }
 
 
    static SvStream& operator >> ( SvStream& _rStorage, util::DateTime& _rDate )
    {
        sal_uInt16 hundredthSeconds;
        _rStorage.ReadUInt16( hundredthSeconds );
        _rDate.NanoSeconds = static_cast< sal_uInt32 >( hundredthSeconds ) * tools::Time::nanoPerCenti;
 
        _rStorage.ReadUInt16( _rDate.Seconds );
        _rStorage.ReadUInt16( _rDate.Minutes );
        _rStorage.ReadUInt16( _rDate.Hours );
        _rStorage.ReadUInt16( _rDate.Day );
        _rStorage.ReadUInt16( _rDate.Month );
        _rStorage.ReadInt16( _rDate.Year );
 
        return _rStorage;
    }
 
    //= TemplateContent
 
    namespace {
 
    struct TemplateContent;
 
    }
 
    typedef ::std::vector< ::rtl::Reference< TemplateContent > >    TemplateFolderContent;
    typedef TemplateFolderContent::const_iterator           ConstFolderIterator;
    typedef TemplateFolderContent::iterator                 FolderIterator;
 
    namespace {
 
    struct TemplateContent : public ::salhelper::SimpleReferenceObject
    {
    public:
 
    private:
        INetURLObject           m_aURL;
        util::DateTime          m_aLastModified;    // date of last modification as reported by UCP
        TemplateFolderContent   m_aSubContents;     // sorted (by name) list of the children
 
    private:
        void    implResetDate( )
        {
            m_aLastModified.NanoSeconds = m_aLastModified.Seconds = m_aLastModified.Minutes = m_aLastModified.Hours = 0;
            m_aLastModified.Day = m_aLastModified.Month = m_aLastModified.Year = 0;
        }
 
    private:
        virtual ~TemplateContent() override;
 
    public:
        explicit TemplateContent( INetURLObject _aURL );
 
        // attribute access
        OUString                 getURL( ) const                             { return m_aURL.GetMainURL( INetURLObject::DecodeMechanism::ToIUri ); }
        void                     setModDate( const util::DateTime& _rDate )  { m_aLastModified = _rDate; }
        const util::DateTime&    getModDate( ) const                         { return m_aLastModified; }
 
        TemplateFolderContent&   getSubContents()            { return m_aSubContents; }
        const TemplateFolderContent& getSubContents() const  { return m_aSubContents; }
 
                ConstFolderIterator              end() const             { return m_aSubContents.end(); }
        TemplateFolderContent::size_type
                                        size() const    { return m_aSubContents.size(); }
 
        void                     push_back( const ::rtl::Reference< TemplateContent >& _rxNewElement )
                                                        { m_aSubContents.push_back( _rxNewElement ); }
    };
 
    }
 
    TemplateContent::TemplateContent( INetURLObject _aURL )
        :m_aURL(std::move( _aURL ))
    {
        DBG_ASSERT( INetProtocol::NotValid != m_aURL.GetProtocol(), "TemplateContent::TemplateContent: invalid URL!" );
        implResetDate();
    }
 
 
    TemplateContent::~TemplateContent()
    {
    }
 
 
    //= stl helpers
 
    namespace {
 
    struct TemplateContentURLLess
    {
        bool operator() ( const ::rtl::Reference< TemplateContent >& _rxLHS, const ::rtl::Reference< TemplateContent >& _rxRHS ) const
        {
            return _rxLHS->getURL() < _rxRHS->getURL();
        }
    };
 
 
    struct SubContentSort
    {
        void operator() ( TemplateFolderContent& _rFolder ) const
        {
            // sort the directory by name
            ::std::sort(
                _rFolder.begin(),
                _rFolder.end(),
                TemplateContentURLLess()
            );
 
            // sort the sub directories by name
            ::std::for_each(
                _rFolder.begin(),
                _rFolder.end(),
                *this
            );
        }
 
        void operator() ( const ::rtl::Reference< TemplateContent >& _rxContent ) const
        {
            if ( _rxContent.is() && _rxContent->size() )
            {
                operator()( _rxContent->getSubContents() );
            }
        }
    };
 
    struct TemplateContentEqual
    {
 
        bool operator() (const ::rtl::Reference< TemplateContent >& _rLHS, const ::rtl::Reference< TemplateContent >& _rRHS )
        {
            if ( !_rLHS.is() || !_rRHS.is() )
            {
                OSL_FAIL( "TemplateContentEqual::operator(): invalid contents!" );
                return true;
                    // this is not strictly true, in case only one is invalid - but this is a heavy error anyway
            }
 
            if ( _rLHS->getURL() != _rRHS->getURL() )
                return false;
 
            if ( _rLHS->getModDate() != _rRHS->getModDate() )
                return false;
 
            if ( _rLHS->getSubContents().size() != _rRHS->getSubContents().size() )
                return false;
 
            if ( !_rLHS->getSubContents().empty() )
            {   // there are children
                // -> compare them
                ::std::pair< FolderIterator, FolderIterator > aFirstDifferent = ::std::mismatch(
                    _rLHS->getSubContents().begin(),
                    _rLHS->getSubContents().end(),
                    _rRHS->getSubContents().begin(),
                    *this
                );
                if ( aFirstDifferent.first != _rLHS->getSubContents().end() )
                    return false;// the sub contents differ
            }
 
            return true;
        }
    };
 
 
    struct StorageHelper
    {
    protected:
        SvStream&   m_rStorage;
        explicit StorageHelper( SvStream& _rStorage ) : m_rStorage( _rStorage ) { }
    };
 
 
    struct StoreContentURL : public StorageHelper
    {
        uno::Reference< util::XOfficeInstallationDirectories > m_xOfficeInstDirs;
 
        StoreContentURL( SvStream& _rStorage,
                         uno::Reference<
                            util::XOfficeInstallationDirectories > xOfficeInstDirs )
        : StorageHelper( _rStorage ), m_xOfficeInstDirs(std::move( xOfficeInstDirs )) { }
 
        void operator() ( const ::rtl::Reference< TemplateContent >& _rxContent ) const
        {
            // use the base class operator with the local name of the content
            OUString sURL = _rxContent->getURL();
            // #116281# Keep office installation relocatable. Never store
            // any direct references to office installation directory.
            sURL = m_xOfficeInstDirs->makeRelocatableURL( sURL );
            m_rStorage.WriteUniOrByteString( sURL, m_rStorage.GetStreamCharSet() );
        }
    };
 
 
    struct StoreFolderContent : public StorageHelper
    {
        uno::Reference< util::XOfficeInstallationDirectories > m_xOfficeInstDirs;
 
    public:
        StoreFolderContent( SvStream& _rStorage,
                         uno::Reference<
                            util::XOfficeInstallationDirectories > xOfficeInstDirs )
        : StorageHelper( _rStorage ), m_xOfficeInstDirs(std::move( xOfficeInstDirs )) { }
 
 
        void operator() ( const TemplateContent& _rContent ) const
        {
            // store the info about this content
            WriteDateTime( m_rStorage, _rContent.getModDate() );
 
            // store the info about the children
            // the number
            m_rStorage.WriteInt32( _rContent.size() );
            // their URLs ( the local name is not enough, since URL might be not a hierarchical one, "expand:" for example )
            ::std::for_each(
                _rContent.getSubContents().begin(),
                _rContent.getSubContents().end(),
                StoreContentURL( m_rStorage, m_xOfficeInstDirs )
            );
            // their content
            ::std::for_each(
                _rContent.getSubContents().begin(),
                _rContent.getSubContents().end(),
                *this
            );
        }
 
 
        void operator() ( const ::rtl::Reference< TemplateContent >& _rxContent ) const
        {
            if ( _rxContent.is() )
            {
                operator()( *_rxContent );
            }
        }
    };
 
 
    struct ReadFolderContent : public StorageHelper
    {
        uno::Reference< util::XOfficeInstallationDirectories > m_xOfficeInstDirs;
 
        ReadFolderContent( SvStream& _rStorage,
                         uno::Reference<
                            util::XOfficeInstallationDirectories > xOfficeInstDirs )
        : StorageHelper( _rStorage ), m_xOfficeInstDirs(std::move( xOfficeInstDirs )) { }
 
 
        void operator() ( TemplateContent& _rContent ) const
        {
            // store the info about this content
            util::DateTime aModDate;
            m_rStorage >> aModDate;
            _rContent.setModDate( aModDate );
 
            // store the info about the children
            // the number
            sal_Int32 nChildren = 0;
            m_rStorage.ReadInt32( nChildren );
            TemplateFolderContent& rChildren = _rContent.getSubContents();
            rChildren.resize( 0 );
            rChildren.reserve( nChildren );
            // initialize them with their (local) names
            while ( nChildren-- )
            {
                OUString sURL = m_rStorage.ReadUniOrByteString(m_rStorage.GetStreamCharSet());
                sURL = m_xOfficeInstDirs->makeAbsoluteURL( sURL );
                rChildren.push_back( new TemplateContent( INetURLObject( sURL ) ) );
            }
 
            // their content
            ::std::for_each(
                _rContent.getSubContents().begin(),
                _rContent.getSubContents().end(),
                *this
            );
        }
 
 
        void operator() ( const ::rtl::Reference< TemplateContent >& _rxContent ) const
        {
            if ( _rxContent.is() )
            {
                operator()( *_rxContent );
            }
        }
    };
 
    }
 
    //= TemplateFolderCacheImpl
 
    class TemplateFolderCacheImpl
    {
    private:
        TemplateFolderContent           m_aPreviousState;   // the current state of the template dirs (as found on the HD)
        TemplateFolderContent           m_aCurrentState;    // the previous state of the template dirs (as found in the cache file)
 
        std::mutex                      m_aMutex;
        // will be lazy inited; never access directly; use getOfficeInstDirs().
        uno::Reference< util::XOfficeInstallationDirectories > m_xOfficeInstDirs;
 
        std::unique_ptr<SvStream>       m_pCacheStream;
        bool                            m_bNeedsUpdate : 1;
        bool                            m_bKnowState : 1;
        bool                            m_bValidCurrentState : 1;
        bool                            m_bAutoStoreState : 1;
 
    public:
        explicit TemplateFolderCacheImpl( bool _bAutoStoreState );
        ~TemplateFolderCacheImpl( );
 
        bool        needsUpdate();
        void        storeState();
 
    private:
        bool        openCacheStream( bool _bForRead );
        void        closeCacheStream( );
 
        bool        readPreviousState();
        bool        readCurrentState();
 
        static OUString    implParseSmart( const OUString& _rPath );
 
        bool        implReadFolder( const ::rtl::Reference< TemplateContent >& _rxRoot );
 
        static  sal_Int32   getMagicNumber();
        static  void        normalize( TemplateFolderContent& _rState );
 
        // @return <TRUE/> if the states equal
        static  bool        equalStates( const TemplateFolderContent& _rLHS, const TemplateFolderContent& _rRHS );
 
        // late initialize m_xOfficeInstDirs
        const uno::Reference< util::XOfficeInstallationDirectories >& getOfficeInstDirs();
    };
 
 
    TemplateFolderCacheImpl::TemplateFolderCacheImpl( bool _bAutoStoreState )
        :m_bNeedsUpdate         ( true )
        ,m_bKnowState           ( false )
        ,m_bValidCurrentState   ( false )
        ,m_bAutoStoreState      ( _bAutoStoreState )
    {
    }
 
 
    TemplateFolderCacheImpl::~TemplateFolderCacheImpl( )
    {
        // store the current state if possible and required
        if ( m_bValidCurrentState && m_bAutoStoreState )
            storeState();
 
        closeCacheStream( );
    }
 
 
    sal_Int32 TemplateFolderCacheImpl::getMagicNumber()
    {
        return (sal_Int8('T') << 12)
                | (sal_Int8('D') << 8)
                | (sal_Int8('S') << 4)
                | (sal_Int8('C'));
    }
 
 
    void TemplateFolderCacheImpl::normalize( TemplateFolderContent& _rState )
    {
        SubContentSort()( _rState );
    }
 
 
    bool TemplateFolderCacheImpl::equalStates( const TemplateFolderContent& _rLHS, const TemplateFolderContent& _rRHS )
    {
        if ( _rLHS.size() != _rRHS.size() )
            return false;
 
        // as both arrays are sorted (by definition - this is a precondition of this method)
        // we can simply go from the front to the back and compare the single elements
 
        ::std::pair< ConstFolderIterator, ConstFolderIterator > aFirstDifferent = ::std::mismatch(
            _rLHS.begin(),
            _rLHS.end(),
            _rRHS.begin(),
            TemplateContentEqual()
        );
 
        return aFirstDifferent.first == _rLHS.end();
    }
 
 
    void TemplateFolderCacheImpl::storeState()
    {
        if ( !m_bValidCurrentState )
            readCurrentState( );
 
        if ( !(m_bValidCurrentState && openCacheStream( false )) )
            return;
 
        m_pCacheStream->WriteInt32( getMagicNumber() );
 
        // store the template root folders
        // the size
        m_pCacheStream->WriteInt32( m_aCurrentState.size() );
        // the complete URLs
        ::std::for_each(
            m_aCurrentState.begin(),
            m_aCurrentState.end(),
            StoreContentURL( *m_pCacheStream, getOfficeInstDirs() )
        );
 
        // the contents
        ::std::for_each(
            m_aCurrentState.begin(),
            m_aCurrentState.end(),
            StoreFolderContent( *m_pCacheStream, getOfficeInstDirs() )
        );
    }
 
 
    OUString TemplateFolderCacheImpl::implParseSmart( const OUString& _rPath )
    {
        INetURLObject aParser;
        aParser.SetSmartProtocol( INetProtocol::File );
        aParser.SetURL( _rPath );
        if ( INetProtocol::NotValid == aParser.GetProtocol() )
        {
            OUString sURL;
            osl::FileBase::getFileURLFromSystemPath( _rPath, sURL );
            aParser.SetURL( sURL );
        }
        return aParser.GetMainURL( INetURLObject::DecodeMechanism::ToIUri );
    }
 
 
    void TemplateFolderCacheImpl::closeCacheStream( )
    {
        m_pCacheStream.reset();
    }
 
 
    bool TemplateFolderCacheImpl::implReadFolder( const ::rtl::Reference< TemplateContent >& _rxRoot )
    {
        try
        {
            // create a content for the current folder root
            Reference< XResultSet > xResultSet;
            Sequence< OUString > aContentProperties{ "Title", "DateModified", "DateCreated",
                                                     "IsFolder" };
 
            // get the set of sub contents in the folder
            try
            {
                Reference< XDynamicResultSet > xDynResultSet;
 
                ::ucbhelper::Content aTemplateRoot( _rxRoot->getURL(), Reference< XCommandEnvironment >(), comphelper::getProcessComponentContext() );
                xDynResultSet = aTemplateRoot.createDynamicCursor( aContentProperties );
                if ( xDynResultSet.is() )
                    xResultSet = xDynResultSet->getStaticResultSet();
            }
            catch( CommandAbortedException& )
            {
                TOOLS_WARN_EXCEPTION( "svtools.misc", "" );
                return false;
            }
            catch( css::uno::Exception& )
            {
            }
 
            // collect the infos about the sub contents
            if ( xResultSet.is() )
            {
                Reference< XRow > xRow( xResultSet, UNO_QUERY_THROW );
                Reference< XContentAccess > xContentAccess( xResultSet, UNO_QUERY_THROW );
 
                while ( xResultSet->next() )
                {
                    INetURLObject aSubContentURL( xContentAccess->queryContentIdentifierString() );
 
                    // a new content instance
                    ::rtl::Reference< TemplateContent > xChild = new TemplateContent( std::move(aSubContentURL) );
 
                    // the modified date
                    xChild->setModDate( xRow->getTimestamp( 2 ) );  // date modified
                    if ( xRow->wasNull() )
                        xChild->setModDate( xRow->getTimestamp( 3 ) );  // fallback: date created
 
                    // push back this content
                    _rxRoot->push_back( xChild );
 
                    // is it a folder?
                    if ( xRow->getBoolean( 4 ) && !xRow->wasNull() )
                    {   // yes -> step down
                        ConstFolderIterator aNextLevelRoot = _rxRoot->end();
                        --aNextLevelRoot;
                        implReadFolder( *aNextLevelRoot );
                    }
                }
            }
        }
        catch( const Exception& )
        {
            TOOLS_WARN_EXCEPTION( "svtools", "TemplateFolderCacheImpl::implReadFolder" );
            return false;
        }
        return true;
    }
 
 
    bool TemplateFolderCacheImpl::readCurrentState()
    {
        // reset
        m_bValidCurrentState = false;
        TemplateFolderContent aTemplateFolderContent;
        m_aCurrentState.swap( aTemplateFolderContent );
 
        // the template directories from the config
        const SvtPathOptions aPathOptions;
        const OUString& aDirs = aPathOptions.GetTemplatePath();
 
        // loop through all the root-level template folders
        sal_Int32 nIndex = 0;
        do
        {
            OUString sTemplatePath( aDirs.getToken(0, ';', nIndex) );
            sTemplatePath = aPathOptions.ExpandMacros( sTemplatePath );
 
            // Make sure excess ".." path segments (from expanding bootstrap
            // variables in paths) are normalized in the same way they are
            // normalized for paths read from the .templdir.cache file (where
            // paths have gone through makeRelocatable URL on writing out and
            // then through makeAbsoluteURL when reading back in), as otherwise
            // equalStates() in needsUpdate() could erroneously consider
            // m_aCurrentState and m_aPreviousState as different:
            sTemplatePath = getOfficeInstDirs()->makeAbsoluteURL(
                getOfficeInstDirs()->makeRelocatableURL(sTemplatePath));
 
            // create a new entry
            m_aCurrentState.push_back( new TemplateContent( INetURLObject( sTemplatePath ) ) );
            TemplateFolderContent::iterator aCurrentRoot = m_aCurrentState.end();
            --aCurrentRoot;
 
            if ( !implReadFolder( *aCurrentRoot ) )
                return false;
        }
        while ( nIndex >= 0 );
 
        // normalize the array (which basically means "sort it")
        normalize( m_aCurrentState );
 
        m_bValidCurrentState = true;
        return m_bValidCurrentState;
    }
 
 
    bool TemplateFolderCacheImpl::readPreviousState()
    {
        DBG_ASSERT( m_pCacheStream, "TemplateFolderCacheImpl::readPreviousState: not to be called without stream!" );
 
        // reset
        TemplateFolderContent aTemplateFolderContent;
        m_aPreviousState.swap( aTemplateFolderContent );
 
        // check the magic number
        sal_Int32 nMagic = 0;
        m_pCacheStream->ReadInt32( nMagic );
        DBG_ASSERT( getMagicNumber() == nMagic, "TemplateFolderCacheImpl::readPreviousState: invalid cache file!" );
        if ( getMagicNumber() != nMagic )
            return false;
 
        // the root directories
        // their number
        sal_Int32 nRootDirectories = 0;
        m_pCacheStream->ReadInt32( nRootDirectories );
        // init empty TemplateContents with the URLs
        m_aPreviousState.reserve( nRootDirectories );
        while ( nRootDirectories-- )
        {
            OUString sURL = m_pCacheStream->ReadUniOrByteString(m_pCacheStream->GetStreamCharSet());
            // #116281# Keep office installation relocatable. Never store
            // any direct references to office installation directory.
            sURL = getOfficeInstDirs()->makeAbsoluteURL( sURL );
            m_aPreviousState.push_back(
                new TemplateContent( INetURLObject(sURL) ) );
        }
 
        // read the contents of the root folders
        ::std::for_each(
            m_aPreviousState.begin(),
            m_aPreviousState.end(),
            ReadFolderContent( *m_pCacheStream, getOfficeInstDirs() )
        );
 
        DBG_ASSERT( !m_pCacheStream->GetErrorCode(), "TemplateFolderCacheImpl::readPreviousState: unknown error during reading the state cache!" );
 
        // normalize the array (which basically means "sort it")
        normalize( m_aPreviousState );
 
        return true;
    }
 
 
    bool TemplateFolderCacheImpl::openCacheStream( bool _bForRead )
    {
        // close any old stream instance
        closeCacheStream( );
 
        // get the storage directory
        OUString sStorageURL = implParseSmart( SvtPathOptions().GetStoragePath() );
        INetURLObject aStorageURL( sStorageURL );
        if ( INetProtocol::NotValid == aStorageURL.GetProtocol() )
        {
            OSL_FAIL( "TemplateFolderCacheImpl::openCacheStream: invalid storage path!" );
            return false;
        }
 
        // append our name
        aStorageURL.Append( u".templdir.cache" );
 
        // open the stream
        m_pCacheStream = UcbStreamHelper::CreateStream( aStorageURL.GetMainURL( INetURLObject::DecodeMechanism::ToIUri ),
            _bForRead ? StreamMode::READ | StreamMode::NOCREATE : StreamMode::WRITE | StreamMode::TRUNC );
        DBG_ASSERT( m_pCacheStream, "TemplateFolderCacheImpl::openCacheStream: could not open/create the cache stream!" );
        if ( m_pCacheStream && m_pCacheStream->GetErrorCode() )
        {
            m_pCacheStream.reset();
        }
 
        if ( m_pCacheStream )
            m_pCacheStream->SetStreamCharSet( RTL_TEXTENCODING_UTF8 );
 
        return nullptr != m_pCacheStream;
    }
 
 
    bool TemplateFolderCacheImpl::needsUpdate()
    {
        if ( m_bKnowState )
            return m_bNeedsUpdate;
 
        m_bNeedsUpdate = true;
        m_bKnowState = true;
 
        if ( readCurrentState() )
        {
            // open the stream which contains the cached state of the directories
            if ( openCacheStream( true ) )
            {   // opening the stream succeeded
                if ( readPreviousState() )
                {
                    m_bNeedsUpdate = !equalStates( m_aPreviousState, m_aCurrentState );
                }
                else
                {
                    closeCacheStream();
                }
            }
        }
        return m_bNeedsUpdate;
    }
 
 
    const uno::Reference< util::XOfficeInstallationDirectories >&
    TemplateFolderCacheImpl::getOfficeInstDirs()
    {
        if ( !m_xOfficeInstDirs.is() )
        {
            std::lock_guard aGuard( m_aMutex );
            if ( !m_xOfficeInstDirs.is() )
            {
                uno::Reference< uno::XComponentContext > xCtx(
                    comphelper::getProcessComponentContext() );
                m_xOfficeInstDirs = util::theOfficeInstallationDirectories::get(xCtx);
            }
        }
        return m_xOfficeInstDirs;
    }
 
 
    //= TemplateFolderCache
 
 
    TemplateFolderCache::TemplateFolderCache( bool _bAutoStoreState )
        :m_pImpl( new TemplateFolderCacheImpl( _bAutoStoreState ) )
    {
    }
 
 
    TemplateFolderCache::~TemplateFolderCache( )
    {
    }
 
 
    bool TemplateFolderCache::needsUpdate()
    {
        return m_pImpl->needsUpdate();
    }
 
 
    void TemplateFolderCache::storeState()
    {
        m_pImpl->storeState();
    }
 
 
}   // namespace sfx2
 
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */