My Project
UDK 3.2.7 C/C++ API Reference
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
file.hxx
Go to the documentation of this file.
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 #ifndef _OSL_FILE_HXX_
21 #define _OSL_FILE_HXX_
22 
23 #include "sal/config.h"
24 
25 #include <string.h>
26 
27 #include <cassert>
28 
29 #include <osl/time.h>
30 #include <rtl/ustring.hxx>
31 
32 #include <osl/file.h>
33 #include <rtl/byteseq.hxx>
34 
35 #include <stdio.h>
36 
37 namespace osl
38 {
39 
40 
41 // -----------------------------------------------------------------------------
49 class FileBase
50 {
51 public:
52 
53  enum RC {
99  E_invalidError = osl_File_E_invalidError, /* unmapped error: always last entry in enum! */
102  };
103 
104 
105 public:
106 
128  static inline RC getCanonicalName( const ::rtl::OUString& ustrRequestedURL, ::rtl::OUString& ustrValidURL )
129  {
130  return (RC) osl_getCanonicalName( ustrRequestedURL.pData, &ustrValidURL.pData );
131  }
132 
168  static inline RC getAbsoluteFileURL( const ::rtl::OUString& ustrBaseDirectoryURL, const ::rtl::OUString& ustrRelativeFileURL, ::rtl::OUString& ustrAbsoluteFileURL )
169  {
170  return (RC) osl_getAbsoluteFileURL( ustrBaseDirectoryURL.pData, ustrRelativeFileURL.pData, &ustrAbsoluteFileURL.pData );
171  }
172 
188  static inline RC getSystemPathFromFileURL( const ::rtl::OUString& ustrFileURL, ::rtl::OUString& ustrSystemPath )
189  {
190  return (RC) osl_getSystemPathFromFileURL( ustrFileURL.pData, &ustrSystemPath.pData );
191  }
192 
208  static inline RC getFileURLFromSystemPath( const ::rtl::OUString& ustrSystemPath, ::rtl::OUString& ustrFileURL )
209  {
210  return (RC) osl_getFileURLFromSystemPath( ustrSystemPath.pData, &ustrFileURL.pData );
211  }
212 
241  static inline RC searchFileURL( const ::rtl::OUString& ustrFileName, const ::rtl::OUString& ustrSearchPath, ::rtl::OUString& ustrFileURL )
242  {
243  return (RC) osl_searchFileURL( ustrFileName.pData, ustrSearchPath.pData, &ustrFileURL.pData );
244  }
245 
256  static inline RC getTempDirURL( ::rtl::OUString& ustrTempDirURL )
257  {
258  return (RC) osl_getTempDirURL( &ustrTempDirURL.pData );
259  }
260 
310  static inline RC createTempFile(
311  ::rtl::OUString* pustrDirectoryURL,
312  oslFileHandle* pHandle,
313  ::rtl::OUString* pustrTempFileURL)
314  {
315  rtl_uString* pustr_dir_url = pustrDirectoryURL ? pustrDirectoryURL->pData : 0;
316  rtl_uString** ppustr_tmp_file_url = pustrTempFileURL ? &pustrTempFileURL->pData : 0;
317 
318  return (RC) osl_createTempFile(pustr_dir_url, pHandle, ppustr_tmp_file_url);
319  }
320 };
321 
322 
323 // -----------------------------------------------------------------------------
329 class VolumeDevice : public FileBase
330 {
331  oslVolumeDeviceHandle _aHandle;
332 
333 public:
334 
338  VolumeDevice() : _aHandle( NULL )
339  {
340  }
341 
348  VolumeDevice( const VolumeDevice & rDevice )
349  {
350  _aHandle = rDevice._aHandle;
351  if ( _aHandle )
352  osl_acquireVolumeDeviceHandle( _aHandle );
353  }
354 
359  {
360  if ( _aHandle )
361  osl_releaseVolumeDeviceHandle( _aHandle );
362  }
363 
370  inline VolumeDevice & operator =( const VolumeDevice & rDevice )
371  {
372  oslVolumeDeviceHandle newHandle = rDevice._aHandle;
373 
374  if ( newHandle )
375  osl_acquireVolumeDeviceHandle( newHandle );
376 
377  if ( _aHandle )
378  osl_releaseVolumeDeviceHandle( _aHandle );
379 
380  _aHandle = newHandle;
381 
382  return *this;
383  }
384 
391  {
392  rtl::OUString aPath;
393  osl_getVolumeDeviceMountPath( _aHandle, &aPath.pData );
394  return aPath;
395  }
396 
397  friend class VolumeInfo;
398 };
399 
400 // -----------------------------------------------------------------------------
401 
402 class Directory;
403 
413 {
414  oslVolumeInfo _aInfo;
415  sal_uInt32 _nMask;
416  VolumeDevice _aDevice;
417 
422 
426  VolumeInfo& operator = ( VolumeInfo& );
427 
428 public:
429 
436  VolumeInfo( sal_uInt32 nMask ): _nMask( nMask )
437  {
438  _aInfo.uStructSize = sizeof( oslVolumeInfo );
439  memset( &_aInfo.uValidFields, 0, sizeof( oslVolumeInfo ) - sizeof( sal_uInt32 ) );
440  _aInfo.pDeviceHandle = &_aDevice._aHandle;
441  }
442 
447  {
448  if( _aInfo.ustrFileSystemName )
450  }
451 
460  inline sal_Bool isValid( sal_uInt32 nMask ) const
461  {
462  return ( nMask & _aInfo.uValidFields ) == nMask;
463  }
464 
471  inline sal_Bool getRemoteFlag() const
472  {
473  return 0 != (_aInfo.uAttributes & osl_Volume_Attribute_Remote);
474  }
475 
483  {
484  return 0 != (_aInfo.uAttributes & osl_Volume_Attribute_Removeable);
485  }
486 
494  {
495  return 0 != (_aInfo.uAttributes & osl_Volume_Attribute_CompactDisc);
496  }
497 
505  {
506  return 0 != (_aInfo.uAttributes & osl_Volume_Attribute_FloppyDisk);
507  }
508 
515  inline sal_Bool getFixedDiskFlag() const
516  {
517  return 0 != (_aInfo.uAttributes & osl_Volume_Attribute_FixedDisk);
518  }
519 
526  inline sal_Bool getRAMDiskFlag() const
527  {
528  return 0 != (_aInfo.uAttributes & osl_Volume_Attribute_RAMDisk);
529  }
530 
538  inline sal_uInt64 getTotalSpace() const
539  {
540  return _aInfo.uTotalSpace;
541  }
542 
550  inline sal_uInt64 getFreeSpace() const
551  {
552  return _aInfo.uFreeSpace;
553  }
554 
562  inline sal_uInt64 getUsedSpace() const
563  {
564  return _aInfo.uUsedSpace;
565  }
566 
574  inline sal_uInt32 getMaxNameLength() const
575  {
576  return _aInfo.uMaxNameLength;
577  }
578 
586  inline sal_uInt32 getMaxPathLength() const
587  {
588  return _aInfo.uMaxPathLength;
589  }
590 
598  inline ::rtl::OUString getFileSystemName() const
599  {
601  }
602 
603 
612  {
613  return _aDevice;
614  }
615 
623  {
625  }
626 
635  {
637  }
638 
639  friend class Directory;
640 };
641 
642 // -----------------------------------------------------------------------------
643 class DirectoryItem;
644 
651 {
652  oslFileStatus _aStatus;
653  sal_uInt32 _nMask;
654 
659 
663  FileStatus& operator = ( FileStatus& );
664 
665 public:
666 
667  enum Type {
676  };
677 
684  FileStatus( sal_uInt32 nMask ): _nMask( nMask )
685  {
686  _aStatus.uStructSize = sizeof( oslFileStatus );
687  memset( &_aStatus.uValidFields, 0, sizeof( oslFileStatus ) - sizeof( sal_uInt32 ) );
688  }
689 
694  {
695  if ( _aStatus.ustrFileURL )
696  rtl_uString_release( _aStatus.ustrFileURL );
697  if ( _aStatus.ustrLinkTargetURL )
699  if ( _aStatus.ustrFileName )
700  rtl_uString_release( _aStatus.ustrFileName );
701  }
702 
712  inline sal_Bool isValid( sal_uInt32 nMask ) const
713  {
714  return ( nMask & _aStatus.uValidFields ) == nMask;
715  }
716 
722  inline Type getFileType() const
723  {
724  SAL_INFO_IF(
725  !isValid(osl_FileStatus_Mask_Type), "sal.osl",
726  "no FileStatus Type determined");
728  ? static_cast< Type >(_aStatus.eType) : Unknown;
729  }
730 
740  inline sal_Bool isDirectory() const
741  {
742  return ( getFileType() == Directory || getFileType() == Volume );
743  }
744 
755  inline sal_Bool isRegular() const
756  {
757  return ( getFileType() == Regular );
758  }
759 
768  inline sal_Bool isLink() const
769  {
770  return ( getFileType() == Link );
771  }
772 
779  inline sal_uInt64 getAttributes() const
780  {
781  SAL_INFO_IF(
783  "no FileStatus Attributes determined");
784  return _aStatus.uAttributes;
785  }
786 
794  inline TimeValue getCreationTime() const
795  {
796  SAL_INFO_IF(
798  "no FileStatus CreationTime determined");
799  return _aStatus.aCreationTime;
800  }
801 
809  inline TimeValue getAccessTime() const
810  {
811  SAL_INFO_IF(
813  "no FileStatus AccessTime determined");
814  return _aStatus.aAccessTime;
815  }
816 
824  inline TimeValue getModifyTime() const
825  {
826  SAL_INFO_IF(
828  "no FileStatus ModifyTime determined");
829  return _aStatus.aModifyTime;
830  }
831 
838  inline sal_uInt64 getFileSize() const
839  {
840  SAL_INFO_IF(
842  "no FileStatus FileSize determined");
843  return _aStatus.uFileSize;
844  }
845 
852  inline ::rtl::OUString getFileName() const
853  {
854  SAL_INFO_IF(
856  "no FileStatus FileName determined");
858  ? rtl::OUString(_aStatus.ustrFileName) : rtl::OUString();
859  }
860 
861 
869  inline ::rtl::OUString getFileURL() const
870  {
871  SAL_INFO_IF(
873  "no FileStatus FileURL determined");
875  ? rtl::OUString(_aStatus.ustrFileURL) : rtl::OUString();
876  }
877 
885  inline ::rtl::OUString getLinkTargetURL() const
886  {
887  SAL_INFO_IF(
889  "no FileStatus LinkTargetURL determined");
892  }
893 
894  friend class DirectoryItem;
895 };
896 
897 
898 // -----------------------------------------------------------------------------
905 class File: public FileBase
906 {
907  oslFileHandle _pData;
908  ::rtl::OUString _aPath;
909 
913  File( File& );
914 
918  File& operator = ( File& );
919 
920 public:
921 
928  File( const ::rtl::OUString& ustrFileURL ): _pData( 0 ), _aPath( ustrFileURL ) {}
929 
933  inline ~File()
934  {
935  close();
936  }
937 
981  inline RC open( sal_uInt32 uFlags )
982  {
983  return (RC) osl_openFile( _aPath.pData, &_pData, uFlags );
984  }
985 
1000  inline RC close()
1001  {
1002  oslFileError Error = osl_File_E_BADF;
1003 
1004  if( _pData )
1005  {
1006  Error=osl_closeFile( _pData );
1007  _pData = NULL;
1008  }
1009 
1010  return (RC) Error;
1011  }
1012 
1030  inline RC setPos( sal_uInt32 uHow, sal_Int64 uPos ) SAL_WARN_UNUSED_RESULT
1031  {
1032  return (RC) osl_setFilePos( _pData, uHow, uPos );
1033  }
1034 
1051  inline RC getPos( sal_uInt64& uPos )
1052  {
1053  return (RC) osl_getFilePos( _pData, &uPos );
1054  }
1055 
1078  inline RC isEndOfFile( sal_Bool *pIsEOF )
1079  {
1080  return (RC) osl_isEndOfFile( _pData, pIsEOF );
1081  }
1082 
1101  inline RC setSize( sal_uInt64 uSize )
1102  {
1103  return (RC) osl_setFileSize( _pData, uSize );
1104  }
1105 
1126  inline RC getSize( sal_uInt64 &rSize )
1127  {
1128  return (RC) osl_getFileSize( _pData, &rSize );
1129  }
1130 
1163  inline RC read( void *pBuffer, sal_uInt64 uBytesRequested, sal_uInt64& rBytesRead )
1164  {
1165  return (RC) osl_readFile( _pData, pBuffer, uBytesRequested, &rBytesRead );
1166  }
1167 
1202  inline RC write(const void *pBuffer, sal_uInt64 uBytesToWrite, sal_uInt64& rBytesWritten)
1203  {
1204  return (RC) osl_writeFile( _pData, pBuffer, uBytesToWrite, &rBytesWritten );
1205  }
1206 
1207 
1232  inline RC readLine( ::rtl::ByteSequence& aSeq )
1233  {
1234  return (RC) osl_readLine( _pData, reinterpret_cast<sal_Sequence**>(&aSeq) );
1235  }
1236 
1268  inline RC sync() const
1269  {
1270  OSL_PRECOND(_pData, "File::sync(): File not open");
1271  return (RC)osl_syncFile(_pData);
1272  }
1273 
1300  inline static RC copy( const ::rtl::OUString& ustrSourceFileURL, const ::rtl::OUString& ustrDestFileURL )
1301  {
1302  return (RC) osl_copyFile( ustrSourceFileURL.pData, ustrDestFileURL.pData );
1303  }
1304 
1329  inline static RC move( const ::rtl::OUString& ustrSourceFileURL, const ::rtl::OUString& ustrDestFileURL )
1330  {
1331  return (RC) osl_moveFile( ustrSourceFileURL.pData, ustrDestFileURL.pData );
1332  }
1333 
1362  inline static RC remove( const ::rtl::OUString& ustrFileURL )
1363  {
1364  return (RC) osl_removeFile( ustrFileURL.pData );
1365  }
1366 
1382  inline static RC setAttributes( const ::rtl::OUString& ustrFileURL, sal_uInt64 uAttributes )
1383  {
1384  return (RC) osl_setFileAttributes( ustrFileURL.pData, uAttributes );
1385  }
1386 
1409  inline static RC setTime(
1410  const ::rtl::OUString& ustrFileURL,
1411  const TimeValue& rCreationTime,
1412  const TimeValue& rLastAccessTime,
1413  const TimeValue& rLastWriteTime )
1414  {
1415  return (RC) osl_setFileTime(
1416  ustrFileURL.pData,
1417  &rCreationTime,
1418  &rLastAccessTime,
1419  &rLastWriteTime );
1420  }
1421 
1422  friend class DirectoryItem;
1423 };
1424 
1425 // -----------------------------------------------------------------------------
1432 {
1433  oslDirectoryItem _pData;
1434 
1435 public:
1436 
1440  DirectoryItem(): _pData( NULL )
1441  {
1442  }
1443 
1447  DirectoryItem( const DirectoryItem& rItem ): _pData( rItem._pData)
1448  {
1449  if( _pData )
1450  osl_acquireDirectoryItem( _pData );
1451  }
1452 
1457  {
1458  if( _pData )
1459  osl_releaseDirectoryItem( _pData );
1460  }
1461 
1466  {
1467  if (&rItem != this)
1468  {
1469  if( _pData )
1470  osl_releaseDirectoryItem( _pData );
1471 
1472  _pData = rItem._pData;
1473 
1474  if( _pData )
1475  osl_acquireDirectoryItem( _pData );
1476  }
1477  return *this;
1478  }
1479 
1486  inline sal_Bool is()
1487  {
1488  return _pData != NULL;
1489  }
1490 
1525  static inline RC get( const ::rtl::OUString& ustrFileURL, DirectoryItem& rItem )
1526  {
1527  if( rItem._pData)
1528  {
1529  osl_releaseDirectoryItem( rItem._pData );
1530  rItem._pData = NULL;
1531  }
1532 
1533  return (RC) osl_getDirectoryItem( ustrFileURL.pData, &rItem._pData );
1534  }
1535 
1568  inline RC getFileStatus( FileStatus& rStatus )
1569  {
1570  return (RC) osl_getFileStatus( _pData, &rStatus._aStatus, rStatus._nMask );
1571  }
1572 
1589  inline sal_Bool isIdenticalTo( const DirectoryItem &pOther )
1590  {
1591  return osl_identicalDirectoryItem( _pData, pOther._pData );
1592  }
1593 
1594  friend class Directory;
1595 };
1596 
1597 //###########################################
1598 
1610 {
1611 public:
1613 
1623  virtual void DirectoryCreated(const rtl::OUString& aDirectoryUrl) = 0;
1624 };
1625 
1626 //###########################################
1627 // This just an internal helper function for
1628 // private use.
1629 extern "C" inline void SAL_CALL onDirectoryCreated(void* pData, rtl_uString* aDirectoryUrl)
1630 {
1631  (static_cast<DirectoryCreationObserver*>(pData))->DirectoryCreated(aDirectoryUrl);
1632 }
1633 
1640 class Directory: public FileBase
1641 {
1642  oslDirectory _pData;
1643  ::rtl::OUString _aPath;
1644 
1648  Directory( Directory& );
1649 
1653  Directory& operator = ( Directory& );
1654 
1655 public:
1656 
1664  Directory( const ::rtl::OUString& strPath ): _pData( 0 ), _aPath( strPath )
1665  {
1666  }
1667 
1672  {
1673  close();
1674  }
1675 
1694  inline RC open()
1695  {
1696  return (RC) osl_openDirectory( _aPath.pData, &_pData );
1697  }
1698 
1710  inline sal_Bool isOpen() { return _pData != NULL; }
1711 
1724  inline RC close()
1725  {
1726  oslFileError Error = osl_File_E_BADF;
1727 
1728  if( _pData )
1729  {
1730  Error=osl_closeDirectory( _pData );
1731  _pData = NULL;
1732  }
1733 
1734  return (RC) Error;
1735  }
1736 
1737 
1755  inline RC reset()
1756  {
1757  close();
1758  return open();
1759  }
1760 
1784  inline RC getNextItem( DirectoryItem& rItem, sal_uInt32 nHint = 0 )
1785  {
1786  if( rItem._pData )
1787  {
1788  osl_releaseDirectoryItem( rItem._pData );
1789  rItem._pData = 0;
1790  }
1791  return ( RC) osl_getNextDirectoryItem( _pData, &rItem._pData, nHint );
1792  }
1793 
1794 
1826  inline static RC getVolumeInfo( const ::rtl::OUString& ustrDirectoryURL, VolumeInfo& rInfo )
1827  {
1828  return (RC) osl_getVolumeInformation( ustrDirectoryURL.pData, &rInfo._aInfo, rInfo._nMask );
1829  }
1830 
1858  inline static RC create( const ::rtl::OUString& ustrDirectoryURL )
1859  {
1860  return (RC) osl_createDirectory( ustrDirectoryURL.pData );
1861  }
1862 
1891  inline static RC remove( const ::rtl::OUString& ustrDirectoryURL )
1892  {
1893  return (RC) osl_removeDirectory( ustrDirectoryURL.pData );
1894  }
1895 
1948  static RC createPath(
1949  const ::rtl::OUString& aDirectoryUrl,
1950  DirectoryCreationObserver* aDirectoryCreationObserver = NULL)
1951  {
1952  return (RC)osl_createDirectoryPath(
1953  aDirectoryUrl.pData,
1954  (aDirectoryCreationObserver) ? onDirectoryCreated : NULL,
1955  aDirectoryCreationObserver);
1956  }
1957 };
1958 
1959 } /* namespace osl */
1960 
1961 #endif /* _OSL_FILE_HXX_ */
1962 
1963 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */