UDK 3.2.7 C/C++ API Reference

osl/file.hxx

Go to the documentation of this file.
00001 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
00002 /*
00003  * This file is part of the LibreOffice project.
00004  *
00005  * This Source Code Form is subject to the terms of the Mozilla Public
00006  * License, v. 2.0. If a copy of the MPL was not distributed with this
00007  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
00008  *
00009  * This file incorporates work covered by the following license notice:
00010  *
00011  *   Licensed to the Apache Software Foundation (ASF) under one or more
00012  *   contributor license agreements. See the NOTICE file distributed
00013  *   with this work for additional information regarding copyright
00014  *   ownership. The ASF licenses this file to you under the Apache
00015  *   License, Version 2.0 (the "License"); you may not use this file
00016  *   except in compliance with the License. You may obtain a copy of
00017  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
00018  */
00019 
00020 #ifndef _OSL_FILE_HXX_
00021 #define _OSL_FILE_HXX_
00022 
00023 #include "sal/config.h"
00024 
00025 #include <string.h>
00026 
00027 #include <cassert>
00028 
00029 #include <osl/time.h>
00030 #include <rtl/ustring.hxx>
00031 
00032 #include <osl/file.h>
00033 #include <rtl/byteseq.hxx>
00034 
00035 #include <stdio.h>
00036 
00037 namespace osl
00038 {
00039 
00040 
00041 // -----------------------------------------------------------------------------
00049 class FileBase
00050 {
00051 public:
00052 
00053     enum RC {
00054         E_None         = osl_File_E_None,
00055         E_PERM         = osl_File_E_PERM,
00056         E_NOENT        = osl_File_E_NOENT,
00057         E_SRCH         = osl_File_E_SRCH,
00058         E_INTR         = osl_File_E_INTR,
00059         E_IO           = osl_File_E_IO,
00060         E_NXIO         = osl_File_E_NXIO,
00061         E_2BIG         = osl_File_E_2BIG,
00062         E_NOEXEC       = osl_File_E_NOEXEC,
00063         E_BADF         = osl_File_E_BADF,
00064         E_CHILD        = osl_File_E_CHILD,
00065         E_AGAIN        = osl_File_E_AGAIN,
00066         E_NOMEM        = osl_File_E_NOMEM,
00067         E_ACCES        = osl_File_E_ACCES,
00068         E_FAULT        = osl_File_E_FAULT,
00069         E_BUSY         = osl_File_E_BUSY,
00070         E_EXIST        = osl_File_E_EXIST,
00071         E_XDEV         = osl_File_E_XDEV,
00072         E_NODEV        = osl_File_E_NODEV,
00073         E_NOTDIR       = osl_File_E_NOTDIR,
00074         E_ISDIR        = osl_File_E_ISDIR,
00075         E_INVAL        = osl_File_E_INVAL,
00076         E_NFILE        = osl_File_E_NFILE,
00077         E_MFILE        = osl_File_E_MFILE,
00078         E_NOTTY        = osl_File_E_NOTTY,
00079         E_FBIG         = osl_File_E_FBIG,
00080         E_NOSPC        = osl_File_E_NOSPC,
00081         E_SPIPE        = osl_File_E_SPIPE,
00082         E_ROFS         = osl_File_E_ROFS,
00083         E_MLINK        = osl_File_E_MLINK,
00084         E_PIPE         = osl_File_E_PIPE,
00085         E_DOM          = osl_File_E_DOM,
00086         E_RANGE        = osl_File_E_RANGE,
00087         E_DEADLK       = osl_File_E_DEADLK,
00088         E_NAMETOOLONG  = osl_File_E_NAMETOOLONG,
00089         E_NOLCK        = osl_File_E_NOLCK,
00090         E_NOSYS        = osl_File_E_NOSYS,
00091         E_NOTEMPTY     = osl_File_E_NOTEMPTY,
00092         E_LOOP         = osl_File_E_LOOP,
00093         E_ILSEQ        = osl_File_E_ILSEQ,
00094         E_NOLINK       = osl_File_E_NOLINK,
00095         E_MULTIHOP     = osl_File_E_MULTIHOP,
00096         E_USERS        = osl_File_E_USERS,
00097         E_OVERFLOW     = osl_File_E_OVERFLOW,
00098         E_NOTREADY     = osl_File_E_NOTREADY,
00099         E_invalidError = osl_File_E_invalidError,   /* unmapped error: always last entry in enum! */
00100         E_TIMEDOUT     = osl_File_E_TIMEDOUT,
00101         E_NETWORK      = osl_File_E_NETWORK
00102     };
00103 
00104 
00105 public:
00106 
00128     static inline RC getCanonicalName( const ::rtl::OUString& ustrRequestedURL, ::rtl::OUString& ustrValidURL )
00129     {
00130         return (RC) osl_getCanonicalName( ustrRequestedURL.pData, &ustrValidURL.pData );
00131     }
00132 
00168     static inline RC getAbsoluteFileURL( const ::rtl::OUString& ustrBaseDirectoryURL, const ::rtl::OUString& ustrRelativeFileURL, ::rtl::OUString& ustrAbsoluteFileURL )
00169     {
00170         return (RC) osl_getAbsoluteFileURL( ustrBaseDirectoryURL.pData, ustrRelativeFileURL.pData, &ustrAbsoluteFileURL.pData );
00171     }
00172 
00188     static inline RC getSystemPathFromFileURL( const ::rtl::OUString& ustrFileURL, ::rtl::OUString& ustrSystemPath )
00189     {
00190         return (RC) osl_getSystemPathFromFileURL( ustrFileURL.pData, &ustrSystemPath.pData );
00191     }
00192 
00208     static inline RC getFileURLFromSystemPath( const ::rtl::OUString& ustrSystemPath, ::rtl::OUString& ustrFileURL )
00209     {
00210         return (RC) osl_getFileURLFromSystemPath( ustrSystemPath.pData, &ustrFileURL.pData );
00211     }
00212 
00241     static inline RC searchFileURL( const ::rtl::OUString& ustrFileName, const ::rtl::OUString& ustrSearchPath, ::rtl::OUString& ustrFileURL )
00242     {
00243         return (RC) osl_searchFileURL( ustrFileName.pData, ustrSearchPath.pData, &ustrFileURL.pData );
00244     }
00245 
00256     static inline RC getTempDirURL( ::rtl::OUString& ustrTempDirURL )
00257     {
00258         return (RC) osl_getTempDirURL( &ustrTempDirURL.pData );
00259     }
00260 
00310     static inline RC createTempFile(
00311         ::rtl::OUString* pustrDirectoryURL,
00312         oslFileHandle*   pHandle,
00313         ::rtl::OUString* pustrTempFileURL)
00314     {
00315         rtl_uString*  pustr_dir_url       = pustrDirectoryURL ? pustrDirectoryURL->pData : 0;
00316         rtl_uString** ppustr_tmp_file_url = pustrTempFileURL  ? &pustrTempFileURL->pData : 0;
00317 
00318         return (RC) osl_createTempFile(pustr_dir_url, pHandle, ppustr_tmp_file_url);
00319     }
00320 };
00321 
00322 
00323 // -----------------------------------------------------------------------------
00329 class VolumeDevice : public FileBase
00330 {
00331     oslVolumeDeviceHandle   _aHandle;
00332 
00333 public:
00334 
00338     VolumeDevice() : _aHandle( NULL )
00339     {
00340     }
00341 
00348     VolumeDevice( const VolumeDevice & rDevice )
00349     {
00350         _aHandle = rDevice._aHandle;
00351         if ( _aHandle )
00352             osl_acquireVolumeDeviceHandle( _aHandle );
00353     }
00354 
00358     ~VolumeDevice()
00359     {
00360         if ( _aHandle )
00361             osl_releaseVolumeDeviceHandle( _aHandle );
00362     }
00363 
00370     inline VolumeDevice & operator =( const VolumeDevice & rDevice )
00371     {
00372         oslVolumeDeviceHandle   newHandle = rDevice._aHandle;
00373 
00374         if ( newHandle )
00375             osl_acquireVolumeDeviceHandle( newHandle );
00376 
00377         if ( _aHandle )
00378             osl_releaseVolumeDeviceHandle( _aHandle );
00379 
00380         _aHandle = newHandle;
00381 
00382         return *this;
00383     }
00384 
00390     inline rtl::OUString getMountPath()
00391     {
00392         rtl::OUString   aPath;
00393         osl_getVolumeDeviceMountPath( _aHandle, &aPath.pData );
00394         return aPath;
00395     }
00396 
00397     friend class VolumeInfo;
00398 };
00399 
00400 // -----------------------------------------------------------------------------
00401 
00402 class Directory;
00403 
00412 class VolumeInfo
00413 {
00414     oslVolumeInfo   _aInfo;
00415     sal_uInt32      _nMask;
00416     VolumeDevice    _aDevice;
00417 
00421     VolumeInfo( VolumeInfo& );
00422 
00426     VolumeInfo& operator = ( VolumeInfo& );
00427 
00428 public:
00429 
00436     VolumeInfo( sal_uInt32 nMask ): _nMask( nMask )
00437     {
00438         _aInfo.uStructSize = sizeof( oslVolumeInfo );
00439         memset( &_aInfo.uValidFields, 0, sizeof( oslVolumeInfo ) - sizeof( sal_uInt32 ) );
00440         _aInfo.pDeviceHandle = &_aDevice._aHandle;
00441     }
00442 
00446     ~VolumeInfo()
00447     {
00448         if( _aInfo.ustrFileSystemName )
00449             rtl_uString_release( _aInfo.ustrFileSystemName );
00450     }
00451 
00460     inline sal_Bool isValid( sal_uInt32 nMask ) const
00461     {
00462         return ( nMask & _aInfo.uValidFields ) == nMask;
00463     }
00464 
00471     inline sal_Bool getRemoteFlag() const
00472     {
00473         return 0 != (_aInfo.uAttributes & osl_Volume_Attribute_Remote);
00474     }
00475 
00482     inline sal_Bool getRemoveableFlag() const
00483     {
00484         return 0 != (_aInfo.uAttributes & osl_Volume_Attribute_Removeable);
00485     }
00486 
00493     inline sal_Bool getCompactDiscFlag() const
00494     {
00495         return 0 != (_aInfo.uAttributes & osl_Volume_Attribute_CompactDisc);
00496     }
00497 
00504     inline sal_Bool getFloppyDiskFlag() const
00505     {
00506         return 0 != (_aInfo.uAttributes & osl_Volume_Attribute_FloppyDisk);
00507     }
00508 
00515     inline sal_Bool getFixedDiskFlag() const
00516     {
00517         return 0 != (_aInfo.uAttributes & osl_Volume_Attribute_FixedDisk);
00518     }
00519 
00526     inline sal_Bool getRAMDiskFlag() const
00527     {
00528         return 0 != (_aInfo.uAttributes & osl_Volume_Attribute_RAMDisk);
00529     }
00530 
00538     inline sal_uInt64 getTotalSpace() const
00539     {
00540         return _aInfo.uTotalSpace;
00541     }
00542 
00550     inline sal_uInt64 getFreeSpace() const
00551     {
00552         return _aInfo.uFreeSpace;
00553     }
00554 
00562     inline sal_uInt64 getUsedSpace() const
00563     {
00564         return _aInfo.uUsedSpace;
00565     }
00566 
00574     inline sal_uInt32 getMaxNameLength() const
00575     {
00576         return _aInfo.uMaxNameLength;
00577     }
00578 
00586     inline sal_uInt32 getMaxPathLength() const
00587     {
00588         return _aInfo.uMaxPathLength;
00589     }
00590 
00598     inline ::rtl::OUString getFileSystemName() const
00599     {
00600         return _aInfo.ustrFileSystemName ? ::rtl::OUString( _aInfo.ustrFileSystemName ) : ::rtl::OUString();
00601     }
00602 
00603 
00611     inline VolumeDevice getDeviceHandle() const
00612     {
00613         return _aDevice;
00614     }
00615 
00622     bool isCaseSensitiveFileSystem() const
00623     {
00624         return (_aInfo.uAttributes & osl_Volume_Attribute_Case_Sensitive);
00625     }
00626 
00634     bool isCasePreservingFileSystem() const
00635     {
00636         return (_aInfo.uAttributes & osl_Volume_Attribute_Case_Is_Preserved);
00637     }
00638 
00639     friend class Directory;
00640 };
00641 
00642 // -----------------------------------------------------------------------------
00643 class DirectoryItem;
00644 
00650 class FileStatus
00651 {
00652     oslFileStatus   _aStatus;
00653     sal_uInt32      _nMask;
00654 
00658     FileStatus( FileStatus& );
00659 
00663     FileStatus& operator = ( FileStatus& );
00664 
00665 public:
00666 
00667     enum Type {
00668         Directory = osl_File_Type_Directory,
00669         Volume    = osl_File_Type_Volume,
00670         Regular   = osl_File_Type_Regular,
00671         Fifo      = osl_File_Type_Fifo,
00672         Socket    = osl_File_Type_Socket,
00673         Link      = osl_File_Type_Link,
00674         Special   = osl_File_Type_Special,
00675         Unknown   = osl_File_Type_Unknown
00676     };
00677 
00684     FileStatus( sal_uInt32 nMask ): _nMask( nMask )
00685     {
00686         _aStatus.uStructSize = sizeof( oslFileStatus );
00687         memset( &_aStatus.uValidFields, 0, sizeof( oslFileStatus ) - sizeof( sal_uInt32 ) );
00688     }
00689 
00693     ~FileStatus()
00694     {
00695         if ( _aStatus.ustrFileURL )
00696             rtl_uString_release( _aStatus.ustrFileURL );
00697         if ( _aStatus.ustrLinkTargetURL )
00698             rtl_uString_release( _aStatus.ustrLinkTargetURL );
00699         if ( _aStatus.ustrFileName )
00700             rtl_uString_release( _aStatus.ustrFileName );
00701     }
00702 
00712     inline sal_Bool isValid( sal_uInt32 nMask ) const
00713     {
00714         return ( nMask & _aStatus.uValidFields ) == nMask;
00715     }
00716 
00722     inline Type getFileType() const
00723     {
00724         SAL_INFO_IF(
00725             !isValid(osl_FileStatus_Mask_Type), "sal.osl",
00726             "no FileStatus Type determined");
00727         return isValid(osl_FileStatus_Mask_Type)
00728             ? static_cast< Type >(_aStatus.eType) : Unknown;
00729     }
00730 
00740     inline sal_Bool isDirectory() const
00741     {
00742         return ( getFileType() == Directory || getFileType() == Volume );
00743     }
00744 
00755     inline sal_Bool isRegular() const
00756     {
00757         return ( getFileType() == Regular );
00758     }
00759 
00768     inline sal_Bool isLink() const
00769     {
00770         return ( getFileType() == Link );
00771     }
00772 
00779     inline sal_uInt64 getAttributes() const
00780     {
00781         SAL_INFO_IF(
00782             !isValid(osl_FileStatus_Mask_Attributes), "sal.osl",
00783             "no FileStatus Attributes determined");
00784         return _aStatus.uAttributes;
00785     }
00786 
00794     inline TimeValue getCreationTime() const
00795     {
00796         SAL_INFO_IF(
00797             !isValid(osl_FileStatus_Mask_CreationTime), "sal.osl",
00798             "no FileStatus CreationTime determined");
00799         return _aStatus.aCreationTime;
00800     }
00801 
00809     inline TimeValue getAccessTime() const
00810     {
00811         SAL_INFO_IF(
00812             !isValid(osl_FileStatus_Mask_AccessTime), "sal.osl",
00813             "no FileStatus AccessTime determined");
00814         return _aStatus.aAccessTime;
00815     }
00816 
00824     inline TimeValue getModifyTime() const
00825     {
00826         SAL_INFO_IF(
00827             !isValid(osl_FileStatus_Mask_ModifyTime), "sal.osl",
00828             "no FileStatus ModifyTime determined");
00829         return _aStatus.aModifyTime;
00830     }
00831 
00838     inline sal_uInt64 getFileSize() const
00839     {
00840         SAL_INFO_IF(
00841             !isValid(osl_FileStatus_Mask_FileSize), "sal.osl",
00842             "no FileStatus FileSize determined");
00843         return _aStatus.uFileSize;
00844     }
00845 
00852     inline ::rtl::OUString getFileName() const
00853     {
00854         SAL_INFO_IF(
00855             !isValid(osl_FileStatus_Mask_FileName), "sal.osl",
00856             "no FileStatus FileName determined");
00857         return isValid(osl_FileStatus_Mask_FileName)
00858             ? rtl::OUString(_aStatus.ustrFileName) : rtl::OUString();
00859     }
00860 
00861 
00869     inline ::rtl::OUString getFileURL() const
00870     {
00871         SAL_INFO_IF(
00872             !isValid(osl_FileStatus_Mask_FileURL), "sal.osl",
00873             "no FileStatus FileURL determined");
00874         return isValid(osl_FileStatus_Mask_FileURL)
00875             ? rtl::OUString(_aStatus.ustrFileURL) : rtl::OUString();
00876     }
00877 
00885     inline ::rtl::OUString getLinkTargetURL() const
00886     {
00887         SAL_INFO_IF(
00888             !isValid(osl_FileStatus_Mask_LinkTargetURL), "sal.osl",
00889             "no FileStatus LinkTargetURL determined");
00890         return isValid(osl_FileStatus_Mask_LinkTargetURL)
00891             ? rtl::OUString(_aStatus.ustrLinkTargetURL) : rtl::OUString();
00892     }
00893 
00894     friend class DirectoryItem;
00895 };
00896 
00897 
00898 // -----------------------------------------------------------------------------
00905 class File: public FileBase
00906 {
00907     oslFileHandle   _pData;
00908     ::rtl::OUString _aPath;
00909 
00913     File( File& );
00914 
00918     File& operator = ( File& );
00919 
00920 public:
00921 
00928     File( const ::rtl::OUString& ustrFileURL ): _pData( 0 ), _aPath( ustrFileURL ) {}
00929 
00933     inline ~File()
00934     {
00935         close();
00936     }
00937 
00981     inline RC open( sal_uInt32 uFlags )
00982     {
00983         return (RC) osl_openFile( _aPath.pData, &_pData, uFlags );
00984     }
00985 
01000     inline RC close()
01001     {
01002         oslFileError Error = osl_File_E_BADF;
01003 
01004         if( _pData )
01005         {
01006             Error=osl_closeFile( _pData );
01007             _pData = NULL;
01008         }
01009 
01010         return (RC) Error;
01011     }
01012 
01030     inline RC setPos( sal_uInt32 uHow, sal_Int64 uPos ) SAL_WARN_UNUSED_RESULT
01031     {
01032         return (RC) osl_setFilePos( _pData, uHow, uPos );
01033     }
01034 
01051     inline RC getPos( sal_uInt64& uPos )
01052     {
01053         return (RC) osl_getFilePos( _pData, &uPos );
01054     }
01055 
01078     inline RC isEndOfFile( sal_Bool *pIsEOF )
01079     {
01080         return (RC) osl_isEndOfFile( _pData, pIsEOF );
01081     }
01082 
01101     inline RC setSize( sal_uInt64 uSize )
01102     {
01103         return (RC) osl_setFileSize( _pData, uSize );
01104     }
01105 
01126     inline RC getSize( sal_uInt64 &rSize )
01127     {
01128         return (RC) osl_getFileSize( _pData, &rSize );
01129     }
01130 
01163     inline RC read( void *pBuffer, sal_uInt64 uBytesRequested, sal_uInt64& rBytesRead )
01164     {
01165         return (RC) osl_readFile( _pData, pBuffer, uBytesRequested, &rBytesRead );
01166     }
01167 
01202     inline RC write(const void *pBuffer, sal_uInt64 uBytesToWrite, sal_uInt64& rBytesWritten)
01203     {
01204         return (RC) osl_writeFile( _pData, pBuffer, uBytesToWrite, &rBytesWritten );
01205     }
01206 
01207 
01232     inline RC readLine( ::rtl::ByteSequence& aSeq )
01233     {
01234         return (RC) osl_readLine( _pData, reinterpret_cast<sal_Sequence**>(&aSeq) );
01235     }
01236 
01268     inline RC sync() const
01269     {
01270         OSL_PRECOND(_pData, "File::sync(): File not open");
01271         return (RC)osl_syncFile(_pData);
01272     }
01273 
01300     inline static RC copy( const ::rtl::OUString& ustrSourceFileURL, const ::rtl::OUString& ustrDestFileURL )
01301     {
01302         return (RC) osl_copyFile( ustrSourceFileURL.pData, ustrDestFileURL.pData );
01303     }
01304 
01329     inline static RC move( const ::rtl::OUString& ustrSourceFileURL, const ::rtl::OUString& ustrDestFileURL )
01330     {
01331         return (RC) osl_moveFile( ustrSourceFileURL.pData, ustrDestFileURL.pData );
01332     }
01333 
01362     inline static RC remove( const ::rtl::OUString& ustrFileURL )
01363     {
01364         return (RC) osl_removeFile( ustrFileURL.pData );
01365     }
01366 
01382     inline static RC setAttributes( const ::rtl::OUString& ustrFileURL, sal_uInt64 uAttributes )
01383     {
01384         return (RC) osl_setFileAttributes( ustrFileURL.pData, uAttributes );
01385     }
01386 
01409     inline static RC setTime(
01410         const ::rtl::OUString& ustrFileURL,
01411         const TimeValue& rCreationTime,
01412         const TimeValue& rLastAccessTime,
01413         const TimeValue& rLastWriteTime )
01414     {
01415         return (RC)  osl_setFileTime(
01416             ustrFileURL.pData,
01417             &rCreationTime,
01418             &rLastAccessTime,
01419             &rLastWriteTime );
01420     }
01421 
01422     friend class DirectoryItem;
01423 };
01424 
01425 // -----------------------------------------------------------------------------
01431 class DirectoryItem: public FileBase
01432 {
01433     oslDirectoryItem _pData;
01434 
01435 public:
01436 
01440     DirectoryItem(): _pData( NULL )
01441     {
01442     }
01443 
01447     DirectoryItem( const DirectoryItem& rItem ): _pData( rItem._pData)
01448     {
01449         if( _pData )
01450             osl_acquireDirectoryItem( _pData );
01451     }
01452 
01456     ~DirectoryItem()
01457     {
01458         if( _pData )
01459             osl_releaseDirectoryItem( _pData );
01460     }
01461 
01465     DirectoryItem& operator=(const DirectoryItem& rItem )
01466     {
01467         if (&rItem != this)
01468         {
01469             if( _pData )
01470                 osl_releaseDirectoryItem( _pData );
01471 
01472             _pData = rItem._pData;
01473 
01474             if( _pData )
01475                 osl_acquireDirectoryItem( _pData );
01476         }
01477         return *this;
01478     }
01479 
01486     inline sal_Bool is()
01487     {
01488         return _pData != NULL;
01489     }
01490 
01525     static inline RC get( const ::rtl::OUString& ustrFileURL, DirectoryItem& rItem )
01526     {
01527         if( rItem._pData)
01528         {
01529             osl_releaseDirectoryItem( rItem._pData );
01530             rItem._pData = NULL;
01531         }
01532 
01533         return (RC) osl_getDirectoryItem( ustrFileURL.pData, &rItem._pData );
01534     }
01535 
01568     inline RC getFileStatus( FileStatus& rStatus )
01569     {
01570         return (RC) osl_getFileStatus( _pData, &rStatus._aStatus, rStatus._nMask );
01571     }
01572 
01589     inline sal_Bool isIdenticalTo( const DirectoryItem &pOther )
01590     {
01591         return osl_identicalDirectoryItem( _pData, pOther._pData );
01592     }
01593 
01594     friend class Directory;
01595 };
01596 
01597 //###########################################
01598 
01609 class DirectoryCreationObserver
01610 {
01611 public:
01612     virtual ~DirectoryCreationObserver() {}
01613 
01623     virtual void DirectoryCreated(const rtl::OUString& aDirectoryUrl) = 0;
01624 };
01625 
01626 //###########################################
01627 // This just an internal helper function for
01628 // private use.
01629 extern "C" inline void SAL_CALL onDirectoryCreated(void* pData, rtl_uString* aDirectoryUrl)
01630 {
01631     (static_cast<DirectoryCreationObserver*>(pData))->DirectoryCreated(aDirectoryUrl);
01632 }
01633 
01640 class Directory: public FileBase
01641 {
01642     oslDirectory    _pData;
01643     ::rtl::OUString _aPath;
01644 
01648     Directory( Directory& );
01649 
01653     Directory& operator = ( Directory& );
01654 
01655 public:
01656 
01664     Directory( const ::rtl::OUString& strPath ): _pData( 0 ), _aPath( strPath )
01665     {
01666     }
01667 
01671     ~Directory()
01672     {
01673         close();
01674     }
01675 
01694     inline RC open()
01695     {
01696         return (RC) osl_openDirectory( _aPath.pData, &_pData );
01697     }
01698 
01710     inline sal_Bool isOpen() { return _pData != NULL; }
01711 
01724     inline RC close()
01725     {
01726         oslFileError Error = osl_File_E_BADF;
01727 
01728         if( _pData )
01729         {
01730             Error=osl_closeDirectory( _pData );
01731             _pData = NULL;
01732         }
01733 
01734         return (RC) Error;
01735     }
01736 
01737 
01755     inline RC reset()
01756     {
01757         close();
01758         return open();
01759     }
01760 
01784     inline RC getNextItem( DirectoryItem& rItem, sal_uInt32 nHint = 0 )
01785     {
01786         if( rItem._pData )
01787         {
01788             osl_releaseDirectoryItem( rItem._pData );
01789             rItem._pData = 0;
01790         }
01791         return ( RC) osl_getNextDirectoryItem( _pData, &rItem._pData, nHint );
01792     }
01793 
01794 
01826     inline static RC getVolumeInfo( const ::rtl::OUString& ustrDirectoryURL, VolumeInfo& rInfo )
01827     {
01828         return (RC) osl_getVolumeInformation( ustrDirectoryURL.pData, &rInfo._aInfo, rInfo._nMask );
01829     }
01830 
01858     inline static RC create( const ::rtl::OUString& ustrDirectoryURL )
01859     {
01860         return (RC) osl_createDirectory( ustrDirectoryURL.pData );
01861     }
01862 
01891     inline static RC remove( const ::rtl::OUString& ustrDirectoryURL )
01892     {
01893         return (RC) osl_removeDirectory( ustrDirectoryURL.pData );
01894     }
01895 
01948     static RC createPath(
01949         const ::rtl::OUString& aDirectoryUrl,
01950         DirectoryCreationObserver* aDirectoryCreationObserver = NULL)
01951     {
01952         return (RC)osl_createDirectoryPath(
01953             aDirectoryUrl.pData,
01954             (aDirectoryCreationObserver) ? onDirectoryCreated : NULL,
01955             aDirectoryCreationObserver);
01956     }
01957 };
01958 
01959 } /* namespace osl */
01960 
01961 #endif  /* _OSL_FILE_HXX_ */
01962 
01963 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines