开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > P2P编程 > 查看源码
FileBase.cpp
资源名称：GGBT.rar　[点击查看]
上传用户：lds876
上传日期：2013-05-25
资源大小：567k
文件大小：13k
源码类别：

P2P编程

开发平台：

Visual C++

FileBase.cpp：源码内容
  1. // FileBase.cpp: implementation of the FileBase class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "testbt.h"
  7. #include "FileBase.h"
  10. #ifdef _DEBUG
  11. #undef THIS_FILE
  12. static char THIS_FILE[]=__FILE__;
  13. #define new DEBUG_NEW
  14. #endif
  16. //////////////////////////////////////////////////////////////////////
  17. // Construction/Destruction
  18. //////////////////////////////////////////////////////////////////////
  19. bool CopyTextToClipboard(CString strSource)
  20. {
  21. bool bRet = true;
  22. // put strSource to clipboard.
  23. if(OpenClipboard(NULL))
  24. {
  25. EmptyClipboard();
  27. HGLOBAL clipbuffer = GlobalAlloc(GMEM_DDESHARE, strSource.GetLength()+1);
  28. if (clipbuffer) 
  29. {
  30. char * buffer = (char*)GlobalLock(clipbuffer);
  31. if (buffer)
  32. {
  33. strcpy(buffer, LPCSTR(strSource));
  34. GlobalUnlock(clipbuffer);
  35. SetClipboardData(CF_TEXT,clipbuffer);
  36. }
  37. else
  38. bRet = false;
  39. }
  40. else
  41. bRet = false;
  43. CloseClipboard();
  44. }
  45. else
  46. bRet = false;
  48. return true;
  49. }
  52. string FormatSizeK(BLONG lSize, bool bFloat)
  53. {
  54. assert(lSize >= 0);
  56. char szText[100] = {0};
  57. float lposition = (float)lSize/1024;
  59. if (bFloat)
  60. sprintf(szText, "%.2fK", lposition);
  61. else
  62. sprintf(szText, "%.0fK", lposition);
  64. return string(szText);
  65. }
  67. string FormatSizeM(BLONG lSize, bool bFloat)
  68. {
  69. assert(lSize >= 0);
  71. char szText[100] = {0};
  72. float lposition = (float)lSize/1024/1024;
  74. if (bFloat)
  75. sprintf(szText, "%.2fM", lposition);
  76. else
  77. sprintf(szText, "%.0fM", lposition);
  79. return string(szText);
  81. }
  83. string FormatSize(BLONG lSize, bool bFloat)
  84. {
  85. assert(lSize >= 0);
  86. char szText[100] = {0};
  87. float lposition = (float)lSize/1024/1024/1024;
  88. if (lposition >= 1)
  89. {
  90. if (bFloat)
  91. sprintf(szText, "%.2fG", lposition);
  92. else
  93. sprintf(szText, "%.0fG", lposition);
  94. return string(szText);
  95. }
  97. lposition = (float)lSize/1024/1024;
  98. if (lposition >= 1)
  99. {
  100. if (bFloat)
  101. sprintf(szText, "%.2fM", lposition);
  102. else
  103. sprintf(szText, "%.0fM", lposition);
  104. return string(szText);
  105. }
  107. lposition = (float)lSize/1024;
  108. if (lposition >= 1)
  109. {
  110. if (bFloat)
  111. sprintf(szText, "%.2fK", lposition);
  112. else
  113. sprintf(szText, "%.0fK", lposition);
  114. return string(szText);
  115. }
  117. sprintf(szText, "%dB", lSize);
  118. return string(szText);
  119. }
  121. long GetFileSize(string strFileName)
  122. {
  123. FILE* pfile = fopen(strFileName.data(), "rb");
  124. if (!pfile)
  125. {
  126. // assert(false);
  127. return 0;
  128. }
  130. int iRet = fseek(pfile, 0, SEEK_END);
  131. if (iRet)
  132. {
  133. assert(false);
  134. return 0;
  135. }
  137. long lsize = ftell(pfile);
  138. fclose(pfile);
  140. assert(lsize >= 0);
  141. return lsize;
  142. }
  144. bool MakesureFileCreate(string strFilePath)
  145. {
  146. char drive[_MAX_DRIVE];
  147. char dir[_MAX_DIR];
  148. char fname[_MAX_FNAME];
  149. char ext[_MAX_EXT];
  150. _splitpath(strFilePath.data(), drive, dir, fname, ext);
  151. if (!strlen(drive))
  152. return false;
  154. string strDir = drive;
  155. strDir += dir;
  156. if (strDir[strDir.size() - 1] != '\')
  157. strDir += '\';
  159. if (!MakeDirecotry(strDir))
  160. return false;
  162. return true;
  163. }
  165. bool MakeDirecotry(string strDir)
  166. {
  167. if (strDir.empty())
  168. return false;
  170. // make sure directory is absolute path.
  171. char drive[_MAX_DRIVE];
  172. char dir[_MAX_DIR];
  173. char fname[_MAX_FNAME];
  174. char ext[_MAX_EXT];
  175. _splitpath(strDir.data(), drive, dir, fname, ext);
  176. if (!strlen(drive))
  177. return false;
  179. CString strPath = strDir.data();
  181. int i = 0;
  182. while (true)
  183. {
  184. i = strPath.Find('\', i+1);
  185. if (i == -1) 
  186. break;
  188. string strTemp = strPath.Left(i);
  189. if (!CreateDirectory(strTemp.data(), 0))
  190. {
  191. /*
  192. DWORD dwErr = GetLastError();
  193. if (dwErr != ERROR_ALREADY_EXISTS)
  194. return false;
  195. //*/
  196. }
  197. }
  199. if (!CreateDirectory(strDir.data(), 0))
  200. {
  201. DWORD dwErr = GetLastError();
  202. if (dwErr != ERROR_ALREADY_EXISTS && dwErr != ERROR_ACCESS_DENIED)
  203. return false;
  204. }
  206. return true;
  207. }
  209. string formatDir(string strDir)
  210. {
  211. assert(!strDir.empty());
  213. string strRet;
  214. if (strDir[strDir.size() - 1] != '\')
  215. strDir += '\';
  217. return strDir;
  218. }
  220. static m_gMovingFiles = 0;
  222. int IsMovingFiles()
  223. {
  224. return m_gMovingFiles;
  225. }
  227. bool MoveDiretorySystem(vector<CString> vstrOld, CString strNew, HWND hWnd)
  228. {
  229. if (vstrOld.empty())
  230. {
  231. assert(false);
  232. return false;
  233. }
  235. DWORD dwAttr = GetFileAttributes(strNew);
  236. if (dwAttr ==  0xffffffff)
  237. {
  238. if (!MakeDirecotry(strNew.GetBuffer(0)))
  239. {
  240. assert(false);
  241. return false;
  242. }
  243. }
  245. //
  246. // Create the target dir, else move not create name dir.
  247. //
  249. char pstrOld[1024] = {0};
  250. char pstrNew[1024] = {0};
  251. memset(pstrOld, 0, 1024);
  252. memset(pstrNew, 0, 1024);
  254. char* pTempOld = pstrOld;
  255. char* pTempNew = pstrNew;
  257. bool bEmpty = true;
  258. for (int i=0; i<vstrOld.size(); i++)
  259. {
  260. CString strOld = vstrOld[i];
  262. string strName, strPath;
  263. SplitPathName(strOld.GetBuffer(0), strPath, strName);
  264. if (formatDir(strPath) == formatDir(strNew.GetBuffer(0)) )
  265. {
  266. // assert(false);
  267. // return true;
  268. continue;
  269. }
  271. strcpy(pTempOld, strOld.GetBuffer(0));
  272. strcpy(pTempNew, strNew.GetBuffer(0));
  274. pTempOld += strlen(pTempOld) + 1;
  275. pTempNew += strlen(pTempNew) + 1;
  277. bEmpty = false;
  278. }
  280. if (bEmpty) 
  281. {
  282. assert(false);
  283. return true;
  284. }
  287. SHFILEOPSTRUCT shFileOp;
  289. shFileOp.fAnyOperationsAborted = FALSE;
  290. shFileOp.lpszProgressTitle = "正在移动...";
  291. shFileOp.hwnd = hWnd;
  292. shFileOp.wFunc = FO_MOVE;
  293. shFileOp.pFrom = pstrOld;
  294. shFileOp.pTo = pstrNew;
  295. shFileOp.fFlags = FOF_ALLOWUNDO;// | FOF_RENAMEONCOLLISION | FOF_WANTMAPPINGHANDLE | ;
  296. shFileOp.hNameMappings = 0;
  298. m_gMovingFiles ++;
  300. int iRet = SHFileOperation(&shFileOp);
  302. m_gMovingFiles --;
  304. // WaitForSingleObject((HANDLE)iRet, 50000);
  305. //*/
  306. /*
  307. if(iRet)
  308. {
  309. shFileOp.pFrom = b;
  310. shFileOp.pTo = a;
  311. int iRet = SHFileOperation(&shFileOp);
  312. ASSERT(!iRet);
  313. }
  314. //*/
  316. // return shFileOp.fAnyOperationsAborted == false;
  317. return iRet == 0;
  318. }
  320. bool MoveDiretory(string strOld, string strNew)
  321. {
  322. strOld = formatDir(strOld);
  323. strNew = formatDir(strNew);
  325. if (_access(strOld.data(), 0))
  326. return true;
  328. if (strOld == strNew)
  329. return true;
  331. if (MoveFile(strOld.data(), strNew.data()))
  332. {
  333. assert(false);
  334. return true;
  335. }
  337. if (!MakeDirecotry(strNew))
  338. return false;
  341. WIN32_FIND_DATA FileData;   // Data structure describes the file found
  342. HANDLE hSearch;             // Search handle returned by FindFirstFile
  343. TCHAR szMsg[100];           // String to store the error message
  345. BOOL bFinished = FALSE;
  347. hSearch = FindFirstFile ((strOld + "*.*").data(), &FileData);
  348. if (hSearch == INVALID_HANDLE_VALUE)
  349. {
  350. wsprintf (szMsg, TEXT("No .TXT files found."));
  351. return true;
  352. }
  354. // Copy each .txt file to the new directory and change it to
  355. // read-only, if it is not already read-only.
  357. while (!bFinished)
  358. {
  359. string strNewPath = strNew + FileData.cFileName;
  360. string strOldPath = strOld + FileData.cFileName;
  362. if (!(FileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
  363. {
  364. if (!CopyFile (strOldPath.data(), strNewPath.data(), FALSE))
  365. {
  366. DWORD dwErr = GetLastError();
  368. // maybe the parent dir have subdir has the same name with the file, fail silently.
  369. if (dwErr != ERROR_ACCESS_DENIED)
  370. {
  371. wsprintf (szMsg, TEXT("Unable to copy file."));
  372. return false;
  373. }
  374. }
  375. }
  377. if (!FindNextFile (hSearch, &FileData))
  378. {
  379. bFinished = TRUE;
  381. if (GetLastError () == ERROR_NO_MORE_FILES)
  382. {
  383. wsprintf (szMsg, TEXT("Found all of the files."));
  384. return true;
  385. }
  386. else
  387. {
  388. wsprintf (szMsg, TEXT("Unable to find next file."));
  389. return false;
  390. }
  391. }
  392. }
  394. // Close the search handle.
  395. if (!FindClose (hSearch))
  396. {
  397. wsprintf (szMsg, TEXT("Unable to close search handle."));
  398. return false;
  399. }
  401. // Remove old files.
  403. return true;
  404. }
  407. bool DeleteDiretory(CString strOld)
  408. {
  409. //
  410. // dosn't exist.
  411. //
  412. DWORD dwAttr = GetFileAttributes(strOld);
  413. if (dwAttr ==  0xffffffff)
  414. return true;
  416. //
  417. // if file.
  418. //
  419. if (dwAttr != 0xffffffff && !(dwAttr & FILE_ATTRIBUTE_DIRECTORY))
  420. {
  421. if (!DeleteFile (strOld))
  422. {
  423. if (GetLastError() == ERROR_ACCESS_DENIED)
  424. {
  425. if (!SetFileAttributes(strOld, FILE_ATTRIBUTE_NORMAL))
  426. return false;
  427. if (!DeleteFile (strOld))
  428. return false;
  429. }
  430. }
  431. return true;
  432. }
  434. //
  435. // if directory.
  436. //
  437. strOld = formatDir(strOld.GetBuffer(0)).data();
  439. WIN32_FIND_DATA FileData;   // Data structure describes the file found
  440. BOOL bFinished = FALSE;
  441. HANDLE hSearch = FindFirstFile (strOld + "*.*", &FileData);
  442. if (hSearch == INVALID_HANDLE_VALUE)
  443. return false;
  445. while (!bFinished)
  446. {
  447. CString strOldPath = strOld + FileData.cFileName;
  449. if (string(FileData.cFileName) != "." &&
  450. string(FileData.cFileName) != ".." )
  451. {
  452. if (!DeleteDiretory(strOldPath))
  453. {
  454. FindClose (hSearch);
  455. return false;
  456. }
  457. }
  460. if (!FindNextFile (hSearch, &FileData))
  461. bFinished = TRUE;
  462. }
  464. // Close the search handle.
  465. if (!FindClose (hSearch))
  466. return false;
  468. if (!RemoveDirectory(strOld))
  469. return false;
  471. return true;
  472. }
  475. bool SplitPathName(string strFilePath, string& strPath, string& strName)
  476. {
  477. // get name map.
  478. if (strFilePath[strFilePath.size() - 1] == '\')
  479. strFilePath.erase(strFilePath.size() - 1);
  481. // copy file to db directory.
  482. char drive[_MAX_DRIVE];
  483. char dir[_MAX_DIR];
  484. char fname[_MAX_FNAME];
  485. char ext[_MAX_EXT];
  486. _splitpath(strFilePath.data(), drive, dir, fname, ext);
  487. if (!strlen(drive) || !strlen(fname))
  488. return false;
  490. strPath = drive;
  491. strPath += dir;
  493. strName = fname;
  494. strName += ext;
  495. return true;
  496. }
  499. ///////////////////////////////////////////////////////////////////////////
  500. // return val : if return string is empty, it is the user cancel select.
  502. /*
  503. string SelectFolder()
  504. {
  505. string strRet;
  506. LPMALLOC pMalloc;
  508.     if (::SHGetMalloc(&pMalloc) == NOERROR)
  509.     {
  510.         BROWSEINFO bi;
  511.         char pszBuffer[MAX_PATH];
  512.         LPITEMIDLIST pidl;
  513.         // Get help on BROWSEINFO struct - it's got all the bit settings.
  514.         bi.hwndOwner = AfxGetMainWnd()->GetSafeHwnd();
  515.         bi.pidlRoot = NULL;
  516.         bi.pszDisplayName = pszBuffer;
  517.         bi.lpszTitle = _T("Select a Starting Directory");
  518.         bi.ulFlags = BIF_RETURNFSANCESTORS | BIF_RETURNONLYFSDIRS; //|BIF_RETURNONLYFSDIRS|BIF_STATUSTEXT; //|BIF_VALIDATE|BIF_EDITBOX;
  519.         bi.lpfn = NULL;
  520.         bi.lParam = 0;
  521.         // This next call issues the dialog box.
  522.         if ((pidl = ::SHBrowseForFolder(&bi)) != NULL)
  523.         {
  524.             if (::SHGetPathFromIDList(pidl, pszBuffer))
  525.             { 
  526. strRet = pszBuffer;
  527.             }
  528.             pMalloc->Free(pidl);
  529.         }
  530.         // Release the shell's allocator.
  531.         pMalloc->Release();
  532.     }
  533. return strRet;
  535. }
  536. //*/
  538. #define BIF_USENEWUI 0x40
  539. int CALLBACK BrowseCallbackProc(HWND hwnd,UINT uMsg,LPARAM lp, LPARAM pData);
  541. bool SelectFolder(const CString strDefault, CString &strRet)
  542. {
  543. strRet.Empty();
  545. BROWSEINFO bi;
  546. TCHAR szDir[MAX_PATH];
  547. LPITEMIDLIST pidl;
  548. LPMALLOC pMalloc;
  550. if (SUCCEEDED(SHGetMalloc(&pMalloc))) 
  551. {
  552. ZeroMemory(&bi,sizeof(bi));
  553. bi.hwndOwner = NULL;
  554. bi.pszDisplayName = 0;
  555. bi.pidlRoot = 0;
  556. bi.ulFlags = BIF_RETURNONLYFSDIRS | BIF_STATUSTEXT | BIF_USENEWUI;
  557. bi.lpfn = BrowseCallbackProc;
  558. bi.lParam = (long)(LPCTSTR)strDefault;
  560. pidl = SHBrowseForFolder(&bi);
  561. if (pidl) 
  562. {
  563. if (SHGetPathFromIDList(pidl,szDir)) 
  564. {
  565. strRet = szDir;
  566. strRet.TrimLeft();
  567. strRet.TrimRight();
  568. if (!strRet.IsEmpty())
  569. {
  570. if(strRet.GetAt(strRet.GetLength()-1)!='\')
  571. strRet +="\";
  572. }
  573. }
  575. pMalloc->Free(pidl); pMalloc->Release();
  576. }
  577. }
  579. return strRet.IsEmpty() == 0;
  581. }     
  582.  int CALLBACK BrowseCallbackProc(HWND hwnd,UINT uMsg,LPARAM lp, LPARAM pData) 
  583.  {
  584.  TCHAR szDir[MAX_PATH];
  585.  
  586.  switch(uMsg) 
  587.  {
  588.  case BFFM_INITIALIZED: 
  589.  {
  590.  if (pData)
  591.  {
  592.  SendMessage(hwnd,BFFM_SETSELECTION,TRUE,(LPARAM)pData);
  593.  }
  594.  else if (GetCurrentDirectory(sizeof(szDir)/sizeof(TCHAR), szDir)) 
  595.  {
  596.  // WParam is TRUE since you are passing a path.
  597.  // It would be FALSE if you were passing a pidl.
  598.  SendMessage(hwnd,BFFM_SETSELECTION,TRUE,(LPARAM)szDir);
  599.  }
  600.  break;
  601.  }
  602.  case BFFM_SELCHANGED: 
  603.  {
  604.  // Set the status window to the currently selected path.
  605.  if (SHGetPathFromIDList((LPITEMIDLIST) lp ,szDir)) 
  606.  {
  607.  SendMessage(hwnd,BFFM_SETSTATUSTEXT,0,(LPARAM)szDir);
  608.  }
  609.  break;
  610.  }
  612.  default:
  613.  break;
  614.  }
  615.  return 0;
  616.  }
  618.  //////////////////////////////////////////////////////////////////
  619.  //
  620.  // if find return the index. else return -1.
  621.  //
  623. int binary_search_ex (vector<long> array, int x) 
  624. {
  625. const int n =  array.size();
  627. int lo = 0, hi = n, mid = 0;
  628. while(lo != hi) 
  629. {
  630. mid = lo + (hi - lo) / 2;
  631. if (x == array[mid]) 
  632. return mid;
  634. if (x < array[mid]) 
  635. hi = mid; 
  636. else 
  637. lo = mid + 1;
  638. }
  639. return -1;
  640. }