file.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 
 
#ifndef INCLUDED_OSL_FILE_HXX
#define INCLUDED_OSL_FILE_HXX
 
#include "sal/config.h"
 
#include <string.h>
 
#include <cstddef>
 
#include "sal/log.hxx"
#include "osl/time.h"
#include "rtl/ustring.hxx"
 
#include "osl/file.h"
#include "osl/diagnose.h"
 
namespace rtl { class ByteSequence; }
 
namespace osl
{
 
 
class FileBase
{
public:
 
    enum RC {
        E_None         = osl_File_E_None,           
        E_PERM         = osl_File_E_PERM,           
        E_NOENT        = osl_File_E_NOENT,          
        E_SRCH         = osl_File_E_SRCH,           
        E_INTR         = osl_File_E_INTR,           
        E_IO           = osl_File_E_IO,             
        E_NXIO         = osl_File_E_NXIO,           
        E_2BIG         = osl_File_E_2BIG,           
        E_NOEXEC       = osl_File_E_NOEXEC,         
        E_BADF         = osl_File_E_BADF,           
        E_CHILD        = osl_File_E_CHILD,          
        E_AGAIN        = osl_File_E_AGAIN,          
        E_NOMEM        = osl_File_E_NOMEM,          
        E_ACCES        = osl_File_E_ACCES,          
        E_FAULT        = osl_File_E_FAULT,          
        E_BUSY         = osl_File_E_BUSY,           
        E_EXIST        = osl_File_E_EXIST,          
        E_XDEV         = osl_File_E_XDEV,           
        E_NODEV        = osl_File_E_NODEV,          
        E_NOTDIR       = osl_File_E_NOTDIR,         
        E_ISDIR        = osl_File_E_ISDIR,          
        E_INVAL        = osl_File_E_INVAL,          
        E_NFILE        = osl_File_E_NFILE,          
        E_MFILE        = osl_File_E_MFILE,          
        E_NOTTY        = osl_File_E_NOTTY,          
        E_FBIG         = osl_File_E_FBIG,           
        E_NOSPC        = osl_File_E_NOSPC,          
        E_SPIPE        = osl_File_E_SPIPE,          
        E_ROFS         = osl_File_E_ROFS,           
        E_MLINK        = osl_File_E_MLINK,          
        E_PIPE         = osl_File_E_PIPE,           
        E_DOM          = osl_File_E_DOM,            
        E_RANGE        = osl_File_E_RANGE,          
        E_DEADLK       = osl_File_E_DEADLK,         
        E_NAMETOOLONG  = osl_File_E_NAMETOOLONG,    
        E_NOLCK        = osl_File_E_NOLCK,          
        E_NOSYS        = osl_File_E_NOSYS,          
        E_NOTEMPTY     = osl_File_E_NOTEMPTY,       
        E_LOOP         = osl_File_E_LOOP,           
        E_ILSEQ        = osl_File_E_ILSEQ,          
        E_NOLINK       = osl_File_E_NOLINK,         
        E_MULTIHOP     = osl_File_E_MULTIHOP,       
        E_USERS        = osl_File_E_USERS,          
        E_OVERFLOW     = osl_File_E_OVERFLOW,       
        E_NOTREADY     = osl_File_E_NOTREADY,       
        E_invalidError = osl_File_E_invalidError,   
        E_TIMEDOUT     = osl_File_E_TIMEDOUT,       
        E_NETWORK      = osl_File_E_NETWORK
    };
 
 
public:
 
    static RC getCanonicalName( const ::rtl::OUString& ustrRequestedURL, ::rtl::OUString& ustrValidURL )
    {
        return static_cast< RC >( osl_getCanonicalName( ustrRequestedURL.pData, &ustrValidURL.pData ) );
    }
 
    static RC getAbsoluteFileURL( const ::rtl::OUString& ustrBaseDirectoryURL, const ::rtl::OUString& ustrRelativeFileURL, ::rtl::OUString& ustrAbsoluteFileURL )
    {
        return static_cast< RC >( osl_getAbsoluteFileURL( ustrBaseDirectoryURL.pData, ustrRelativeFileURL.pData, &ustrAbsoluteFileURL.pData ) );
    }
 
