LCOV - code coverage report
Current view: top level - ucb/source/ucp/file - prov.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 127 174 73.0 %
Date: 2014-11-03 Functions: 24 34 70.6 %
Legend: Lines: hit not hit

          Line data    Source code
       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 <osl/security.hxx>
      21             : #include <osl/file.hxx>
      22             : #include <osl/socket.h>
      23             : #include <comphelper/processfactory.hxx>
      24             : #include <com/sun/star/beans/PropertyAttribute.hpp>
      25             : #include <com/sun/star/ucb/FileSystemNotation.hpp>
      26             : #include <com/sun/star/beans/PropertyState.hpp>
      27             : #include <cppuhelper/factory.hxx>
      28             : #include <cppuhelper/supportsservice.hxx>
      29             : #include "filglob.hxx"
      30             : #include "filid.hxx"
      31             : #include "shell.hxx"
      32             : #include "bc.hxx"
      33             : #include "prov.hxx"
      34             : 
      35             : using namespace fileaccess;
      36             : using namespace com::sun::star;
      37             : using namespace com::sun::star::uno;
      38             : using namespace com::sun::star::lang;
      39             : using namespace com::sun::star::beans;
      40             : using namespace com::sun::star::ucb;
      41             : using namespace com::sun::star::container;
      42             : 
      43             : #if OSL_DEBUG_LEVEL > 0
      44             : #define THROW_WHERE SAL_WHERE
      45             : #else
      46             : #define THROW_WHERE ""
      47             : #endif
      48             : 
      49             : 
      50         333 : extern "C" SAL_DLLPUBLIC_EXPORT void * SAL_CALL ucpfile_component_getFactory(
      51             :     const sal_Char * pImplName, void * pServiceManager, void * )
      52             : {
      53         333 :     void * pRet = 0;
      54             : 
      55             :     Reference< XMultiServiceFactory > xSMgr(
      56         333 :             reinterpret_cast< XMultiServiceFactory * >( pServiceManager ) );
      57         666 :     Reference< XSingleServiceFactory > xFactory;
      58             : 
      59             : 
      60             :     // File Content Provider.
      61             : 
      62             : 
      63         666 :     if ( fileaccess::shell::getImplementationName_static().
      64         666 :             equalsAscii( pImplName ) )
      65             :     {
      66         333 :         xFactory = FileProvider::createServiceFactory( xSMgr );
      67             :     }
      68             : 
      69             : 
      70             : 
      71         333 :     if ( xFactory.is() )
      72             :     {
      73         333 :         xFactory->acquire();
      74         333 :         pRet = xFactory.get();
      75             :     }
      76             : 
      77         666 :     return pRet;
      78             : }
      79             : 
      80             : /****************************************************************************/
      81             : /*                                                                          */
      82             : /*                                                                          */
      83             : /*                        FileProvider                                      */
      84             : /*                                                                          */
      85             : /*                                                                          */
      86             : /****************************************************************************/
      87        4701 : FileProvider::FileProvider( const Reference< XComponentContext >& rxContext )
      88             :     : m_xContext(rxContext)
      89             :     , m_FileSystemNotation(FileSystemNotation::UNKNOWN_NOTATION)
      90        4701 :     , m_pMyShell(NULL)
      91             : {
      92        4701 : }
      93             : 
      94       13998 : FileProvider::~FileProvider()
      95             : {
      96        4666 :     if( m_pMyShell )
      97        3456 :         delete m_pMyShell;
      98        9332 : }
      99             : 
     100             : // XInitialization
     101      349490 : void SAL_CALL FileProvider::init()
     102             : {
     103      349490 :     if( ! m_pMyShell )
     104        3491 :         m_pMyShell = new shell( m_xContext, this, true );
     105      349490 : }
     106             : 
     107             : 
     108             : void SAL_CALL
     109           0 : FileProvider::initialize(
     110             :     const Sequence< Any >& aArguments )
     111             :     throw (Exception, RuntimeException, std::exception)
     112             : {
     113           0 :     if( ! m_pMyShell ) {
     114           0 :         OUString config;
     115           0 :         if( aArguments.getLength() > 0 &&
     116           0 :             (aArguments[0] >>= config) &&
     117           0 :             config.equalsAscii("NoConfig") )
     118           0 :             m_pMyShell = new shell( m_xContext, this, false );
     119             :         else
     120           0 :             m_pMyShell = new shell( m_xContext, this, true );
     121             :     }
     122           0 : }
     123             : 
     124             : // XServiceInfo methods.
     125             : OUString SAL_CALL
     126           2 : FileProvider::getImplementationName()
     127             :     throw( RuntimeException, std::exception )
     128             : {
     129           2 :     return fileaccess::shell::getImplementationName_static();
     130             : }
     131             : 
     132           0 : sal_Bool SAL_CALL FileProvider::supportsService(const OUString& ServiceName )
     133             :   throw( RuntimeException, std::exception )
     134             : {
     135           0 :     return cppu::supportsService(this, ServiceName);
     136             : }
     137             : 
     138             : Sequence< OUString > SAL_CALL
     139           0 : FileProvider::getSupportedServiceNames(
     140             :                        void )
     141             :   throw( RuntimeException, std::exception )
     142             : {
     143           0 :     return fileaccess::shell::getSupportedServiceNames_static();
     144             : }
     145             : 
     146             : Reference< XSingleServiceFactory > SAL_CALL
     147         333 : FileProvider::createServiceFactory(
     148             :                    const Reference< XMultiServiceFactory >& rxServiceMgr )
     149             : {
     150             :   /**
     151             :    * Create a single service factory.<BR>
     152             :    * Note: The function pointer ComponentInstantiation points to a function throws Exception.
     153             :    *
     154             :    * @param rServiceManager     the service manager used by the implementation.
     155             :    * @param rImplementationName the implementation name. An empty string is possible.
     156             :    * @param ComponentInstantiation the function pointer to create an object.
     157             :    * @param rServiceNames           the service supported by the implementation.
     158             :    * @return a factory that support the interfaces XServiceProvider, XServiceInfo
     159             :    *            XSingleServiceFactory and XComponent.
     160             :    *
     161             :    * @see createOneInstanceFactory
     162             :    */
     163             :   /*
     164             :    *  Reference< ::com::sun::star::XSingleServiceFactory > createSingleFactory
     165             :    *  (
     166             :    *  const ::com::sun::star::Reference< ::com::sun::star::XMultiServiceFactory > & rServiceManager,
     167             :    *  const OUString & rImplementationName,
     168             :    *  ComponentInstantiation pCreateFunction,
     169             : 
     170             :    *  const ::com::sun::star::Sequence< OUString > & rServiceNames
     171             :    *  );
     172             :    */
     173             : 
     174             :     return Reference< XSingleServiceFactory > ( cppu::createSingleFactory(
     175             :         rxServiceMgr,
     176             :         fileaccess::shell::getImplementationName_static(),
     177             :         FileProvider::CreateInstance,
     178         333 :         fileaccess::shell::getSupportedServiceNames_static() ) );
     179             : }
     180             : 
     181             : Reference< XInterface > SAL_CALL
     182        4701 : FileProvider::CreateInstance(
     183             :     const Reference< XMultiServiceFactory >& xMultiServiceFactory )
     184             : {
     185        4701 :     XServiceInfo* xP = (XServiceInfo*) new FileProvider( comphelper::getComponentContext(xMultiServiceFactory) );
     186        4701 :     return Reference< XInterface >::query( xP );
     187             : }
     188             : 
     189             : 
     190             : 
     191             : 
     192             : // XContent
     193             : 
     194             : 
     195             : 
     196             : Reference< XContent > SAL_CALL
     197      178225 : FileProvider::queryContent(
     198             :     const Reference< XContentIdentifier >& xIdentifier )
     199             :     throw( IllegalIdentifierException,
     200             :            RuntimeException, std::exception)
     201             : {
     202      178225 :     init();
     203      178225 :     OUString aUnc;
     204      178225 :     bool err = m_pMyShell->getUnqFromUrl( xIdentifier->getContentIdentifier(),
     205      178225 :                                               aUnc );
     206             : 
     207      178225 :     if(  err )
     208           0 :         throw IllegalIdentifierException( THROW_WHERE );
     209             : 
     210      178225 :     return Reference< XContent >( new BaseContent( m_pMyShell,xIdentifier,aUnc ) );
     211             : }
     212             : 
     213             : 
     214             : 
     215             : sal_Int32 SAL_CALL
     216        1268 : FileProvider::compareContentIds(
     217             :                 const Reference< XContentIdentifier >& Id1,
     218             :                 const Reference< XContentIdentifier >& Id2 )
     219             :   throw( RuntimeException, std::exception )
     220             : {
     221        1268 :     init();
     222        1268 :     OUString aUrl1 = Id1->getContentIdentifier();
     223        2536 :     OUString aUrl2 = Id2->getContentIdentifier();
     224             : 
     225        1268 :     sal_Int32   iComp = aUrl1.compareTo( aUrl2 );
     226             : 
     227        1268 :     if ( 0 != iComp )
     228             :     {
     229        2478 :         OUString aPath1, aPath2;
     230             : 
     231        1246 :         m_pMyShell->getUnqFromUrl( aUrl1, aPath1 );
     232        1246 :         m_pMyShell->getUnqFromUrl( aUrl2, aPath2 );
     233             : 
     234             :         osl::FileBase::RC   error;
     235        2478 :         osl::DirectoryItem  aItem1, aItem2;
     236             : 
     237        1246 :         error = osl::DirectoryItem::get( aPath1, aItem1 );
     238        1246 :         if ( error == osl::FileBase::E_None )
     239        1242 :             error = osl::DirectoryItem::get( aPath2, aItem2 );
     240             : 
     241        1246 :         if ( error != osl::FileBase::E_None )
     242          14 :             return iComp;
     243             : 
     244        2464 :         osl::FileStatus aStatus1( osl_FileStatus_Mask_FileURL );
     245        2464 :         osl::FileStatus aStatus2( osl_FileStatus_Mask_FileURL );
     246        1232 :         error = aItem1.getFileStatus( aStatus1 );
     247        1232 :         if ( error == osl::FileBase::E_None )
     248        1232 :             error = aItem2.getFileStatus( aStatus2 );
     249             : 
     250        1232 :         if ( error == osl::FileBase::E_None )
     251             :         {
     252        1232 :             iComp = aStatus1.getFileURL().compareTo( aStatus2.getFileURL() );
     253             : 
     254             : // Quick hack for Windows to threat all file systems as case insensitive
     255             : #ifdef  WNT
     256             :             if ( 0 != iComp )
     257             :             {
     258             :                 error = osl::FileBase::getSystemPathFromFileURL( aStatus1.getFileURL(), aPath1 );
     259             :                 if ( error == osl::FileBase::E_None )
     260             :                     error = osl::FileBase::getSystemPathFromFileURL( aStatus2.getFileURL(), aPath2 );
     261             : 
     262             :                 if ( error == osl::FileBase::E_None )
     263             :                     iComp = rtl_ustr_compareIgnoreAsciiCase( aPath1.getStr(), aPath2.getStr() );
     264             :             }
     265             : #endif
     266        1232 :         }
     267             :     }
     268             : 
     269        2522 :     return iComp;
     270             : }
     271             : 
     272             : 
     273             : 
     274             : Reference< XContentIdentifier > SAL_CALL
     275      169997 : FileProvider::createContentIdentifier(
     276             :                       const OUString& ContentId )
     277             :   throw( RuntimeException, std::exception )
     278             : {
     279      169997 :     init();
     280      169997 :     FileContentIdentifier* p = new FileContentIdentifier( m_pMyShell,ContentId,false );
     281      169997 :     return Reference< XContentIdentifier >( p );
     282             : }
     283             : 
     284             : 
     285             : 
     286             : //XPropertySetInfoImpl
     287             : 
     288             : class XPropertySetInfoImpl2
     289             :     : public cppu::OWeakObject,
     290             :       public XPropertySetInfo
     291             : {
     292             : public:
     293             :     XPropertySetInfoImpl2();
     294             :     virtual ~XPropertySetInfoImpl2();
     295             : 
     296             :     // XInterface
     297             :     virtual Any SAL_CALL
     298             :     queryInterface(
     299             :         const Type& aType )
     300             :         throw( RuntimeException, std::exception) SAL_OVERRIDE;
     301             : 
     302             :     virtual void SAL_CALL
     303             :     acquire(
     304             :         void )
     305             :         throw() SAL_OVERRIDE;
     306             : 
     307             :     virtual void SAL_CALL
     308             :     release(
     309             :         void )
     310             :         throw() SAL_OVERRIDE;
     311             : 
     312             : 
     313             :     virtual Sequence< Property > SAL_CALL
     314             :     getProperties(
     315             :         void )
     316             :         throw( RuntimeException, std::exception ) SAL_OVERRIDE;
     317             : 
     318             :     virtual Property SAL_CALL
     319             :     getPropertyByName(
     320             :         const OUString& aName )
     321             :         throw( UnknownPropertyException,
     322             :                RuntimeException, std::exception) SAL_OVERRIDE;
     323             : 
     324             :     virtual sal_Bool SAL_CALL
     325             :     hasPropertyByName( const OUString& Name )
     326             :         throw( RuntimeException, std::exception ) SAL_OVERRIDE;
     327             : 
     328             : 
     329             : private:
     330             :     Sequence< Property > m_seq;
     331             : };
     332             : 
     333             : 
     334           2 : XPropertySetInfoImpl2::XPropertySetInfoImpl2()
     335           2 :     : m_seq( 3 )
     336             : {
     337           4 :     m_seq[0] = Property( OUString("HostName"),
     338             :                          -1,
     339           2 :                          cppu::UnoType<OUString>::get(),
     340           2 :                          PropertyAttribute::READONLY );
     341             : 
     342           4 :     m_seq[1] = Property( OUString("HomeDirectory"),
     343             :                          -1,
     344           2 :                          cppu::UnoType<OUString>::get(),
     345           2 :                          PropertyAttribute::READONLY );
     346             : 
     347           4 :     m_seq[2] = Property( OUString("FileSystemNotation"),
     348             :                          -1,
     349           2 :                          cppu::UnoType<sal_Int32>::get(),
     350           2 :                          PropertyAttribute::READONLY );
     351           2 : }
     352             : 
     353             : 
     354           4 : XPropertySetInfoImpl2::~XPropertySetInfoImpl2()
     355             : {
     356             :     // nothing
     357           4 : }
     358             : 
     359             : 
     360             : void SAL_CALL
     361          14 : XPropertySetInfoImpl2::acquire(
     362             :     void )
     363             :     throw()
     364             : {
     365          14 :     OWeakObject::acquire();
     366          14 : }
     367             : 
     368             : 
     369             : void SAL_CALL
     370          14 : XPropertySetInfoImpl2::release(
     371             :     void )
     372             :     throw()
     373             : {
     374          14 :     OWeakObject::release();
     375          14 : }
     376             : 
     377             : 
     378             : Any SAL_CALL
     379           2 : XPropertySetInfoImpl2::queryInterface(
     380             :     const Type& rType )
     381             :     throw( RuntimeException, std::exception )
     382             : {
     383             :     Any aRet = cppu::queryInterface( rType,
     384           2 :                                           (static_cast< XPropertySetInfo* >(this)) );
     385           2 :     return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
     386             : }
     387             : 
     388             : 
     389             : Property SAL_CALL
     390           0 : XPropertySetInfoImpl2::getPropertyByName(
     391             :     const OUString& aName )
     392             :     throw( UnknownPropertyException,
     393             :            RuntimeException, std::exception)
     394             : {
     395           0 :     for( sal_Int32 i = 0; i < m_seq.getLength(); ++i )
     396           0 :         if( m_seq[i].Name == aName )
     397           0 :             return m_seq[i];
     398             : 
     399           0 :     throw UnknownPropertyException( THROW_WHERE );
     400             : }
     401             : 
     402             : 
     403             : 
     404             : Sequence< Property > SAL_CALL
     405           4 : XPropertySetInfoImpl2::getProperties(
     406             :     void )
     407             :     throw( RuntimeException, std::exception )
     408             : {
     409           4 :     return m_seq;
     410             : }
     411             : 
     412             : 
     413             : sal_Bool SAL_CALL
     414           0 : XPropertySetInfoImpl2::hasPropertyByName(
     415             :     const OUString& aName )
     416             :     throw( RuntimeException, std::exception )
     417             : {
     418           0 :     for( sal_Int32 i = 0; i < m_seq.getLength(); ++i )
     419           0 :         if( m_seq[i].Name == aName )
     420           0 :             return true;
     421           0 :     return false;
     422             : }
     423             : 
     424             : 
     425             : 
     426             : 
     427             : 
     428           6 : void SAL_CALL FileProvider::initProperties( void )
     429             : {
     430           6 :     osl::MutexGuard aGuard( m_aMutex );
     431           6 :     if( ! m_xPropertySetInfo.is() )
     432             :     {
     433           2 :         osl_getLocalHostname( &m_HostName.pData );
     434             : 
     435             : #if defined ( UNX )
     436           2 :         m_FileSystemNotation = FileSystemNotation::UNIX_NOTATION;
     437             : #elif defined( WNT )
     438             :         m_FileSystemNotation = FileSystemNotation::DOS_NOTATION;
     439             : #else
     440             :         m_FileSystemNotation = FileSystemNotation::UNKNOWN_NOTATION;
     441             : #endif
     442           2 :         osl::Security aSecurity;
     443           2 :         aSecurity.getHomeDir( m_HomeDirectory );
     444             : 
     445             :         // static const sal_Int32 UNKNOWN_NOTATION = (sal_Int32)0;
     446             :         // static const sal_Int32 UNIX_NOTATION = (sal_Int32)1;
     447             :         // static const sal_Int32 DOS_NOTATION = (sal_Int32)2;
     448             :         // static const sal_Int32 MAC_NOTATION = (sal_Int32)3;
     449             : 
     450           2 :         XPropertySetInfoImpl2* p = new XPropertySetInfoImpl2();
     451           2 :         m_xPropertySetInfo = Reference< XPropertySetInfo >( p );
     452           6 :     }
     453           6 : }
     454             : 
     455             : 
     456             : // XPropertySet
     457             : 
     458             : Reference< XPropertySetInfo > SAL_CALL
     459           4 : FileProvider::getPropertySetInfo(  )
     460             :     throw( RuntimeException, std::exception )
     461             : {
     462           4 :     initProperties();
     463           4 :     return m_xPropertySetInfo;
     464             : }
     465             : 
     466             : 
     467             : void SAL_CALL
     468           0 : FileProvider::setPropertyValue( const OUString& aPropertyName,
     469             :                                 const Any& )
     470             :     throw( UnknownPropertyException,
     471             :            PropertyVetoException,
     472             :            IllegalArgumentException,
     473             :            WrappedTargetException,
     474             :            RuntimeException, std::exception )
     475             : {
     476           0 :     if( aPropertyName.equalsAscii( "FileSystemNotation" ) ||
     477           0 :         aPropertyName.equalsAscii( "HomeDirectory" )      ||
     478           0 :         aPropertyName.equalsAscii( "HostName" ) )
     479           0 :         return;
     480             :     else
     481           0 :         throw UnknownPropertyException( THROW_WHERE );
     482             : }
     483             : 
     484             : 
     485             : 
     486             : Any SAL_CALL
     487           2 : FileProvider::getPropertyValue(
     488             :     const OUString& aPropertyName )
     489             :     throw( UnknownPropertyException,
     490             :            WrappedTargetException,
     491             :            RuntimeException, std::exception )
     492             : {
     493           2 :     initProperties();
     494           2 :     if( aPropertyName.equalsAscii( "FileSystemNotation" ) )
     495             :     {
     496           0 :         Any aAny;
     497           0 :         aAny <<= m_FileSystemNotation;
     498           0 :         return aAny;
     499             :     }
     500           2 :     else if( aPropertyName.equalsAscii( "HomeDirectory" ) )
     501             :     {
     502           0 :         Any aAny;
     503           0 :         aAny <<= m_HomeDirectory;
     504           0 :         return aAny;
     505             :     }
     506           2 :     else if( aPropertyName.equalsAscii( "HostName" ) )
     507             :     {
     508           2 :         Any aAny;
     509           2 :         aAny <<= m_HostName;
     510           2 :         return aAny;
     511             :     }
     512             :     else
     513           0 :         throw UnknownPropertyException( THROW_WHERE );
     514             : }
     515             : 
     516             : 
     517             : void SAL_CALL
     518           0 : FileProvider::addPropertyChangeListener(
     519             :     const OUString&,
     520             :     const Reference< XPropertyChangeListener >& )
     521             :     throw( UnknownPropertyException,
     522             :            WrappedTargetException,
     523             :            RuntimeException, std::exception)
     524             : {
     525           0 :     return;
     526             : }
     527             : 
     528             : 
     529             : void SAL_CALL
     530           0 : FileProvider::removePropertyChangeListener(
     531             :     const OUString&,
     532             :     const Reference< XPropertyChangeListener >& )
     533             :     throw( UnknownPropertyException,
     534             :            WrappedTargetException,
     535             :            RuntimeException, std::exception )
     536             : {
     537           0 :     return;
     538             : }
     539             : 
     540             : void SAL_CALL
     541           0 : FileProvider::addVetoableChangeListener(
     542             :     const OUString&,
     543             :     const Reference< XVetoableChangeListener >& )
     544             :     throw( UnknownPropertyException,
     545             :            WrappedTargetException,
     546             :            RuntimeException, std::exception )
     547             : {
     548           0 :     return;
     549             : }
     550             : 
     551             : 
     552             : void SAL_CALL
     553           0 : FileProvider::removeVetoableChangeListener(
     554             :     const OUString&,
     555             :     const Reference< XVetoableChangeListener >& )
     556             :     throw( UnknownPropertyException,
     557             :            WrappedTargetException,
     558             :            RuntimeException, std::exception)
     559             : {
     560           0 :     return;
     561             : }
     562             : 
     563             : 
     564             : 
     565             : // XFileIdentifierConverter
     566             : 
     567             : sal_Int32 SAL_CALL
     568           2 : FileProvider::getFileProviderLocality( const OUString& BaseURL )
     569             :     throw( RuntimeException, std::exception )
     570             : {
     571             :     // If the base URL is a 'file' URL, return 10 (very 'local'), otherwise
     572             :     // return -1 (missmatch).  What is missing is a fast comparison to ASCII,
     573             :     // ignoring case:
     574           2 :     return BaseURL.getLength() >= 5
     575           2 :            && (BaseURL[0] == 'F' || BaseURL[0] == 'f')
     576           2 :            && (BaseURL[1] == 'I' || BaseURL[1] == 'i')
     577           2 :            && (BaseURL[2] == 'L' || BaseURL[2] == 'l')
     578           2 :            && (BaseURL[3] == 'E' || BaseURL[3] == 'e')
     579           2 :            && BaseURL[4] == ':' ?
     580           4 :                10 : -1;
     581             : }
     582             : 
     583       47806 : OUString SAL_CALL FileProvider::getFileURLFromSystemPath( const OUString&,
     584             :                                                                const OUString& SystemPath )
     585             :     throw( RuntimeException, std::exception )
     586             : {
     587       47806 :     OUString aNormalizedPath;
     588       47806 :     if ( osl::FileBase::getFileURLFromSystemPath( SystemPath,aNormalizedPath ) != osl::FileBase::E_None )
     589           0 :         return OUString();
     590             : 
     591       47806 :     return aNormalizedPath;
     592             : }
     593             : 
     594      102431 : OUString SAL_CALL FileProvider::getSystemPathFromFileURL( const OUString& URL )
     595             :     throw( RuntimeException, std::exception )
     596             : {
     597      102431 :     OUString aSystemPath;
     598      102431 :     if (osl::FileBase::getSystemPathFromFileURL( URL,aSystemPath ) != osl::FileBase::E_None )
     599           0 :         return OUString();
     600             : 
     601      102431 :     return aSystemPath;
     602             : }
     603             : 
     604             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10