filespecutils.cpp
上传用户:dangjiwu
上传日期:2013-07-19
资源大小:42019k
文件大小:11k
源码类别:

Symbian

开发平台:

Visual C++

  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: filespecutils.cpp,v 1.1.50.3 2004/07/09 01:44:20 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  49. #include "hxtypes.h"
  50. #include "hlxclib/sys/stat.h"
  51. #include "hxtick.h"
  52. #include "hxrand.h"
  53. #include "filespecutils.h"
  54. #include "symbihxdataf.h"
  55. HX_RESULT CHXFileSpecUtils::GetFreeSpaceOnDisk(const CHXDirSpecifier& volSpec, INT64& freeSpace)
  56. {
  57.     HX_RESULT retVal = HXR_NOTIMPL;
  58.     
  59.     HX_ASSERT("GetFreeSpaceOnDisk Not written yet" == NULL);
  60.     return retVal;
  61. }
  62. //******************************************************************************
  63. HX_RESULT CHXFileSpecUtils::GetTotalSpaceOnDisk(const CHXDirSpecifier& volSpec, 
  64. INT64& totalSpace)
  65.     HX_RESULT retVal = HXR_NOTIMPL;
  66.     
  67.     HX_ASSERT("GetTotalSpaceOnDisk Not written yet" == NULL);
  68.     return retVal;
  69. }
  70. //******************************************************************************
  71. BOOL CHXFileSpecUtils::IsDiskEjectable(const CHXDirSpecifier& volSpec)
  72. {
  73.     BOOL bRetVal = FALSE;
  74.     
  75.     HX_ASSERT("IsDiskEjectable Not written yet" == NULL);
  76.     return bRetVal;
  77. }
  78. // IsLocal returns TRUE if the file or directory is on a local volume
  79. // (not on a server)
  80. //******************************************************************************
  81. /* Include correct headers to get more fs types below... */
  82. BOOL CHXFileSpecUtils::IsDiskLocal(const CHXDirSpecifier& volSpec)
  83. {
  84.     BOOL bRetVal = FALSE;
  85.     
  86.     HX_ASSERT("IsDiskLocal Not written yet" == NULL);
  87.     return bRetVal;
  88. }
  89. // file/dir utilities
  90. //******************************************************************** **********
  91. HX_RESULT CHXFileSpecUtils::RemoveDir(const CHXDirSpecifier& dirSpec)
  92. {
  93.     HX_RESULT retVal = HXR_NOTIMPL;
  94.     
  95.     HX_ASSERT("RemoveDir Not written yet" == NULL);
  96.     return retVal;
  97. };
  98. //******************************************************************** **********
  99. HX_RESULT CHXFileSpecUtils::RemoveFile(const CHXFileSpecifier& fileSpec)
  100. {
  101.     HX_RESULT retVal = HXR_FAILED;
  102.     CSymbIHXDataFile* pDataFile = new CSymbIHXDataFile();
  103.     if (pDataFile)
  104.     {
  105. pDataFile->AddRef();
  106. pDataFile->Bind(fileSpec.GetPathName());
  107. retVal = pDataFile->Delete();
  108. pDataFile->Close();
  109. pDataFile->Release();
  110.     }
  111.     return retVal;
  112. };
  113. //******************************************************************************
  114. HX_RESULT CHXFileSpecUtils::GetFileSize(const CHXFileSpecifier& fileSpec, INT64& fSize)
  115. {
  116.     HX_RESULT retVal = HXR_FAILED;
  117.     CSymbIHXDataFile* pDataFile = new CSymbIHXDataFile();
  118.     if (pDataFile)
  119.     {
  120. struct stat statBuffer;
  121. pDataFile->AddRef();
  122. pDataFile->Bind(fileSpec.GetPathName());
  123. retVal = pDataFile->Stat(&statBuffer);
  124. pDataFile->Close();
  125. pDataFile->Release();
  126. if (retVal == HXR_OK)
  127. {
  128.     fSize = statBuffer.st_size;
  129. }
  130.     }
  131.     return retVal;
  132. }
  133. //******************************************************************************
  134. HX_RESULT CHXFileSpecUtils::GetDirectorySize(const CHXDirSpecifier& dirSpec, BOOL shouldDescend, INT64& fSize)
  135. {
  136.     HX_RESULT retVal = HXR_NOTIMPL;
  137.     
  138.     HX_ASSERT("GetDirectorySize Not written yet" == NULL);
  139.     return retVal;
  140. }
  141. //******************************************************************************
  142. CHXFileSpecifier CHXFileSpecUtils::GetCurrentApplication(void)
  143. {
  144.     CHXFileSpecifier retSpecifier;
  145.     
  146.     HX_ASSERT("GetCurrentApplication Not written yet" == NULL);
  147.     return retSpecifier;
  148. }
  149. //******************************************************************************
  150. CHXDirSpecifier CHXFileSpecUtils::GetCurrentApplicationDir(void)
  151. {
  152.     CHXDirSpecifier retSpecifier;
  153.     
  154.     HX_ASSERT("GetCurrentApplicationDir Not written yet" == NULL);
  155.     return retSpecifier;
  156. }
  157. //******************************************************************************
  158. BOOL CHXFileSpecUtils::FileExists(const CHXFileSpecifier& fileSpec)
  159. {
  160.     HX_RESULT bRetVal = FALSE;
  161.     CSymbIHXDataFile* pDataFile = new CSymbIHXDataFile();
  162.     if (pDataFile)
  163.     {
  164. struct stat statBuffer;
  165. pDataFile->AddRef();
  166. pDataFile->Bind(fileSpec.GetPathName());
  167. bRetVal = (pDataFile->Stat(&statBuffer) == HXR_OK);
  168. pDataFile->Close();
  169. pDataFile->Release();
  170.     }
  171.     return bRetVal;
  172. }
  173. //******************************************************************************
  174. BOOL CHXFileSpecUtils::DirectoryExists(const CHXDirSpecifier& dirSpec)
  175. {
  176.     BOOL bRetVal = FALSE;
  177.     
  178.     HX_ASSERT("DirectoryExists Not written yet" == NULL);
  179.     return bRetVal;
  180. }
  181. //******************************************************************************
  182. HX_RESULT CHXFileSpecUtils::CreateDir(const CHXDirSpecifier& dirSpec)
  183. {
  184.     HX_RESULT retVal = HXR_NOTIMPL;
  185.     
  186.     HX_ASSERT("CreateDir Not written yet" == NULL);
  187.     return retVal;
  188. }
  189. //******************************************************************************
  190. static CHXFileSpecifier GetUniqueFileSpecInternal(const CHXDirSpecifier& locationSpec, 
  191.   const char *pszNameFirst, const char *pszTemplate, 
  192.   const char *pszWildcard, UINT32 nStartNum);
  193. const UINT32 kNumWrapValue = 9999+1; // limit insertions to 4-digit numbers
  194. CHXFileSpecifier CHXFileSpecUtils::GetUniqueFileSpec(const CHXDirSpecifier& locationSpec, 
  195.      const char *pszNameFirst, const char *pszTemplate, 
  196.      const char *pszWildcard)
  197. {
  198.     return GetUniqueFileSpecInternal(locationSpec, pszNameFirst, pszTemplate, pszWildcard, 0);
  199. }
  200. CHXFileSpecifier CHXFileSpecUtils::GetUniqueTempFileSpec(const CHXDirSpecifier& locationSpec, 
  201.  const char *pszTemplate, const char *pszWildcard)
  202. {
  203.     CMultiplePrimeRandom  rand(HX_GET_TICKCOUNT());
  204.     
  205.     UINT32 num;
  206.     
  207.     num = rand.GetRandomNumber();
  208.     
  209.     num %= kNumWrapValue;
  210.     
  211.     if (num == 0 || num == 1) num = 2;
  212.     
  213.     return GetUniqueFileSpecInternal(locationSpec, NULL, pszTemplate, pszWildcard, num);
  214. }
  215. static CHXFileSpecifier GetUniqueFileSpecInternal(const CHXDirSpecifier& locationSpec, 
  216.                                                   const char *pszNameFirst, const char *pszTemplate, 
  217.                                                   const char *pszWildcard, UINT32 nStartNum)
  218. {
  219.     CHXFileSpecifier  resultFileSpec;
  220.     
  221.     require_return(locationSpec.IsSet(), resultFileSpec);
  222.     require_return(pszTemplate != NULL && pszWildcard != NULL, resultFileSpec);
  223.     require_return(pszNameFirst != NULL || nStartNum != 0, resultFileSpec);
  224.     
  225.     CHXFileSpecifier  testFileSpec;
  226.     CHXDirSpecifier  testDirSpec;
  227.     CHXString strNumber;
  228.     CHXString strName;
  229.     UINT32 nCurrentNum;
  230.     
  231.     nCurrentNum = nStartNum;
  232.     
  233.     while (1) 
  234.     {
  235.         // if the number is non-zero, make a string from the template;
  236.         // if the number is zero, user the initial name string
  237.         if (nCurrentNum == 0)
  238.         {
  239.             // replace the wildcard in the template with the number string
  240.             strName = pszNameFirst;
  241.         }
  242.         else
  243.         {
  244.             // replace the wildcard in the template with the number string
  245.             strNumber.Empty();
  246.             strNumber.AppendULONG(nCurrentNum);
  247.     
  248.             strName = pszTemplate;
  249.             strName.FindAndReplace(pszWildcard, strNumber); // replace first wildcard with number string
  250.         }
  251.         // test if a file or directory exists with that name
  252.         testFileSpec = locationSpec.SpecifyChildFile(strName);
  253.         testDirSpec = locationSpec.SpecifyChildDirectory(strName);
  254.         if (CHXFileSpecUtils::FileExists(testFileSpec)
  255.             || CHXFileSpecUtils::DirectoryExists(testDirSpec))
  256.         {
  257.             // an item already has that name, so increment & wrap the number
  258.             nCurrentNum++;
  259.             nCurrentNum %= kNumWrapValue;
  260.     
  261.             // don't use 0 again, and skip 1 since "MyFile2.txt" logically follows "MyFile.txt"
  262.             if (nCurrentNum == 0 || nCurrentNum == 1) 
  263.             {
  264.                 nCurrentNum = 2; 
  265.             }
  266.     
  267.             // a quick sanity check
  268.             if (nCurrentNum == nStartNum)
  269.             {
  270.                 check(!"GetUniqueFileSpecInternal number wrapped");
  271.                 break;
  272.             }
  273.         }
  274.         else
  275.         {
  276.             // the name is unique
  277.             resultFileSpec = testFileSpec;
  278.             break;
  279.         }
  280.     } // while
  281.     
  282.     return resultFileSpec;
  283. }
  284. //******************************************************************************
  285. CHXDirSpecifier CHXFileSpecUtils::GetSystemTempDirectory()
  286. {
  287.     CHXDirSpecifier retSpecifier;
  288.     
  289.     HX_ASSERT("GetSystemTempDirectory Not written yet" == NULL);
  290.     return retSpecifier;
  291. }
  292. BOOL CHXFileSpecUtils::MakeNameLegal(char *pszName)
  293. {
  294.     BOOL bRetVal = FALSE;
  295.     
  296.     HX_ASSERT("MakeNameLegal Not written yet" == NULL);
  297.     return bRetVal;
  298. }
  299. //******************************************************************************
  300. CHXDirSpecifier 
  301. CHXFileSpecUtils::GetAppDataDir(const char* szAppName)
  302. {
  303.     CHXDirSpecifier retSpecifier;
  304.     
  305.     HX_ASSERT("GetAppDataDir Not written yet" == NULL);
  306.     return retSpecifier;
  307. }