    static RC getSystemPathFromFileURL( const ::rtl::OUString& ustrFileURL, ::rtl::OUString& ustrSystemPath )
    {
        return static_cast< RC >( osl_getSystemPathFromFileURL( ustrFileURL.pData, &ustrSystemPath.pData ) );
    }
 
    static RC getFileURLFromSystemPath( const ::rtl::OUString& ustrSystemPath, ::rtl::OUString& ustrFileURL )
    {
        return static_cast< RC >( osl_getFileURLFromSystemPath( ustrSystemPath.pData, &ustrFileURL.pData ) );
    }
 
    static RC searchFileURL( const ::rtl::OUString& ustrFileName, const ::rtl::OUString& ustrSearchPath, ::rtl::OUString& ustrFileURL )
    {
        return static_cast< RC >( osl_searchFileURL( ustrFileName.pData, ustrSearchPath.pData, &ustrFileURL.pData ) );
    }
 
    static RC getTempDirURL( ::rtl::OUString& ustrTempDirURL )
    {
        return static_cast< RC >( osl_getTempDirURL( &ustrTempDirURL.pData ) );
    }
 
    static RC createTempFile(
        ::rtl::OUString* pustrDirectoryURL,
        oslFileHandle*   pHandle,
        ::rtl::OUString* pustrTempFileURL)
    {
        rtl_uString*  pustr_dir_url       = pustrDirectoryURL ? pustrDirectoryURL->pData : NULL;
        rtl_uString** ppustr_tmp_file_url = pustrTempFileURL  ? &pustrTempFileURL->pData : NULL;
 
        return static_cast< RC >( osl_createTempFile(pustr_dir_url, pHandle, ppustr_tmp_file_url) );
    }
};
 
 
class VolumeDevice : public FileBase
{
    oslVolumeDeviceHandle   _aHandle;
 
public:
 
    VolumeDevice() : _aHandle( NULL )
    {
    }
 
    VolumeDevice( const VolumeDevice & rDevice )
    {
        _aHandle = rDevice._aHandle;
        if ( _aHandle )
            osl_acquireVolumeDeviceHandle( _aHandle );
    }
 
    ~VolumeDevice()
    {
        if ( _aHandle )
            osl_releaseVolumeDeviceHandle( _aHandle );
    }
 
    VolumeDevice & operator =( const VolumeDevice & rDevice )
    {
        oslVolumeDeviceHandle   newHandle = rDevice._aHandle;
 
        if ( newHandle )
            osl_acquireVolumeDeviceHandle( newHandle );
 
        if ( _aHandle )
            osl_releaseVolumeDeviceHandle( _aHandle );
 
        _aHandle = newHandle;
 
        return *this;
    }
 
    rtl::OUString getMountPath()
    {
        rtl::OUString   aPath;
        osl_getVolumeDeviceMountPath( _aHandle, &aPath.pData );
        return aPath;
    }
 
    friend class VolumeInfo;
};
 
 
class Directory;
 
class VolumeInfo
{
    oslVolumeInfo   _aInfo;
    sal_uInt32      _nMask;
    VolumeDevice    _aDevice;
 
    VolumeInfo( VolumeInfo& ) SAL_DELETED_FUNCTION;
 
    VolumeInfo& operator = ( VolumeInfo& ) SAL_DELETED_FUNCTION;
 
public:
 
    VolumeInfo( sal_uInt32 nMask )
        : _nMask( nMask )
    {
        memset( &_aInfo, 0, sizeof( oslVolumeInfo ));
        _aInfo.uStructSize = sizeof( oslVolumeInfo );
        _aInfo.pDeviceHandle = &_aDevice._aHandle;
    }
 
    ~VolumeInfo()
    {
        if( _aInfo.ustrFileSystemName )
            rtl_uString_release( _aInfo.ustrFileSystemName );
    }
 
    bool isValid( sal_uInt32 nMask ) const
    {
        return ( nMask & _aInfo.uValidFields ) == nMask;
    }
 
    bool getRemoteFlag() const
    {
        return (_aInfo.uAttributes & osl_Volume_Attribute_Remote) != 0;
    }
 
    bool getRemoveableFlag() const
    {
        return (_aInfo.uAttributes & osl_Volume_Attribute_Removeable) != 0;
    }
 
    bool getCompactDiscFlag() const
    {
        return (_aInfo.uAttributes & osl_Volume_Attribute_CompactDisc) != 0;
    }
 
    bool getFloppyDiskFlag() const
    {
        return (_aInfo.uAttributes & osl_Volume_Attribute_FloppyDisk) != 0;
    }
 
    bool getFixedDiskFlag() const
    {
        return (_aInfo.uAttributes & osl_Volume_Attribute_FixedDisk) != 0;
    }
 
    bool getRAMDiskFlag() const
    {
        return (_aInfo.uAttributes & osl_Volume_Attribute_RAMDisk) != 0;
    }
 
    sal_uInt64 getTotalSpace() const
    {
        return _aInfo.uTotalSpace;
    }
 
    sal_uInt64 getFreeSpace() const
    {
        return _aInfo.uFreeSpace;
    }
 
    sal_uInt64 getUsedSpace() const
    {
        return _aInfo.uUsedSpace;
    }
 
    sal_uInt32 getMaxNameLength() const
    {
        return _aInfo.uMaxNameLength;
    }
 
    sal_uInt32 getMaxPathLength() const
    {
        return _aInfo.uMaxPathLength;
    }
 
    ::rtl::OUString getFileSystemName() const
    {
        return _aInfo.ustrFileSystemName ? ::rtl::OUString( _aInfo.ustrFileSystemName ) : ::rtl::OUString();
    }
 
 
    VolumeDevice getDeviceHandle() const
    {
        return _aDevice;
    }
 
    bool isCaseSensitiveFileSystem() const
    {
        return (_aInfo.uAttributes & osl_Volume_Attribute_Case_Sensitive) != 0;
    }
 
    bool isCasePreservingFileSystem() const
    {
        return (_aInfo.uAttributes & osl_Volume_Attribute_Case_Is_Preserved) != 0;
    }
 
    friend class Directory;
};
 
 
class DirectoryItem;
 
class FileStatus
{
    oslFileStatus   _aStatus;
    sal_uInt32      _nMask;
 
    FileStatus( FileStatus& ) SAL_DELETED_FUNCTION;
 
    FileStatus& operator = ( FileStatus& ) SAL_DELETED_FUNCTION;
 
public:
 
    enum Type {
        Directory = osl_File_Type_Directory,
        Volume    = osl_File_Type_Volume,
        Regular   = osl_File_Type_Regular,
        Fifo      = osl_File_Type_Fifo,
        Socket    = osl_File_Type_Socket,
        Link      = osl_File_Type_Link,
        Special   = osl_File_Type_Special,
        Unknown   = osl_File_Type_Unknown
    };
 
    FileStatus(sal_uInt32 nMask)
        : _nMask(nMask)
    {
        memset(&_aStatus, 0, sizeof(_aStatus));
        _aStatus.uStructSize = sizeof(_aStatus);
    }
 
    ~FileStatus()
    {
        if ( _aStatus.ustrFileURL )
            rtl_uString_release( _aStatus.ustrFileURL );
        if ( _aStatus.ustrLinkTargetURL )
            rtl_uString_release( _aStatus.ustrLinkTargetURL );
        if ( _aStatus.ustrFileName )
            rtl_uString_release( _aStatus.ustrFileName );
    }
 
    bool isValid( sal_uInt32 nMask ) const
    {
        return ( nMask & _aStatus.uValidFields ) == nMask;
    }
 
    Type getFileType() const
    {
        SAL_INFO_IF(
            !isValid(osl_FileStatus_Mask_Type), "sal.osl",
            "no FileStatus Type determined");
        return isValid(osl_FileStatus_Mask_Type)
            ? static_cast< Type >(_aStatus.eType) : Unknown;
    }
 
    bool isDirectory() const
    {
        return ( getFileType() == Directory || getFileType() == Volume );
    }
 
    bool isRegular() const
    {
        return ( getFileType() == Regular );
    }
 
    bool isLink() const
    {
        return ( getFileType() == Link );
    }
 
    sal_uInt64 getAttributes() const
    {
        SAL_INFO_IF(
            !isValid(osl_FileStatus_Mask_Attributes), "sal.osl",
            "no FileStatus Attributes determined");
        return _aStatus.uAttributes;
    }
 
    TimeValue getCreationTime() const
    {
        SAL_INFO_IF(
            !isValid(osl_FileStatus_Mask_CreationTime), "sal.osl",
            "no FileStatus CreationTime determined");
        return _aStatus.aCreationTime;
    }
 
    TimeValue getAccessTime() const
    {
        SAL_INFO_IF(
            !isValid(osl_FileStatus_Mask_AccessTime), "sal.osl",
            "no FileStatus AccessTime determined");
        return _aStatus.aAccessTime;
    }
 
    TimeValue getModifyTime() const
    {
        SAL_INFO_IF(
            !isValid(osl_FileStatus_Mask_ModifyTime), "sal.osl",
            "no FileStatus ModifyTime determined");
        return _aStatus.aModifyTime;
    }
 
    sal_uInt64 getFileSize() const
    {
        SAL_INFO_IF(
            !isValid(osl_FileStatus_Mask_FileSize), "sal.osl",
            "no FileStatus FileSize determined");
        return _aStatus.uFileSize;
    }
 
    ::rtl::OUString getFileName() const
    {
        SAL_INFO_IF(
            !isValid(osl_FileStatus_Mask_FileName), "sal.osl",
            "no FileStatus FileName determined");
        return isValid(osl_FileStatus_Mask_FileName)
            ? rtl::OUString(_aStatus.ustrFileName) : rtl::OUString();
    }
 
 
    ::rtl::OUString getFileURL() const
    {
        SAL_INFO_IF(
            !isValid(osl_FileStatus_Mask_FileURL), "sal.osl",
            "no FileStatus FileURL determined");
        return isValid(osl_FileStatus_Mask_FileURL)
            ? rtl::OUString(_aStatus.ustrFileURL) : rtl::OUString();
    }
 
    ::rtl::OUString getLinkTargetURL() const
    {
        SAL_INFO_IF(
            !isValid(osl_FileStatus_Mask_LinkTargetURL), "sal.osl",
            "no FileStatus LinkTargetURL determined");
        return isValid(osl_FileStatus_Mask_LinkTargetURL)
            ? rtl::OUString(_aStatus.ustrLinkTargetURL) : rtl::OUString();
    }
 
    friend class DirectoryItem;
};
 
 
class File: public FileBase
{
    oslFileHandle   _pData;
    ::rtl::OUString _aPath;
 
    File( File& ) SAL_DELETED_FUNCTION;
 
    File& operator = ( File& ) SAL_DELETED_FUNCTION;
 
public:
 
    File( const ::rtl::OUString& ustrFileURL ): _pData( NULL ), _aPath( ustrFileURL ) {}
 
    ~File()
    {
        close();
    }
 
    rtl::OUString getURL() const { return _aPath; }
 
    RC open( sal_uInt32 uFlags )
    {
        return static_cast< RC >( osl_openFile( _aPath.pData, &_pData, uFlags ) );
    }
 
    RC close()
    {
        oslFileError Error = osl_File_E_BADF;
 
        if( _pData )
        {
            Error=osl_closeFile( _pData );
            _pData = NULL;
        }
 
        return static_cast< RC >( Error );
    }
 
    SAL_WARN_UNUSED_RESULT RC setPos( sal_uInt32 uHow, sal_Int64 uPos )
    {
        return static_cast< RC >( osl_setFilePos( _pData, uHow, uPos ) );
    }
 
    RC getPos( sal_uInt64& uPos )
    {
        return static_cast< RC >( osl_getFilePos( _pData, &uPos ) );
    }
 
    RC isEndOfFile( sal_Bool *pIsEOF )
    {
        return static_cast< RC >( osl_isEndOfFile( _pData, pIsEOF ) );
    }
 
    RC setSize( sal_uInt64 uSize )
    {
        return static_cast< RC >( osl_setFileSize( _pData, uSize ) );
    }
 
    RC getSize( sal_uInt64 &rSize )
    {
        return static_cast< RC >( osl_getFileSize( _pData, &rSize ) );
    }
 
    RC read( void *pBuffer, sal_uInt64 uBytesRequested, sal_uInt64& rBytesRead )
    {
        return static_cast< RC >( osl_readFile( _pData, pBuffer, uBytesRequested, &rBytesRead ) );
    }
 
    RC write(const void *pBuffer, sal_uInt64 uBytesToWrite, sal_uInt64& rBytesWritten)
    {
        return static_cast< RC >( osl_writeFile( _pData, pBuffer, uBytesToWrite, &rBytesWritten ) );
    }
 
 
    RC readLine( ::rtl::ByteSequence& aSeq )
    {
        return static_cast< RC >( osl_readLine( _pData, reinterpret_cast<sal_Sequence**>(&aSeq) ) );
    }
 
    RC sync() const
    {
        OSL_PRECOND(_pData, "File::sync(): File not open");
        return static_cast< RC >(osl_syncFile(_pData));
    }
 
    static RC copy( const ::rtl::OUString& ustrSourceFileURL, const ::rtl::OUString& ustrDestFileURL )
    {
        return static_cast< RC >( osl_copyFile( ustrSourceFileURL.pData, ustrDestFileURL.pData ) );
    }
 
    static RC move( const ::rtl::OUString& ustrSourceFileURL, const ::rtl::OUString& ustrDestFileURL )
    {
        return static_cast< RC >( osl_moveFile( ustrSourceFileURL.pData, ustrDestFileURL.pData ) );
    }
 
    static RC replace(const ::rtl::OUString& ustrSourceFileURL,
                      const ::rtl::OUString& ustrDestFileURL)
    {
        return static_cast<RC>(osl_replaceFile(ustrSourceFileURL.pData, ustrDestFileURL.pData));
    }
 
    static RC remove( const ::rtl::OUString& ustrFileURL )
    {
        return static_cast< RC >( osl_removeFile( ustrFileURL.pData ) );
    }
 
    static RC setAttributes( const ::rtl::OUString& ustrFileURL, sal_uInt64 uAttributes )
    {
        return static_cast< RC >( osl_setFileAttributes( ustrFileURL.pData, uAttributes ) );
    }
 
    static RC setTime(
        const ::rtl::OUString& ustrFileURL,
        const TimeValue& rCreationTime,
        const TimeValue& rLastAccessTime,
        const TimeValue& rLastWriteTime )
    {
        return static_cast< RC >( osl_setFileTime(
            ustrFileURL.pData,
            &rCreationTime,
            &rLastAccessTime,
            &rLastWriteTime ) );
    }
 
    friend class DirectoryItem;
};
 
 
class DirectoryItem: public FileBase
{
    oslDirectoryItem _pData;
 
public:
 
    DirectoryItem(): _pData( NULL )
    {
    }
 
    DirectoryItem( const DirectoryItem& rItem ): _pData( rItem._pData)
    {
        if( _pData )
            osl_acquireDirectoryItem( _pData );
    }
 
    ~DirectoryItem()
    {
        if( _pData )
            osl_releaseDirectoryItem( _pData );
    }
 
    DirectoryItem& operator=(const DirectoryItem& rItem )
    {
        if (&rItem != this)
        {
            if( _pData )
                osl_releaseDirectoryItem( _pData );
 
            _pData = rItem._pData;
 
            if( _pData )
                osl_acquireDirectoryItem( _pData );
        }
        return *this;
    }
 
