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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 金融证券系统 > 查看源码
SpArchive.cpp
资源名称：clking_src.rar　[点击查看]
上传用户：zhanglf88
上传日期：2013-11-19
资源大小：6036k
文件大小：13k
源码类别：

金融证券系统

开发平台：

Visual C++

SpArchive.cpp：源码内容
  1. /*
  2. Cross Platform Core Code.
  4. Copyright(R) 2001-2002 Balang Software.
  5. All rights reserved.
  7. Using:
  8. class CSPArchive;
  9. */
  10. #include "StdAfx.h"
  12. #ifdef _DEBUG
  13. #undef THIS_FILE
  14. static char THIS_FILE[] = __FILE__;
  15. #endif
  17. #ifdef _DEBUG
  18. #define new DEBUG_NEW
  19. #endif
  21. #ifndef _SP_ENABLE_INLINES
  22. #define _SPARCHIVE_INLINE
  23. #include "../Include/SpArchive.inl"
  24. #undef _SPARCHIVE_INLINE
  25. #endif
  27. ////////////////////////////////////////////////////////////////////////////
  28. // Archive object input/output
  30. // minimum buffer size
  31. enum { nBufSizeMin = 128 };
  33. // default amount to grow m_pLoadArray upon insert
  34. enum { nGrowSize = 64 };
  35. // default size of hash table in m_pStoreMap when storing
  36. enum { nHashSize = 137 };
  37. // default size to grow collision blocks when storing
  38. enum { nBlockSize = 16 };
  40. ////////////////////////////////////////////////////////////////////////////
  42. CSPArchive::CSPArchive(CSPFile* pFile, UINT nMode, int nBufSize, void* lpBuf)
  43. {
  44. SP_ASSERT_VALID(pFile);
  46. // initialize members not dependent on allocated buffer
  47. m_nMode = nMode;
  48. m_pFile = pFile;
  49. m_bForceFlat = TRUE;
  51. // initialize the buffer.  minimum size is 128
  52. m_lpBufStart = (BYTE*)lpBuf;
  53. m_bUserBuf = TRUE;
  54. m_bDirectBuffer = FALSE;
  56. if (nBufSize < nBufSizeMin)
  57. {
  58. // force use of private buffer of minimum size
  59. m_nBufSize = nBufSizeMin;
  60. m_lpBufStart = NULL;
  61. }
  62. else
  63. m_nBufSize = nBufSize;
  65. nBufSize = m_nBufSize;
  66. if (m_lpBufStart == NULL)
  67. {
  68. // check for CSPFile providing buffering support
  69. m_bDirectBuffer = m_pFile->GetBufferPtr(CSPFile::bufferCheck);
  70. if (!m_bDirectBuffer)
  71. {
  72. // no support for direct buffering, allocate new buffer
  73. m_lpBufStart = new BYTE[m_nBufSize];
  74. m_bUserBuf = FALSE;
  75. }
  76. else
  77. {
  78. // CSPFile* supports direct buffering!
  79. nBufSize = 0;   // will trigger initial FillBuffer
  80. }
  81. }
  83. if (!m_bDirectBuffer)
  84. {
  85. SP_ASSERT(m_lpBufStart != NULL);
  86. SP_ASSERT(SP_IsValidAddress(m_lpBufStart, nBufSize, IsStoring()));
  87. }
  88. m_lpBufMax = m_lpBufStart + nBufSize;
  89. m_lpBufCur = (IsLoading()) ? m_lpBufMax : m_lpBufStart;
  90. }
  92. CSPArchive::~CSPArchive()
  93. {
  94. // Close makes m_pFile NULL. If it is not NULL, we must Close the CSPArchive
  95. if (m_pFile != NULL && !(m_nMode & bNoFlushOnDelete))
  96. Close();
  98. Abort();    // abort completely shuts down the archive
  99. }
  101. void CSPArchive::Abort()
  102. {
  103. SP_ASSERT(m_bDirectBuffer || m_lpBufStart == NULL ||
  104. SP_IsValidAddress(m_lpBufStart, m_lpBufMax - m_lpBufStart, IsStoring()));
  105. SP_ASSERT(m_bDirectBuffer || m_lpBufCur == NULL ||
  106. SP_IsValidAddress(m_lpBufCur, m_lpBufMax - m_lpBufCur, IsStoring()));
  108. // disconnect from the file
  109. m_pFile = NULL;
  111. if (!m_bUserBuf)
  112. {
  113. SP_ASSERT(!m_bDirectBuffer);
  114. delete[] m_lpBufStart;
  115. m_lpBufStart = NULL;
  116. m_lpBufCur = NULL;
  117. }
  118. }
  120. void CSPArchive::Close()
  121. {
  122. SP_ASSERT_VALID(m_pFile);
  124. Flush();
  125. m_pFile = NULL;
  126. }
  128. UINT CSPArchive::Read(void* lpBuf, UINT nMax)
  129. {
  130. SP_ASSERT_VALID(m_pFile);
  132. if (nMax == 0)
  133. return 0;
  135. SP_ASSERT(lpBuf != NULL);
  136. SP_ASSERT(SP_IsValidAddress(lpBuf, nMax));
  137. SP_ASSERT(m_bDirectBuffer || m_lpBufStart != NULL);
  138. SP_ASSERT(m_bDirectBuffer || m_lpBufCur != NULL);
  139. SP_ASSERT(m_lpBufStart == NULL ||
  140. SP_IsValidAddress(m_lpBufStart, m_lpBufMax - m_lpBufStart, FALSE));
  141. SP_ASSERT(m_lpBufCur == NULL ||
  142. SP_IsValidAddress(m_lpBufCur, m_lpBufMax - m_lpBufCur, FALSE));
  143. SP_ASSERT(IsLoading());
  145. // try to fill from buffer first
  146. UINT nMaxTemp = nMax;
  147. UINT nTemp = min(nMaxTemp, (UINT)(m_lpBufMax - m_lpBufCur));
  148. memcpy(lpBuf, m_lpBufCur, nTemp);
  149. m_lpBufCur += nTemp;
  150. lpBuf = (BYTE*)lpBuf + nTemp;
  151. nMaxTemp -= nTemp;
  153. if (nMaxTemp != 0)
  154. {
  155. SP_ASSERT(m_lpBufCur == m_lpBufMax);
  157. // read rest in buffer size chunks
  158. nTemp = nMaxTemp - (nMaxTemp % m_nBufSize);
  159. UINT nRead = 0;
  161. UINT nLeft = nTemp;
  162. UINT nBytes;
  163. do
  164. {
  165. nBytes = m_pFile->Read(lpBuf, nLeft);
  166. lpBuf = (BYTE*)lpBuf + nBytes;
  167. nRead += nBytes;
  168. nLeft -= nBytes;
  169. }
  170. while ((nBytes > 0) && (nLeft > 0));
  172. nMaxTemp -= nRead;
  174. // read last chunk into buffer then copy
  175. if (nRead == nTemp)
  176. {
  177. SP_ASSERT(m_lpBufCur == m_lpBufMax);
  178. SP_ASSERT(nMaxTemp < (UINT)m_nBufSize);
  180. // fill buffer (similar to CSPArchive::FillBuffer, but no exception)
  181. if (!m_bDirectBuffer)
  182. {
  183. UINT nLeft = max(nMaxTemp, (UINT)m_nBufSize);
  184. UINT nBytes;
  185. BYTE* lpTemp = m_lpBufStart;
  186. nRead = 0;
  187. do
  188. {
  189. nBytes = m_pFile->Read(lpTemp, nLeft);
  190. lpTemp = lpTemp + nBytes;
  191. nRead += nBytes;
  192. nLeft -= nBytes;
  193. }
  194. while ((nBytes > 0) && (nLeft > 0) && nRead < nMaxTemp);
  196. m_lpBufCur = m_lpBufStart;
  197. m_lpBufMax = m_lpBufStart + nRead;
  198. }
  199. else
  200. {
  201. nRead = m_pFile->GetBufferPtr(CSPFile::bufferRead, m_nBufSize,
  202. (void**)&m_lpBufStart, (void**)&m_lpBufMax);
  203. SP_ASSERT(nRead == (UINT)(m_lpBufMax - m_lpBufStart));
  204. m_lpBufCur = m_lpBufStart;
  205. }
  207. // use first part for rest of read
  208. nTemp = min(nMaxTemp, (UINT)(m_lpBufMax - m_lpBufCur));
  209. memcpy(lpBuf, m_lpBufCur, nTemp);
  210. m_lpBufCur += nTemp;
  211. nMaxTemp -= nTemp;
  212. }
  213. }
  214. return nMax - nMaxTemp;
  215. }
  217. void CSPArchive::Write(const void* lpBuf, UINT nMax)
  218. {
  219. SP_ASSERT_VALID(m_pFile);
  221. if (nMax == 0)
  222. return;
  224. SP_ASSERT(lpBuf != NULL);
  225. SP_ASSERT(SP_IsValidAddress((void*)lpBuf, nMax, FALSE));  // read-only access needed
  226. SP_ASSERT(m_bDirectBuffer || m_lpBufStart != NULL);
  227. SP_ASSERT(m_bDirectBuffer || m_lpBufCur != NULL);
  228. SP_ASSERT(m_lpBufStart == NULL ||
  229. SP_IsValidAddress(m_lpBufStart, m_lpBufMax - m_lpBufStart));
  230. SP_ASSERT(m_lpBufCur == NULL ||
  231. SP_IsValidAddress(m_lpBufCur, m_lpBufMax - m_lpBufCur));
  232. SP_ASSERT(IsStoring());
  234. // copy to buffer if possible
  235. UINT nTemp = min(nMax, (UINT)(m_lpBufMax - m_lpBufCur));
  236. memcpy(m_lpBufCur, lpBuf, nTemp);
  237. m_lpBufCur += nTemp;
  238. lpBuf = (BYTE*)lpBuf + nTemp;
  239. nMax -= nTemp;
  241. if (nMax > 0)
  242. {
  243. Flush();    // flush the full buffer
  245. // write rest of buffer size chunks
  246. nTemp = nMax - (nMax % m_nBufSize);
  247. m_pFile->Write(lpBuf, nTemp);
  248. lpBuf = (BYTE*)lpBuf + nTemp;
  249. nMax -= nTemp;
  251. if (m_bDirectBuffer)
  252. {
  253. // sync up direct mode buffer to new file position
  254. SP_VERIFY(m_pFile->GetBufferPtr(CSPFile::bufferWrite, m_nBufSize,
  255. (void**)&m_lpBufStart, (void**)&m_lpBufMax) == (UINT)m_nBufSize);
  256. SP_ASSERT((UINT)m_nBufSize == (UINT)(m_lpBufMax - m_lpBufStart));
  257. m_lpBufCur = m_lpBufStart;
  258. }
  260. // copy remaining to active buffer
  261. SP_ASSERT(nMax < (UINT)m_nBufSize);
  262. SP_ASSERT(m_lpBufCur == m_lpBufStart);
  263. memcpy(m_lpBufCur, lpBuf, nMax);
  264. m_lpBufCur += nMax;
  265. }
  266. }
  268. void CSPArchive::Flush()
  269. {
  270. SP_ASSERT_VALID(m_pFile);
  271. SP_ASSERT(m_bDirectBuffer || m_lpBufStart != NULL);
  272. SP_ASSERT(m_bDirectBuffer || m_lpBufCur != NULL);
  273. SP_ASSERT(m_lpBufStart == NULL ||
  274. SP_IsValidAddress(m_lpBufStart, m_lpBufMax - m_lpBufStart, IsStoring()));
  275. SP_ASSERT(m_lpBufCur == NULL ||
  276. SP_IsValidAddress(m_lpBufCur, m_lpBufMax - m_lpBufCur, IsStoring()));
  278. if (IsLoading())
  279. {
  280. // unget the characters in the buffer, seek back unused amount
  281. if (m_lpBufMax != m_lpBufCur)
  282. m_pFile->Seek(-(m_lpBufMax - m_lpBufCur), CSPFile::current);
  283. m_lpBufCur = m_lpBufMax;    // empty
  284. }
  285. else
  286. {
  287. if (!m_bDirectBuffer)
  288. {
  289. // write out the current buffer to file
  290. if (m_lpBufCur != m_lpBufStart)
  291. m_pFile->Write(m_lpBufStart, m_lpBufCur - m_lpBufStart);
  292. }
  293. else
  294. {
  295. // commit current buffer
  296. if (m_lpBufCur != m_lpBufStart)
  297. m_pFile->GetBufferPtr(CSPFile::bufferCommit, m_lpBufCur - m_lpBufStart);
  298. // get next buffer
  299. SP_VERIFY(m_pFile->GetBufferPtr(CSPFile::bufferWrite, m_nBufSize,
  300. (void**)&m_lpBufStart, (void**)&m_lpBufMax) == (UINT)m_nBufSize);
  301. SP_ASSERT((UINT)m_nBufSize == (UINT)(m_lpBufMax - m_lpBufStart));
  302. }
  303. m_lpBufCur = m_lpBufStart;
  304. }
  305. }
  307. void CSPArchive::FillBuffer(UINT nBytesNeeded)
  308. {
  309. SP_ASSERT_VALID(m_pFile);
  310. SP_ASSERT(IsLoading());
  311. SP_ASSERT(m_bDirectBuffer || m_lpBufStart != NULL);
  312. SP_ASSERT(m_bDirectBuffer || m_lpBufCur != NULL);
  313. SP_ASSERT(nBytesNeeded > 0);
  314. SP_ASSERT(nBytesNeeded <= (UINT)m_nBufSize);
  315. SP_ASSERT(m_lpBufStart == NULL ||
  316. SP_IsValidAddress(m_lpBufStart, m_lpBufMax - m_lpBufStart, FALSE));
  317. SP_ASSERT(m_lpBufCur == NULL ||
  318. SP_IsValidAddress(m_lpBufCur, m_lpBufMax - m_lpBufCur, FALSE));
  320. UINT nUnused = m_lpBufMax - m_lpBufCur;
  321. ULONG nTotalNeeded = ((ULONG)nBytesNeeded) + nUnused;
  323. // fill up the current buffer from file
  324. if (!m_bDirectBuffer)
  325. {
  326. SP_ASSERT(m_lpBufCur != NULL);
  327. SP_ASSERT(m_lpBufStart != NULL);
  328. SP_ASSERT(m_lpBufMax != NULL);
  330. if (m_lpBufCur > m_lpBufStart)
  331. {
  332. // copy unused
  333. if ((int)nUnused > 0)
  334. {
  335. memmove(m_lpBufStart, m_lpBufCur, nUnused);
  336. m_lpBufCur = m_lpBufStart;
  337. m_lpBufMax = m_lpBufStart + nUnused;
  338. }
  340. // read to satisfy nBytesNeeded or nLeft if possible
  341. UINT nRead = nUnused;
  342. UINT nLeft = m_nBufSize-nUnused;
  343. UINT nBytes;
  344. BYTE* lpTemp = m_lpBufStart + nUnused;
  345. do
  346. {
  347. nBytes = m_pFile->Read(lpTemp, nLeft);
  348. lpTemp = lpTemp + nBytes;
  349. nRead += nBytes;
  350. nLeft -= nBytes;
  351. }
  352. while (nBytes > 0 && nLeft > 0 && nRead < nBytesNeeded);
  354. m_lpBufCur = m_lpBufStart;
  355. m_lpBufMax = m_lpBufStart + nRead;
  356. }
  357. }
  358. else
  359. {
  360. // seek to unused portion and get the buffer starting there
  361. if (nUnused != 0)
  362. m_pFile->Seek(-(LONG)nUnused, CSPFile::current);
  363. UINT nActual = m_pFile->GetBufferPtr(CSPFile::bufferRead, m_nBufSize,
  364. (void**)&m_lpBufStart, (void**)&m_lpBufMax);
  365. SP_ASSERT(nActual == (UINT)(m_lpBufMax - m_lpBufStart));
  366. m_lpBufCur = m_lpBufStart;
  367. }
  368. }
  370. void CSPArchive::WriteCount(DWORD dwCount)
  371. {
  372. if (dwCount < 0xFFFF)
  373. *this << (WORD)dwCount;
  374. else
  375. {
  376. *this << (WORD)0xFFFF;
  377. *this << dwCount;
  378. }
  379. }
  381. DWORD CSPArchive::ReadCount()
  382. {
  383. WORD wCount;
  384. *this >> wCount;
  385. if (wCount != 0xFFFF)
  386. return wCount;
  388. DWORD dwCount;
  389. *this >> dwCount;
  390. return dwCount;
  391. }
  393. // special functions for text file input and output
  395. void CSPArchive::WriteString(LPCTSTR lpsz)
  396. {
  397. SP_ASSERT(SP_IsValidString(lpsz));
  398. Write(lpsz, lstrlen(lpsz) * sizeof(TCHAR));
  399. }
  401. LPTSTR CSPArchive::ReadString(LPTSTR lpsz, UINT nMax)
  402. {
  403. // if nMax is negative (such a large number doesn't make sense given today's
  404. // 2gb address space), then assume it to mean "keep the newline".
  405. int nStop = (int)nMax < 0 ? -(int)nMax : (int)nMax;
  406. SP_ASSERT(SP_IsValidAddress(lpsz, (nStop+1) * sizeof(TCHAR)));
  408. TCHAR ch;
  409. int nRead = 0;
  411. while (nRead < nStop)
  412. {
  413. *this >> ch;
  415. // stop and end-of-line (trailing 'n' is ignored)
  416. if (ch == 'n' || ch == 'r')
  417. {
  418. if (ch == 'r')
  419. *this >> ch;
  420. // store the newline when called with negative nMax
  421. if ((int)nMax != nStop)
  422. lpsz[nRead++] = ch;
  423. break;
  424. }
  425. lpsz[nRead++] = ch;
  426. }
  428. lpsz[nRead] = '';
  429. return lpsz;
  430. }
  432. BOOL CSPArchive::ReadString(CSPString& rString)
  433. {
  434. rString.Empty();
  435. const int nMaxSize = 128;
  436. LPTSTR lpsz = rString.GetBuffer(nMaxSize);
  437. LPTSTR lpszResult;
  438. int nLen;
  439. for (;;)
  440. {
  441. lpszResult = ReadString(lpsz, (UINT)-nMaxSize); // store the newline
  442. rString.ReleaseBuffer();
  444. // if string is read completely or EOF
  445. if (lpszResult == NULL ||
  446. (nLen = lstrlen(lpsz)) < nMaxSize ||
  447. lpsz[nLen-1] == 'n')
  448. {
  449. break;
  450. }
  452. nLen = rString.GetLength();
  453. lpsz = rString.GetBuffer(nMaxSize + nLen) + nLen;
  454. }
  456. // remove 'n' from end of string if present
  457. lpsz = rString.GetBuffer(0);
  458. nLen = rString.GetLength();
  459. if (nLen != 0 && lpsz[nLen-1] == 'n')
  460. rString.GetBufferSetLength(nLen-1);
  462. return lpszResult != NULL;
  463. }
  465. ///////////////////////////////////////////////////////////////////////////////
  466. // CString serialization code
  467. // String format:
  468. //      UNICODE strings are always prefixed by 0xff, 0xfffe
  469. //      if < 0xff chars: len:BYTE, TCHAR chars
  470. //      if >= 0xff characters: 0xff, len:WORD, TCHAR chars
  471. //      if >= 0xfffe characters: 0xff, 0xffff, len:DWORD, TCHARs
  473. CSPArchive& operator<<(CSPArchive& ar, CSPString& string)
  474. {
  475. if (string.GetLength() < 255)
  476. {
  477. ar << (BYTE)string.GetLength();
  478. }
  479. else if (string.GetLength() < 0xfffe)
  480. {
  481. ar << (BYTE)0xff;
  482. ar << (WORD)string.GetLength();
  483. }
  484. else
  485. {
  486. ar << (BYTE)0xff;
  487. ar << (WORD)0xffff;
  488. ar << (DWORD)string.GetLength();
  489. }
  490. ar.Write(string.GetBuffer(string.GetLength()), string.GetLength()*sizeof(TCHAR));
  491. return ar;
  492. }
  494. // return string length or -1 if UNICODE string is found in the archive
  495. UINT _AfxReadStringLength(CSPArchive& ar)
  496. {
  497. DWORD nNewLen;
  499. // attempt BYTE length first
  500. BYTE bLen;
  501. ar >> bLen;
  503. if (bLen < 0xff)
  504. return bLen;
  506. // attempt WORD length
  507. WORD wLen;
  508. ar >> wLen;
  509. if (wLen == 0xfffe)
  510. {
  511. // UNICODE string prefix (length will follow)
  512. return (UINT)-1;
  513. }
  514. else if (wLen == 0xffff)
  515. {
  516. // read DWORD of length
  517. ar >> nNewLen;
  518. return (UINT)nNewLen;
  519. }
  520. else
  521. return wLen;
  522. }
  524. CSPArchive& operator>>(CSPArchive& ar, CSPString& string)
  525. {
  526. UINT nNewLen = _AfxReadStringLength(ar);
  527. if (nNewLen == (UINT)-1)
  528. SP_ASSERT(FALSE);
  530. // set length of string to new length
  531. string.Empty();
  532. char * lpBuf = string.GetBufferSetLength((int)nNewLen);
  534. // read in the characters
  535. if (nNewLen != 0)
  536. {
  537. // read new data
  538. if (ar.Read(lpBuf, nNewLen) != nNewLen)
  539. {
  540. SP_ASSERT( FALSE );
  541. //AfxThrowArchiveException(CArchiveException::endOfFile);
  542. return ar;
  543. }
  544. }
  545. return ar;
  546. }