    bool is()
    {
        return _pData != NULL;
    }
 
    static RC get( const ::rtl::OUString& ustrFileURL, DirectoryItem& rItem )
    {
        if( rItem._pData)
        {
            osl_releaseDirectoryItem( rItem._pData );
            rItem._pData = NULL;
        }
 
        return static_cast< RC >( osl_getDirectoryItem( ustrFileURL.pData, &rItem._pData ) );
    }
 
    RC getFileStatus( FileStatus& rStatus )
    {
        return static_cast< RC >( osl_getFileStatus( _pData, &rStatus._aStatus, rStatus._nMask ) );
    }
 
    bool isIdenticalTo( const DirectoryItem &pOther )
    {
        return osl_identicalDirectoryItem( _pData, pOther._pData );
    }
 
    friend class Directory;
};
 
 
class DirectoryCreationObserver
{
public:
    virtual ~DirectoryCreationObserver() {}
 
    virtual void DirectoryCreated(const rtl::OUString& aDirectoryUrl) = 0;
};
 
 
// This just an internal helper function for
// private use.
extern "C" inline void SAL_CALL onDirectoryCreated(void* pData, rtl_uString* aDirectoryUrl)
{
    static_cast<DirectoryCreationObserver*>(pData)->DirectoryCreated(aDirectoryUrl);
}
 
class Directory: public FileBase
{
    oslDirectory    _pData;
    ::rtl::OUString _aPath;
 
    Directory( Directory& ) SAL_DELETED_FUNCTION;
 
    Directory& operator = ( Directory& ) SAL_DELETED_FUNCTION;
 
public:
 
    Directory( const ::rtl::OUString& strPath ): _pData( NULL ), _aPath( strPath )
    {
    }
 
    ~Directory()
    {
        close();
    }
 
    rtl::OUString getURL() const { return _aPath; }
 
    RC open()
    {
        return static_cast< RC >( osl_openDirectory( _aPath.pData, &_pData ) );
    }
 
    bool isOpen() { return _pData != NULL; }
 
    RC close()
    {
        oslFileError Error = osl_File_E_BADF;
 
        if( _pData )
        {
            Error=osl_closeDirectory( _pData );
            _pData = NULL;
        }
 
        return static_cast< RC >( Error );
    }
 
 
    RC reset()
    {
        close();
        return open();
    }
 
    RC getNextItem( DirectoryItem& rItem, sal_uInt32 nHint = 0 )
    {
        if( rItem._pData )
        {
            osl_releaseDirectoryItem( rItem._pData );
            rItem._pData = NULL;
        }
        return static_cast<RC>(osl_getNextDirectoryItem( _pData, &rItem._pData, nHint ));
    }
 
 
    static RC getVolumeInfo( const ::rtl::OUString& ustrDirectoryURL, VolumeInfo& rInfo )
    {
        return static_cast< RC >( osl_getVolumeInformation( ustrDirectoryURL.pData, &rInfo._aInfo, rInfo._nMask ) );
    }
 
    static RC create(
        const ::rtl::OUString& ustrDirectoryURL,
        sal_uInt32 flags = osl_File_OpenFlag_Read | osl_File_OpenFlag_Write )
    {
        return static_cast< RC >(
            osl_createDirectoryWithFlags( ustrDirectoryURL.pData, flags ) );
    }
 
    static RC remove( const ::rtl::OUString& ustrDirectoryURL )
    {
        return static_cast< RC >( osl_removeDirectory( ustrDirectoryURL.pData ) );
    }
 
    static RC createPath(
        const ::rtl::OUString& aDirectoryUrl,
        DirectoryCreationObserver* aDirectoryCreationObserver = NULL)
    {
        return static_cast< RC >(osl_createDirectoryPath(
            aDirectoryUrl.pData,
            aDirectoryCreationObserver ? onDirectoryCreated : NULL,
            aDirectoryCreationObserver));
    }
};
 
} /* namespace osl */
 
#endif // INCLUDED_OSL_FILE_HXX
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */