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

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

金融证券系统

开发平台：

Visual C++

Container.cpp：源码内容
  1. /*
  2. Cross Platform Core Code.
  4. Copyright(R) 2001-2002 Balang Software.
  5. All rights reserved.
  7. Using:
  8. class CStockInfoArray;
  9. class CStockContainer;
  10. class CDomain;
  11. class CDomainContainer;
  12. */
  14. #include "stdafx.h"
  15. #include "../Include/Container.h"
  17. #ifdef _DEBUG
  18. #undef THIS_FILE
  19. static char THIS_FILE[]=__FILE__;
  20. #define new DEBUG_NEW
  21. #endif
  23. //////////////////////////////////////////////////////////////////////
  24. // class CStockContainer
  26. CStockContainer * CStockContainer::m_pSortContainer = NULL;
  28. //////////////////////////////////////////////////////////////////////
  29. // Construction/Destruction
  30. //////////////////////////////////////////////////////////////////////
  32. CStockContainer::CStockContainer()
  33. {
  34. m_nType = typeNone;
  35. m_dwDate = -1;
  36. m_nCurrentStock = -1;
  38. m_nSortVariantID = SLH_INVALID;
  39. m_bSortAscend = FALSE;
  40. }
  42. CStockContainer::~CStockContainer()
  43. {
  44. Clear( );
  45. }
  47. BOOL CStockContainer::Lock()
  48. {
  49. return m_mutex.Lock();
  50. }
  52. BOOL CStockContainer::UnLock()
  53. {
  54. return m_mutex.UnLock();
  55. }
  57. int CStockContainer::Add( CStockInfo &newElement )
  58. {
  59. CSPMutex::Scoped l(m_mutex);
  61. int nIndex = CStockInfoArray::Add(newElement);
  62. m_map.SetAt( newElement.GetStockCode(), (void *)nIndex );
  63. return nIndex;
  64. }
  66. BOOL CStockContainer::GetCurrentType( int *pType, CSPString * pDomain, DWORD *pdwDate )
  67. {
  68. CSPMutex::Scoped l(m_mutex);
  70. if( pType )
  71. *pType = m_nType;
  72. if( pDomain )
  73. *pDomain = m_strDomain;
  74. if( pdwDate )
  75. *pdwDate = m_dwDate;
  76. return TRUE;
  77. }
  79. BOOL CStockContainer::GetPioneerTechDate( DWORD * pdwDate )
  80. {
  81. CStockInfo info;
  82. if( GetStockInfo( STKLIB_CODE_MAIN, &info )
  83. && info.m_kdata.GetSize() > 0 )
  84. {
  85. *pdwDate = info.m_kdata.ElementAt(0).m_date;
  86. return TRUE;
  87. }
  88. return FALSE;
  89. }
  91. BOOL CStockContainer::GetLatestTechDate( DWORD * pdwDate )
  92. {
  93. CStockInfo info;
  94. if( GetStockInfo( STKLIB_CODE_MAIN, &info )
  95. && info.m_kdata.GetSize() > 0 )
  96. {
  97. *pdwDate = info.m_kdata.ElementAt(info.m_kdata.GetSize()-1).m_date;
  98. return TRUE;
  99. }
  100. return FALSE;
  101. }
  103. BOOL CStockContainer::GetTechDateArray( CSPDWordArray & dwArray )
  104. {
  105. CStockInfo info;
  106. if( GetStockInfo( STKLIB_CODE_MAIN, &info ) )
  107. {
  108. dwArray.SetSize( 0, info.m_kdata.GetSize()+10 );
  109. for( int i=0; i<info.m_kdata.GetSize(); i++ )
  110. dwArray.Add( info.m_kdata.ElementAt(i).m_date );
  111. return TRUE;
  112. }
  113. return FALSE;
  114. }
  116. BOOL CStockContainer::RetrieveFromStatic( int nType, LPCTSTR lpszDomain, CStrategy * pStrategy, DWORD dwDate )
  117. {
  118. CSPMutex::Scoped l(m_mutex);
  120. Clear( );
  122. if( nType == typeNone )
  123. {
  124. m_nType = typeNone;
  125. return TRUE;
  126. }
  128. if( nType < typeMin || nType > typeMax )
  129. return FALSE;
  130. m_nType = nType;
  132. m_dwDate = dwDate;
  134. CSPStringArray astrSpecify;
  136. switch( nType )
  137. {
  138. case typeAll:
  139. CopyData( AfxGetStockContainer() );
  140. break;
  141. case typeIndex:
  142. case typeA:
  143. case typeBond:
  144. case typeFund:
  145. case typeClassShaa:
  146. case typeClassShab:
  147. case typeClassSzna:
  148. case typeClassSznb:
  149. case typeClassShabond:
  150. case typeClassSznbond:
  151. case typeRight:
  152. {
  153. int nCount = 0;
  154. SetSize( 0, AfxGetStockContainer().GetSize() );
  155. for( int i=0; i<AfxGetStockContainer().GetSize(); i++ )
  156. {
  157. CStockInfo & info = AfxGetStockContainer().ElementAt(i);
  158. LONG stocktype = info.GetType();
  159. if( ( typeIndex == nType && CStock::typeshIndex == stocktype )
  160. || ( typeIndex == nType && CStock::typeszIndex == stocktype )
  161. || ( typeA == nType && (CStock::typeshA == stocktype || CStock::typeszA == stocktype) && !info.IsFund() )
  162. || ( typeBond == nType && (CStock::typeshBond == stocktype || CStock::typeszBond == stocktype) )
  163. || ( typeFund == nType && info.IsFund() )
  164. || ( typeClassShaa == nType && CStock::typeshA == stocktype )
  165. || ( typeClassShab == nType && CStock::typeshB == stocktype )
  166. || ( typeClassSzna == nType && CStock::typeszA == stocktype )
  167. || ( typeClassSznb == nType && CStock::typeszB == stocktype )
  168. || ( typeClassShabond == nType && CStock::typeshBond == stocktype )
  169. || ( typeClassSznbond == nType && CStock::typeszBond == stocktype )
  170. || ( typeRight == nType && (CStock::typeshRight == stocktype || CStock::typeszRight == stocktype) ) )
  171. {
  172. Add( info );
  173. nCount ++;
  174. }
  175. }
  176. SetSize( nCount );
  177. }
  178. break;
  179. case typeStrategy:
  180. {
  181. if( pStrategy )
  182. RetrieveSpecify( pStrategy->GetStocks() );
  183. }
  184. break;
  185. case typeGroup:
  186. {
  187. if( lpszDomain && strlen(lpszDomain) > 0 )
  188. {
  189. AfxGetGroupContainer().GetDomainStocks( lpszDomain, astrSpecify );
  190. RetrieveSpecify( astrSpecify );
  191. m_strDomain = lpszDomain;
  192. }
  193. else
  194. return AfxGetGroupContainer().GetAllDomainInfo( this, m_dwDate );
  195. }
  196. break;
  197. case typeDomain:
  198. {
  199. if( lpszDomain && strlen(lpszDomain) > 0 )
  200. {
  201. AfxGetDomainContainer().GetDomainStocks( lpszDomain, astrSpecify );
  202. RetrieveSpecify( astrSpecify );
  203. m_strDomain = lpszDomain;
  204. }
  205. else
  206. return AfxGetDomainContainer().GetAllDomainInfo( this, m_dwDate );
  207. }
  208. break;
  209. default:
  210. SP_ASSERT( FALSE );
  211. SetMap( );
  212. SetAverage( );
  213. return FALSE;
  214. }
  216. SetMap( );
  218. DWORD dwMainDate = -1;
  219. AfxGetStockContainer().GetCurrentType( NULL, NULL, &dwMainDate );
  220. if( m_dwDate != dwMainDate )
  221. OnDataChanged();
  222. else
  223. SetAverage( );
  224. return TRUE;
  225. }
  227. BOOL CStockContainer::ReRetrieveFromStatic( CStrategy * pStrategy, BOOL bUpToDate )
  228. {
  229. CSPMutex::Scoped l(m_mutex);
  231. int type;
  232. CSPString strDomain;
  233. DWORD dwDate;
  234. GetCurrentType( &type, &strDomain, &dwDate );
  235. if( bUpToDate )
  236. dwDate = -1;
  237. return RetrieveFromStatic( type, strDomain, pStrategy, dwDate );
  238. }
  240. BOOL CStockContainer::RetrieveSpecify( CSPStringArray & astr )
  241. {
  242. CSPMutex::Scoped l(m_mutex);
  244. SetSize( 0, astr.GetSize() );
  246. int nCount = 0;
  247. for( int i=0; i<astr.GetSize(); i++ )
  248. {
  249. CSPString string = astr.ElementAt(i);
  250. CStockInfo info;
  251. if( AfxGetStockContainer().GetStockInfo( string, &info ) )
  252. {
  253. Add( info );
  254. nCount ++;
  255. }
  256. }
  257. SetSize( nCount );
  259. return TRUE;
  260. }
  262. BOOL CStockContainer::GetStockInfo( const char * szCode, CStockInfo * pInfo, int * pid )
  263. {
  264. CSPMutex::Scoped l(m_mutex);
  266. if( NULL == szCode || strlen(szCode) <= 0 )
  267. return FALSE;
  269. void * pArrayID = NULL;
  270. if( m_map.Lookup( szCode, pArrayID ) )
  271. {
  272. if( ((int)pArrayID) >= 0 && ((int)pArrayID) < GetSize() )
  273. {
  274. CStockInfo & info = ElementAt((int)pArrayID);
  275. if( pInfo )
  276. *pInfo = info;
  277. if( pid )
  278. *pid = (int)pArrayID;
  279. return TRUE;
  280. }
  281. }
  283. return FALSE;
  284. }
  286. BOOL CStockContainer::SetCurrentStock( const char * szCode )
  287. {
  288. CSPMutex::Scoped l(m_mutex);
  290. int nStockIndex = -1;
  291. CStockInfo info;
  292. if( GetStockInfo( szCode, &info, &nStockIndex ) )
  293. return SetCurrentStock( nStockIndex );
  294. else
  295. {
  296. m_nCurrentStock = -1;
  297. m_strCurrentStockCode = szCode;
  298. return FALSE;
  299. }
  300. }
  302. BOOL CStockContainer::SetCurrentStock( int nStockIndex )
  303. {
  304. CSPMutex::Scoped l(m_mutex);
  306. if( nStockIndex >= 0 && nStockIndex < GetSize() )
  307. {
  308. m_nCurrentStock = nStockIndex;
  309. return TRUE;
  310. }
  311. return FALSE;
  312. }
  314. BOOL CStockContainer::GetCurrentStock( CStockInfo * pInfo )
  315. {
  316. CSPMutex::Scoped l(m_mutex);
  318. SP_ASSERT( pInfo );
  319. if( m_nCurrentStock >= 0 && m_nCurrentStock < GetSize() )
  320. {
  321. CStockInfo & info = ElementAt(m_nCurrentStock);
  322. if( pInfo )
  323. * pInfo = info;
  324. return TRUE;
  325. }
  326. else if( m_strCurrentStockCode.GetLength() > 0 )
  327. {
  328. CStockInfo info;
  329. info.SetStockCode( CStock::marketUnknown, m_strCurrentStockCode );
  330. if( pInfo )
  331. *pInfo = info;
  332. return TRUE;
  333. }
  334. return FALSE;
  335. }
  337. BOOL CStockContainer::GetPrevStock( CStockInfo * pInfo )
  338. {
  339. CSPMutex::Scoped l(m_mutex);
  341. SP_ASSERT( pInfo );
  343. if( GetSize() == 0 )
  344. return FALSE;
  346. if( m_nCurrentStock < 0 || m_nCurrentStock >= GetSize() )
  347. m_nCurrentStock = -1;
  349. if( m_auidSort.GetSize() == GetSize() )
  350. {
  351. if( m_nCurrentStock == -1 )
  352. m_nCurrentStock = m_auidSort[m_auidSort.GetSize()-1];
  353. else
  354. {
  355. for( int i=0; i<m_auidSort.GetSize(); i++ )
  356. {
  357. if( m_nCurrentStock == (int)m_auidSort[i] )
  358. break;
  359. }
  360. if( i >= m_auidSort.GetSize() || i == 0 )
  361. {
  362. m_nCurrentStock = -1;
  363. return FALSE;
  364. }
  365. i --;
  366. m_nCurrentStock = m_auidSort[i];
  367. }
  368. }
  369. else
  370. {
  371. if( m_nCurrentStock < 0 )
  372. m_nCurrentStock = GetSize()-1;
  373. else
  374. m_nCurrentStock --;
  375. if( m_nCurrentStock < 0 )
  376. {
  377. m_nCurrentStock = -1;
  378. return FALSE;
  379. }
  380. }
  382. if( m_nCurrentStock >= 0 && m_nCurrentStock < GetSize() )
  383. {
  384. CStockInfo & info = ElementAt(m_nCurrentStock);
  385. if( pInfo )
  386. * pInfo = info;
  387. return TRUE;
  388. }
  389. else
  390. m_nCurrentStock = -1;
  392. return FALSE;
  393. }
  395. BOOL CStockContainer::GetNextStock( CStockInfo * pInfo )
  396. {
  397. CSPMutex::Scoped l(m_mutex);
  399. SP_ASSERT( pInfo );
  401. if( GetSize() == 0 )
  402. return FALSE;
  404. if( m_nCurrentStock < 0 || m_nCurrentStock >= GetSize() )
  405. m_nCurrentStock = -1;
  407. if( m_auidSort.GetSize() == GetSize() )
  408. {
  409. if( m_nCurrentStock == -1 )
  410. m_nCurrentStock = m_auidSort[0];
  411. else
  412. {
  413. for( int i=0; i<m_auidSort.GetSize(); i++ )
  414. {
  415. if( m_nCurrentStock == (int)m_auidSort[i] )
  416. break;
  417. }
  418. i ++;
  419. if( i >= m_auidSort.GetSize() )
  420. {
  421. m_nCurrentStock = -1;
  422. return FALSE;
  423. }
  424. m_nCurrentStock = m_auidSort[i];
  425. }
  426. }
  427. else
  428. {
  429. if( m_nCurrentStock < 0 )
  430. m_nCurrentStock = 0;
  431. else
  432. m_nCurrentStock ++;
  433. if( m_nCurrentStock >= GetSize() )
  434. {
  435. m_nCurrentStock = -1;
  436. return FALSE;
  437. }
  438. }
  440. if( m_nCurrentStock >= 0 && m_nCurrentStock < GetSize() )
  441. {
  442. CStockInfo & info = ElementAt(m_nCurrentStock);
  443. if( pInfo )
  444. * pInfo = info;
  445. return TRUE;
  446. }
  447. else
  448. m_nCurrentStock = -1;
  450. return FALSE;
  451. }
  453. CStockInfo & CStockContainer::GetStockInfoByID( int nID )
  454. {
  455. CSPMutex::Scoped l(m_mutex);
  457. if( ID_STOCKCNTN_AVERAGE == nID )
  458. return m_infoAverage;
  459. if( ID_STOCKCNTN_WEIGHTAVERAGE == nID )
  460. return m_infoWeightAverage;
  461. if( nID >= 0 && nID < GetSize() )
  462. return ElementAt( nID );
  463. SP_ASSERT( FALSE );
  464. return m_infoNull;
  465. }
  467. CStockInfo & CStockContainer::GetStockInfoByIDSort( int nID )
  468. {
  469. CSPMutex::Scoped l(m_mutex);
  471. if( ID_STOCKCNTN_AVERAGE == nID )
  472. return m_infoAverage;
  473. if( ID_STOCKCNTN_WEIGHTAVERAGE == nID )
  474. return m_infoWeightAverage;
  475. if( m_auidSort.GetSize() == GetSize() 
  476. && nID >= 0 && nID < GetSize() )
  477. {
  478. if( m_auidSort[nID] >= 0 && (int)m_auidSort[nID] < GetSize() )
  479. return ElementAt(m_auidSort[nID]);
  480. }
  481. else if( nID >= 0 && nID < GetSize() )
  482. return ElementAt( nID );
  483. SP_ASSERT( FALSE );
  484. return m_infoNull;
  485. }
  487. CStockInfo & CStockContainer::GetAverage( )
  488. {
  489. return m_infoAverage;
  490. }
  492. CStockInfo & CStockContainer::GetWeightAverage( )
  493. {
  494. return m_infoWeightAverage;
  495. }
  497. BOOL CStockContainer::Load( CStDatabase * pDB, PROGRESS_CALLBACK fnCallback, void *cookie, int nProgStart, int nProgEnd )
  498. {
  499. CSPMutex::Scoped l(m_mutex);
  501. SP_ASSERT( nProgStart <= nProgEnd );
  502. SP_ASSERT( pDB );
  503. if( nProgStart > nProgEnd || NULL == pDB )
  504. return FALSE;
  506. Clear( );
  508. int nLen = pDB->LoadCodetable( *this );
  509. SetMap( );
  511. pDB->LoadBasetable( *this );
  512. // pDB->LoadKDataCache( *this, fnCallback, cookie, nProgStart, nProgEnd );
  514. m_nType = typeAll;
  515. m_dwDate = -1;
  517. OnDataChanged( );
  518. return TRUE;
  519. }
  521. void CStockContainer::OnDataChanged( )
  522. {
  523. CSPMutex::Scoped l(m_mutex);
  525. DWORD dateLatest = m_dwDate;
  526. if( -1 == dateLatest )
  527. AfxGetStockContainer().GetLatestTechDate( &dateLatest );
  529. for( int i=0; i<GetSize(); i++ )
  530. {
  531. CStockInfo & info = ElementAt(i);
  532. info.StatBaseIndex( dateLatest );
  533. info.StatTechIndex( dateLatest );
  534. }
  536. SetAverage( );
  537. }
  539. BOOL CStockContainer::ReloadBase( CStDatabase * pDB )
  540. {
  541. CSPMutex::Scoped l(m_mutex);
  543. SP_ASSERT( pDB );
  544. if( GetSize() <= 0 || NULL == pDB )
  545. return Load( NULL, NULL );
  546. pDB->LoadBasetable( *this );
  548. OnDataChanged();
  549. return TRUE;
  550. }
  552. BOOL CStockContainer::SetMap( )
  553. {
  554. CSPMutex::Scoped l(m_mutex);
  556. m_map.RemoveAll( );
  558. if( GetSize() == 0 )
  559. return TRUE;
  561. m_map.InitHashTable( GetSize() * 2 + 10 );
  563. for( int i=0; i<GetSize(); i++ )
  564. {
  565. CStockInfo &info = ElementAt(i);
  566. m_map.SetAt( info.GetStockCode(), (void *)i );
  567. }
  568. return TRUE;
  569. }
  571. BOOL CStockContainer::SetAverage( PROGRESS_CALLBACK fnCallback, void *cookie, int nProgStart, int nProgEnd )
  572. {
  573. CSPMutex::Scoped l(m_mutex);
  575. SP_ASSERT( nProgStart <= nProgEnd );
  576. if( nProgStart > nProgEnd )
  577. return FALSE;
  579. CStockInfo & ave = m_infoAverage;
  580. CStockInfo & wave = m_infoWeightAverage;
  582. ave.Clear( );
  583. wave.Clear( );
  585. ave.SetStockCode( CStock::marketUnknown, slh_avrcode );
  586. ave.SetStockName( slh_avrname );
  587. wave.SetStockCode( CStock::marketUnknown, slh_wavrcode );
  588. wave.SetStockName( slh_wavrname );
  590. ave.m_reporttype = CStock::reportUnknown;
  591. wave.m_reporttype = CStock::reportUnknown;
  593. float fTemp = 0;
  595. float dc[100], wdc[100];
  596. int i = 0;
  597. for( i=0; i<sizeof(dc)/sizeof(dc[0]); i++ ) dc[i] = 0.;
  598. for( i=0; i<sizeof(wdc)/sizeof(wdc[0]); i++ ) wdc[i] = (float)0.0001;
  600. int nProgressSegment = GetSize() / 25;
  601. float dProgressRatio = ( 0 == GetSize() ? 1 : ((float)(nProgEnd - nProgStart))/GetSize() );
  603. for( int nCount=0; nCount<GetSize(); nCount++ )
  604. {
  605. if( fnCallback && !(nCount % nProgressSegment) )
  606. fnCallback( PROG_PROGRESS, (int)(nProgStart+nCount*dProgressRatio), NULL, cookie );
  608. CStockInfo & info = ElementAt(nCount);
  610. float factor = 1; // (float)CStock::GetReportFactor( info.m_reporttype );
  612. if( CStock::typeshIndex == info.GetType() || CStock::typeszIndex == info.GetType()
  613. || CStock::typeshBond == info.GetType() || CStock::typeszBond == info.GetType() )
  614. continue;
  616. ave.m_datebase = info.m_datebase;
  617. ave.m_datetech = info.m_datetech;
  618. wave.m_datebase = info.m_datebase;
  619. wave.m_datetech = info.m_datetech;
  621. float w = info.m_fShare_count_total;
  623. /* 平均值 *********************************************************************/
  624. // ★技术数据
  625. int m = 0, n = 0;
  626. if( info.m_fLast > 1e-4 )
  627. {
  628. ave.m_fLast = ( ave.m_fLast * dc[m] + info.m_fLast )/(dc[m]+1); dc[m] += 1;
  629. wave.m_fLast = ( wave.m_fLast * wdc[n] + info.m_fLast * w )/(wdc[n]+w); wdc[n] += w;
  630. }
  631. m++; n++;
  632. if( info.m_fOpen > 1e-4 )
  633. {
  634. ave.m_fOpen = ( ave.m_fOpen * dc[m] + info.m_fOpen )/(dc[m]+1); dc[m] += 1;
  635. wave.m_fOpen = ( wave.m_fOpen * wdc[n] + info.m_fOpen * w )/(wdc[n]+w); wdc[n] += w;
  636. }
  637. m++; n++;
  638. if( info.m_fClose > 1e-4 )
  639. {
  640. ave.m_fClose = ( ave.m_fClose * dc[m] + info.m_fClose )/(dc[m]+1); dc[m] += 1;
  641. wave.m_fClose = ( wave.m_fClose * wdc[n] + info.m_fClose * w )/(wdc[n]+w); wdc[n] += w;
  642. }
  643. m++; n++;
  644. if( info.m_fHigh > 1e-4 )
  645. {
  646. ave.m_fHigh = ( ave.m_fHigh * dc[m] + info.m_fHigh )/(dc[m]+1); dc[m] += 1;
  647. wave.m_fHigh = ( wave.m_fHigh * wdc[n] + info.m_fHigh * w )/(wdc[n]+w); wdc[n] += w;
  648. }
  649. m++; n++;
  650. if( info.m_fLow > 1e-4 )
  651. {
  652. ave.m_fLow = ( ave.m_fLow * dc[m] + info.m_fLow )/(dc[m]+1); dc[m] += 1;
  653. wave.m_fLow = ( wave.m_fLow * wdc[n] + info.m_fLow * w )/(wdc[n]+w); wdc[n] += w;
  654. }
  655. m++; n++;
  656. if( info.m_fVolume > 1e-4 )
  657. {
  658. ave.m_fVolume = ( ave.m_fVolume * dc[m] + info.m_fVolume )/(dc[m]+1); dc[m] += 1;
  659. }
  660. m++; n++;
  661. if( info.m_fAmount > 1e-4 )
  662. {
  663. ave.m_fAmount = ( ave.m_fAmount * dc[m] + info.m_fAmount )/(dc[m]+1); dc[m] += 1;
  664. }
  666. for( i=0; i<sizeof(ave.m_fBuyPrice)/sizeof(ave.m_fBuyPrice[0]); i++ )
  667. {
  668. m++; n++;
  669. if( info.m_fBuyPrice[i] > 1e-4 )
  670. {
  671. ave.m_fBuyPrice[i] = ( ave.m_fBuyPrice[i] * dc[m] + info.m_fBuyPrice[i] )/(dc[m]+1); dc[m] += 1;
  672. wave.m_fBuyPrice[i] = ( wave.m_fBuyPrice[i] * wdc[n] + info.m_fBuyPrice[i] )/(wdc[n]+1); wdc[n] += w;
  673. }
  674. }
  675. for( i=0; i<sizeof(ave.m_fBuyVolume)/sizeof(ave.m_fBuyVolume[0]); i++ )
  676. {
  677. m++; n++;
  678. if( info.m_fBuyVolume[i] > 1e-4 )
  679. {
  680. ave.m_fBuyVolume[i] = ( ave.m_fBuyVolume[i] * dc[m] + info.m_fBuyVolume[i] )/(dc[m]+1); dc[m] += 1;
  681. wave.m_fBuyVolume[i] = ( wave.m_fBuyVolume[i] * wdc[n] + info.m_fBuyVolume[i] )/(wdc[n]+1); wdc[n] += w;
  682. }
  683. }
  684. for( i=0; i<sizeof(ave.m_fSellPrice)/sizeof(ave.m_fSellPrice[0]); i++ )
  685. {
  686. m++; n++;
  687. if( info.m_fSellPrice[i] > 1e-4 )
  688. {
  689. ave.m_fSellPrice[i] = ( ave.m_fSellPrice[i] * dc[m] + info.m_fSellPrice[i] )/(dc[m]+1); dc[m] += 1;
  690. wave.m_fSellPrice[i] = ( wave.m_fSellPrice[i] * wdc[n] + info.m_fSellPrice[i] )/(wdc[n]+1); wdc[n] += w;
  691. }
  692. }
  693. for( i=0; i<sizeof(ave.m_fSellVolume)/sizeof(ave.m_fSellVolume[0]); i++ )
  694. {
  695. m++; n++;
  696. if( info.m_fSellVolume[i] > 1e-4 )
  697. {
  698. ave.m_fSellVolume[i] = ( ave.m_fSellVolume[i] * dc[m] + info.m_fSellVolume[i] )/(dc[m]+1); dc[m] += 1;
  699. wave.m_fSellVolume[i] = ( wave.m_fSellVolume[i] * wdc[n] + info.m_fSellVolume[i] )/(wdc[n]+1); wdc[n] += w;
  700. }
  701. }
  703. // ★偿债能力
  704. m++; n++;
  705. if( fabs(info.m_fRatio_liquidity) > 1e-4 )
  706. {
  707. ave.m_fRatio_liquidity = ( ave.m_fRatio_liquidity * dc[m] + info.m_fRatio_liquidity )/(dc[m]+1); dc[m] += 1;
  708. wave.m_fRatio_liquidity = ( wave.m_fRatio_liquidity * wdc[n] + info.m_fRatio_liquidity * w )/(wdc[n]+w); wdc[n] += w;
  709. }
  710. m++; n++;
  711. if( fabs(info.m_fRatio_quick) > 1e-4 )
  712. {
  713. ave.m_fRatio_quick = ( ave.m_fRatio_quick * dc[m] + info.m_fRatio_quick )/(dc[m]+1); dc[m] += 1;
  714. wave.m_fRatio_quick = ( wave.m_fRatio_quick * wdc[n] + info.m_fRatio_quick * w )/(wdc[n]+w); wdc[n] += w;
  715. }
  716. m++; n++;
  717. if( fabs(info.m_fVelocity_receivables) > 1e-4 )
  718. {
  719. ave.m_fVelocity_receivables = ( ave.m_fVelocity_receivables * dc[m] + info.m_fVelocity_receivables )/(dc[m]+1); dc[m] += 1;
  720. wave.m_fVelocity_receivables= ( wave.m_fVelocity_receivables * wdc[n] + info.m_fVelocity_receivables * w )/(wdc[n]+w); wdc[n] += w;
  721. }
  723. // ★经营能力
  724. m++; n++;
  725. if( fabs(info.m_fVelocity_merchandise) > 1e-4 )
  726. {
  727. ave.m_fVelocity_merchandise = ( ave.m_fVelocity_merchandise * dc[m] + info.m_fVelocity_merchandise )/(dc[m]+1); dc[m] += 1;
  728. wave.m_fVelocity_merchandise= ( wave.m_fVelocity_merchandise * wdc[n] + info.m_fVelocity_merchandise * w )/(wdc[n]+w); wdc[n] += w;
  729. }
  730. m++; n++;
  731. if( fabs(info.m_fMain_income) > 1e-4 )
  732. {
  733. ave.m_fMain_income = ( ave.m_fMain_income * dc[m] + factor*info.m_fMain_income )/(dc[m]+1); dc[m] += 1;
  734. }
  735. m++; n++;
  736. if( fabs(info.m_fCash_ps) > 1e-4 )
  737. {
  738. ave.m_fCash_ps = ( ave.m_fCash_ps * dc[m] + factor*info.m_fCash_ps )/(dc[m]+1); dc[m] += 1;
  739. wave.m_fCash_ps = ( wave.m_fCash_ps * wdc[n] + factor * info.m_fCash_ps * w )/(wdc[n]+w); wdc[n] += w;
  740. }
  742. // ★盈利能力
  743. m++; n++;
  744. if( fabs(info.m_fProfit_margin) > 1e-4 )
  745. {
  746. ave.m_fProfit_margin = ( ave.m_fProfit_margin * dc[m] + info.m_fProfit_margin )/(dc[m]+1); dc[m] += 1;
  747. wave.m_fProfit_margin = ( wave.m_fProfit_margin * wdc[n] + info.m_fProfit_margin * w )/(wdc[n]+w); wdc[n] += w;
  748. }
  749. m++; n++;
  750. if( fabs(info.m_fNetasset_yield) > 1e-4 )
  751. {
  752. ave.m_fNetasset_yield = ( ave.m_fNetasset_yield * dc[m] + factor*info.m_fNetasset_yield )/(dc[m]+1); dc[m] += 1;
  753. wave.m_fNetasset_yield = ( wave.m_fNetasset_yield * wdc[n] + factor * info.m_fNetasset_yield * w )/(wdc[n]+w); wdc[n] += w;
  754. }
  756. // ★资本结构
  757. m++; n++;
  758. if( info.m_fShare_count_total > 1e-4 )
  759. {
  760. ave.m_fShare_count_total = ( ave.m_fShare_count_total * dc[m] + info.m_fShare_count_total )/(dc[m]+1); dc[m] += 1;
  761. }
  762. m++; n++;
  763. if( info.m_fShare_count_a > 1e-4 )
  764. {
  765. ave.m_fShare_count_a = ( ave.m_fShare_count_a * dc[m] + info.m_fShare_count_a )/(dc[m]+1); dc[m] += 1;
  766. }
  767. m++; n++;
  768. if( info.m_fShare_count_b > 1e-4 )
  769. {
  770. ave.m_fShare_count_b = ( ave.m_fShare_count_b * dc[m] + info.m_fShare_count_b )/(dc[m]+1); dc[m] += 1;
  771. }
  772. m++; n++;
  773. if( info.m_fShare_count_h > 1e-4 )
  774. {
  775. ave.m_fShare_count_h = ( ave.m_fShare_count_h * dc[m] + info.m_fShare_count_h )/(dc[m]+1); dc[m] += 1;
  776. }
  777. m++; n++;
  778. if( info.m_fShare_count_national > 1e-4 )
  779. {
  780. ave.m_fShare_count_national = ( ave.m_fShare_count_national * dc[m] + info.m_fShare_count_national )/(dc[m]+1); dc[m] += 1;
  781. }
  782. m++; n++;
  783. if( info.m_fShare_count_corp > 1e-4 )
  784. {
  785. ave.m_fShare_count_corp = ( ave.m_fShare_count_corp * dc[m] + info.m_fShare_count_corp )/(dc[m]+1); dc[m] += 1;
  786. }
  787. m++; n++;
  788. if( fabs(info.m_fProfit_psud) > 1e-4 )
  789. {
  790. ave.m_fProfit_psud = ( ave.m_fProfit_psud * dc[m] + info.m_fProfit_psud )/(dc[m]+1); dc[m] += 1;
  791. wave.m_fProfit_psud = ( wave.m_fProfit_psud * wdc[n] + info.m_fProfit_psud * w )/(wdc[n]+w); wdc[n] += w;
  792. }
  793. m++; n++;
  794. if( fabs(info.m_fAsset) > 1e-4 )
  795. {
  796. ave.m_fAsset = ( ave.m_fAsset * dc[m] + info.m_fAsset )/(dc[m]+1); dc[m] += 1;
  797. }
  798. m++; n++;
  799. if( fabs(info.m_fRatio_holderright) > 1e-4 )
  800. {
  801. ave.m_fRatio_holderright = ( ave.m_fRatio_holderright * dc[m] + info.m_fRatio_holderright )/(dc[m]+1); dc[m] += 1;
  802. wave.m_fRatio_holderright = ( wave.m_fRatio_holderright * wdc[n] + info.m_fRatio_holderright * w )/(wdc[n]+w); wdc[n] += w;
  803. }
  804. m++; n++;
  805. if( fabs(info.m_fRatio_longdebt) > 1e-4 )
  806. {
  807. ave.m_fRatio_longdebt = ( ave.m_fRatio_longdebt * dc[m] + info.m_fRatio_longdebt )/(dc[m]+1); dc[m] += 1;
  808. wave.m_fRatio_longdebt = ( wave.m_fRatio_longdebt * wdc[n] + info.m_fRatio_longdebt * w )/(wdc[n]+w); wdc[n] += w;
  809. }
  810. m++; n++;
  811. if( fabs(info.m_fRatio_debt) > 1e-4 )
  812. {
  813. ave.m_fRatio_debt = ( ave.m_fRatio_debt * dc[m] + info.m_fRatio_debt )/(dc[m]+1); dc[m] += 1;
  814. wave.m_fRatio_debt = ( wave.m_fRatio_debt * wdc[n] + info.m_fRatio_debt * w )/(wdc[n]+w); wdc[n] += w;
  815. }
  817. // ★投资收益能力
  818. m++; n++;
  819. if( fabs(info.m_fNetasset_ps) > 1e-4 )
  820. {
  821. ave.m_fNetasset_ps = ( ave.m_fNetasset_ps * dc[m] + info.m_fNetasset_ps )/(dc[m]+1); dc[m] += 1;
  822. wave.m_fNetasset_ps = ( wave.m_fNetasset_ps * wdc[n] + info.m_fNetasset_ps * w )/(wdc[n]+w); wdc[n] += w;
  823. }
  824. m++; n++;
  825. if( fabs(info.m_fNetasset_ps_regulate) > 1e-4 )
  826. {
  827. ave.m_fNetasset_ps_regulate = ( ave.m_fNetasset_ps_regulate * dc[m] + info.m_fNetasset_ps_regulate )/(dc[m]+1); dc[m] += 1;
  828. wave.m_fNetasset_ps_regulate= ( wave.m_fNetasset_ps_regulate * wdc[n] + info.m_fNetasset_ps_regulate * w )/(wdc[n]+w); wdc[n] += w;
  829. }
  830. m++; n++;
  831. if( fabs(info.m_fEps) > 1e-4 )
  832. {
  833. ave.m_fEps = ( ave.m_fEps * dc[m] + factor*info.m_fEps )/(dc[m]+1); dc[m] += 1;
  834. wave.m_fEps = ( wave.m_fEps * wdc[n] + factor * info.m_fEps * w )/(wdc[n]+w); wdc[n] += w;
  835. }
  836. m++; n++;
  837. if( fabs(info.m_fEps_deduct) > 1e-4 )
  838. {
  839. ave.m_fEps_deduct = ( ave.m_fEps_deduct * dc[m] + factor*info.m_fEps_deduct )/(dc[m]+1); dc[m] += 1;
  840. wave.m_fEps_deduct = ( wave.m_fEps_deduct * wdc[n] + factor * info.m_fEps_deduct * w )/(wdc[n]+w); wdc[n] += w;
  841. }
  842. m++; n++;
  843. if( fabs(info.m_fNet_profit) > 1e-4 )
  844. {
  845. ave.m_fNet_profit = ( ave.m_fNet_profit * dc[m] + factor*info.m_fNet_profit )/(dc[m]+1); dc[m] += 1;
  846. }
  847. m++; n++;
  848. if( fabs(info.m_fMain_profit) > 1e-4 )
  849. {
  850. ave.m_fMain_profit = ( ave.m_fMain_profit * dc[m] + factor*info.m_fMain_profit )/(dc[m]+1); dc[m] += 1;
  851. }
  852. m++; n++;
  853. if( fabs(info.m_fTotal_profit) > 1e-4 )
  854. {
  855. ave.m_fTotal_profit = ( ave.m_fTotal_profit * dc[m] + factor*info.m_fTotal_profit )/(dc[m]+1);dc[m] += 1;
  856. }
  858. // ★增长率
  859. m++; n++;
  860. ave.m_fProfit_inc = ( ave.m_fProfit_inc * dc[m] + info.m_fProfit_inc )/(dc[m]+1); dc[m] += 1;
  861. wave.m_fProfit_inc = ( wave.m_fProfit_inc * wdc[n] + info.m_fProfit_inc * w )/(wdc[n]+w); wdc[n] += w;
  863. m++; n++;
  864. ave.m_fIncome_inc = ( ave.m_fIncome_inc * dc[m] + info.m_fIncome_inc )/(dc[m]+1); dc[m] += 1;
  865. wave.m_fIncome_inc = ( wave.m_fIncome_inc * wdc[n] + info.m_fIncome_inc * w )/(wdc[n]+w); wdc[n] += w;
  867. m++; n++;
  868. ave.m_fAsset_inc = ( ave.m_fAsset_inc * dc[m] + info.m_fAsset_inc )/(dc[m]+1); dc[m] += 1;
  869. wave.m_fAsset_inc = ( wave.m_fAsset_inc * wdc[n] + info.m_fAsset_inc * w )/(wdc[n]+w); wdc[n] += w;
  871. // ★技术数据统计值
  872. m++; n++;
  873. if( fabs(STKLIB_DATA_INVALID - info.m_fYield_average) > 1e-4 )
  874. {
  875. ave.m_fYield_average = ( ave.m_fYield_average * dc[m] + info.m_fYield_average )/(dc[m]+1); dc[m] += 1;
  876. wave.m_fYield_average = ( wave.m_fYield_average * wdc[n] + info.m_fYield_average * w )/(wdc[n]+w); wdc[n] += w;
  877. m++; n++;
  878. if( fabs(STKLIB_DATA_INVALID - info.m_fYield_stddev) > 1e-4 )
  879. {
  880. ave.m_fYield_stddev = ( ave.m_fYield_stddev * dc[m] + info.m_fYield_stddev )/(dc[m]+1); dc[m] += 1;
  881. wave.m_fYield_stddev= ( wave.m_fYield_stddev * wdc[n] + info.m_fYield_stddev * w )/(wdc[n]+w); wdc[n] += w;
  882. }
  883. }
  884. m++; n++;
  885. if( fabs(STKLIB_DATA_INVALID - info.m_fBeite) > 1e-4 )
  886. {
  887. ave.m_fBeite = ( ave.m_fBeite * dc[m] + info.m_fBeite )/(dc[m]+1); dc[m] += 1;
  888. wave.m_fBeite = ( wave.m_fBeite * wdc[n] + info.m_fBeite * w )/(wdc[n]+w); wdc[n] += w;
  889. }
  891. // K线数据
  892. m++; n++;
  893. if( 0 == nCount )
  894. {
  895. m_infoAverage.m_kdata = info.m_kdata;
  896. m_infoWeightAverage.m_kdata = info.m_kdata;
  897. }
  898. for( int k=info.m_kdata.GetSize()-1; k>=0; k-- )
  899. {
  900. KDATA & kdInfo = info.m_kdata.ElementAt(k);
  901. // 平均值
  902. int nIndex = k;
  903. if( nIndex >= m_infoAverage.m_kdata.GetSize() || m_infoAverage.m_kdata.ElementAt(nIndex).m_date != kdInfo.m_date )
  904. nIndex = m_infoAverage.m_kdata.GetIndexByDate(kdInfo.m_date);
  905. if( -1 == nIndex )
  906. {
  907. KDATA kdNew;
  908. memset( &kdNew, 0, sizeof(kdNew) );
  909. kdNew.m_date = kdInfo.m_date;
  910. nIndex = m_infoAverage.m_kdata.InsertKDataSort(kdNew);
  911. }
  912. if( -1 == nIndex )
  913. continue;
  914. KDATA & kdAve = m_infoAverage.m_kdata.ElementAt(nIndex);
  915. kdAve.m_fOpen = (kdAve.m_fOpen * dc[m] + kdInfo.m_fOpen)/(dc[m]+1);
  916. kdAve.m_fHigh = (kdAve.m_fHigh * dc[m] + kdInfo.m_fHigh)/(dc[m]+1);
  917. kdAve.m_fLow = (kdAve.m_fLow * dc[m] + kdInfo.m_fLow)/(dc[m]+1);
  918. kdAve.m_fClose = (kdAve.m_fClose * dc[m] + kdInfo.m_fClose)/(dc[m]+1);
  919. kdAve.m_fVolume = (kdAve.m_fVolume * dc[m] + kdInfo.m_fVolume)/(dc[m]+1);
  920. kdAve.m_fAmount = (kdAve.m_fAmount * dc[m] + kdInfo.m_fAmount)/(dc[m]+1);
  922. // 加权平均值
  923. nIndex = k;
  924. if( nIndex >= m_infoWeightAverage.m_kdata.GetSize() || m_infoWeightAverage.m_kdata.ElementAt(nIndex).m_date != kdInfo.m_date )
  925. nIndex = m_infoWeightAverage.m_kdata.GetIndexByDate(kdInfo.m_date);
  926. if( -1 == nIndex )
  927. {
  928. KDATA kdNew;
  929. memset( &kdNew, 0, sizeof(kdNew) );
  930. kdNew.m_date = kdInfo.m_date;
  931. nIndex = m_infoWeightAverage.m_kdata.InsertKDataSort(kdNew);
  932. }
  933. if( -1 == nIndex )
  934. continue;
  935. KDATA & kdWAve = m_infoWeightAverage.m_kdata.ElementAt(nIndex);
  936. kdWAve.m_fOpen = (kdWAve.m_fOpen * wdc[n] + kdInfo.m_fOpen * w)/(wdc[n]+w);
  937. kdWAve.m_fHigh = (kdWAve.m_fHigh * wdc[n] + kdInfo.m_fHigh * w)/(wdc[n]+w);
  938. kdWAve.m_fLow = (kdWAve.m_fLow * wdc[n] + kdInfo.m_fLow * w)/(wdc[n]+w);
  939. kdWAve.m_fClose = (kdWAve.m_fClose * wdc[n] + kdInfo.m_fClose * w)/(wdc[n]+w);
  940. kdWAve.m_fVolume = (kdWAve.m_fVolume * wdc[n] + kdInfo.m_fVolume * w)/(wdc[n]+w);
  941. kdWAve.m_fAmount = (kdWAve.m_fAmount * wdc[n] + kdInfo.m_fAmount * w)/(wdc[n]+w);
  942. }
  943. dc[m] += 1;
  944. wdc[n] += w;
  946. SP_ASSERT( m <= sizeof(dc)/sizeof(dc[0]) );
  947. SP_ASSERT( n <= sizeof(wdc)/sizeof(wdc[0]) );
  949. }
  951. if( fnCallback )
  952. fnCallback( PROG_PROGRESS, nProgEnd, NULL, cookie );
  954. return TRUE;
  955. }
  957. BOOL CStockContainer::Clear( )
  958. {
  959. CSPMutex::Scoped l(m_mutex);
  961. ClearVariantSaveValue( );
  963. // WARNING: Cannot clear this m_nCurrentStock = -1;
  964. // WARNING: Cannot clear this m_strCurrentStockCode.Empty();
  965. m_nType = typeNone;
  966. m_strDomain.Empty();
  967. m_dwDate = -1;
  968. RemoveAll();
  969. m_map.RemoveAll( );
  970. m_infoAverage.Clear( );
  971. m_infoWeightAverage.Clear( );
  973. m_auidSort.RemoveAll();
  974. return TRUE;
  975. }
  977. void CStockContainer::CopyData( CStockContainer & src )
  978. {
  979. CSPMutex::Scoped l(m_mutex);
  981. SetSize( src.GetSize() );
  982. for( int i=0; i<src.GetSize(); i++ )
  983. {
  984. CStockInfo & info = src.ElementAt(i);
  985. SetAt( i, info );
  986. }
  987. }
  989. int CStockContainer::SortFunction(const void *s1,const void *s2)
  990. {
  991. CStockInfo *pStock1 = (CStockInfo *)s1;
  992. CStockInfo *pStock2 = (CStockInfo *)s2;
  994. if( NULL == pStock2 )
  995. return 1;
  997. if( NULL == pStock1 )
  998. return -1;
  1000. if( NULL == CStockContainer::m_pSortContainer )
  1001. return 1;
  1003. int nRet = AfxCompareVariantValue( CStockContainer::m_pSortContainer->m_nSortVariantID, *pStock1, *pStock2,
  1004. CStockContainer::m_pSortContainer );
  1005. if( CStockContainer::m_pSortContainer->m_bSortAscend )
  1006. return nRet;
  1007. if( nRet > 0 )
  1008. return -1;
  1009. else if( nRet < 0 )
  1010. return 1;
  1011. return 0;
  1012. }
  1014. int CStockContainer::StockInfoCompareFunc( const void *s1,const void *s2, CStockContainer * pContainer, int nSortVariantID )
  1015. {
  1016. CStockInfo *pStock1 = (CStockInfo *)s1;
  1017. CStockInfo *pStock2 = (CStockInfo *)s2;
  1019. if( NULL == pStock2 )
  1020. return 1;
  1022. if( NULL == pStock1 )
  1023. return -1;
  1025. return AfxCompareVariantValue( nSortVariantID, *pStock1, *pStock2, pContainer );
  1026. }
  1029. BOOL CStockContainer::Sort( int nSortVariantID, BOOL bAscend )
  1030. {
  1031. CSPMutex::Scoped l(m_mutex);
  1033. m_auidSort.RemoveAll(); // if call this Sort(...), then not use m_auidSort
  1035. CStockContainer::m_pSortContainer = this;
  1036. m_nSortVariantID = nSortVariantID;
  1037. m_bSortAscend = bAscend;
  1039. if( NULL != GetData() )
  1040. qsort( GetData(), GetSize(), sizeof(CStockInfo), SortFunction );
  1041. return TRUE;
  1042. }
  1044. void CStockContainer::SetSortID( CSPDWordArray & auidsort )
  1045. {
  1046. CSPMutex::Scoped l(m_mutex);
  1048. m_auidSort.RemoveAll();
  1049. m_auidSort.Copy( auidsort );
  1050. }
  1052. BOOL CStockContainer::GetMultiSortIDArray( CSPDWordArray & adwSortID, LONG lStockType, UINT nSLH, BOOL bAsc, int nCount )
  1053. {
  1054. CSPMutex::Scoped l(m_mutex);
  1056. SP_ASSERT( nCount > 0 && nSLH >= SLH_MIN && nSLH <= SLH_MAX );
  1057. if( nCount <= 0 || nSLH < SLH_MIN || nSLH > SLH_MAX )
  1058. return FALSE;
  1060. adwSortID.RemoveAll();
  1062. for( int n=0; n<nCount; n++ )
  1063. {
  1064. int nMinMaxIndex = -1;
  1065. double dMinMaxValue = 0;
  1066. BOOL bInited = FALSE;
  1067. for( int i=0; i<GetSize(); i++ )
  1068. {
  1069. CStockInfo & info = ElementAt(i);
  1071. // 股票类型
  1072. if( info.GetType() != lStockType )
  1073. continue;
  1075. // 如果加过，则继续寻找下一个
  1076. for( int k=0; k<adwSortID.GetSize(); k++ )
  1077. {
  1078. if( adwSortID[k] == (DWORD)i )
  1079. break;
  1080. }
  1081. if( k != adwSortID.GetSize() )
  1082. continue;
  1084. // 判断大小
  1085. double dValue = 0;
  1086. if( AfxGetVariantValue( nSLH, info, &dValue, NULL ) )
  1087. {
  1088. if( !bInited )
  1089. {
  1090. nMinMaxIndex = i;
  1091. dMinMaxValue = dValue;
  1092. bInited = TRUE;
  1093. }
  1094. if( bAsc && dValue < dMinMaxValue )
  1095. {
  1096. nMinMaxIndex = i;
  1097. dMinMaxValue = dValue;
  1098. }
  1099. if( !bAsc && dValue > dMinMaxValue )
  1100. {
  1101. nMinMaxIndex = (DWORD)i;
  1102. dMinMaxValue = dValue;
  1103. }
  1104. }
  1105. }
  1107. if( -1 == nMinMaxIndex )
  1108. break;
  1109. adwSortID.Add( nMinMaxIndex );
  1110. }
  1112. return TRUE;
  1113. }
  1115. BOOL CStockContainer::GetVariantSaveValue( double *pValue, UINT nVariantID, CStockInfo &info, BOOL *pNoValue )
  1116. {
  1117. CSPMutex::Scoped l(m_mutex);
  1119. void * pArrayID = NULL;
  1120. if( !m_map.Lookup( info.GetStockCode(), pArrayID ) )
  1121. return FALSE;
  1123. int nIndex = (int)pArrayID;
  1124. if( nIndex >= 0 && nIndex < m_aptrSaveValueArray.GetSize() )
  1125. {
  1126. CSPPtrArray * pArray = (CSPPtrArray *)m_aptrSaveValueArray.ElementAt( nIndex );
  1127. if( pArray )
  1128. {
  1129. VARIANT_SAVEVALUE * pSave = NULL;
  1130. for( int j=0; j<pArray->GetSize(); j++ )
  1131. {
  1132. pSave = (VARIANT_SAVEVALUE *) pArray->GetAt(j);
  1133. if( pSave->nVariantID == nVariantID )
  1134. {
  1135. if( pValue ) *pValue = pSave->Value;
  1136. if( pNoValue ) *pNoValue = pSave->bNoValue;
  1137. return TRUE;
  1138. }
  1139. }
  1140. }
  1141. }
  1143. return FALSE;
  1144. }
  1146. void CStockContainer::SetVariantSaveValue( double Value, UINT nVariantID, CStockInfo &info, BOOL bNoValue )
  1147. {
  1148. CSPMutex::Scoped l(m_mutex);
  1150. void * pArrayID = NULL;
  1151. if( !m_map.Lookup( info.GetStockCode(), pArrayID ) )
  1152. return;
  1154. // alloc for m_aptrSaveValueArray
  1155. if( m_aptrSaveValueArray.GetSize() == 0 )
  1156. {
  1157. m_aptrSaveValueArray.SetSize( GetSize() );
  1158. for( int i=0; i<m_aptrSaveValueArray.GetSize(); i++ )
  1159. m_aptrSaveValueArray.SetAt( i, NULL );
  1160. }
  1162. int nIndex = (int)pArrayID;
  1163. if( nIndex >= 0 && nIndex < m_aptrSaveValueArray.GetSize() )
  1164. {
  1165. CSPPtrArray * pArray = (CSPPtrArray *)m_aptrSaveValueArray.ElementAt( nIndex );
  1166. if( NULL == pArray )
  1167. {
  1168. pArray = new CSPPtrArray;
  1169. m_aptrSaveValueArray.SetAt( nIndex, pArray );
  1170. }
  1172. // 如果已经存在，覆盖之
  1173. for( int j=0; j<pArray->GetSize(); j++ )
  1174. {
  1175. VARIANT_SAVEVALUE * pSave = (VARIANT_SAVEVALUE *) pArray->GetAt(j);
  1176. if( pSave->nVariantID == nVariantID )
  1177. {
  1178. pSave->Value = Value;
  1179. pSave->bNoValue = bNoValue;
  1180. return;
  1181. }
  1182. }
  1184. // 加入新的
  1185. VARIANT_SAVEVALUE * pSaveValue = new VARIANT_SAVEVALUE;
  1186. pSaveValue->nVariantID = nVariantID;
  1187. pSaveValue->Value = Value;
  1188. pSaveValue->bNoValue = bNoValue;
  1189. pArray->Add( pSaveValue );
  1190. }
  1191. }
  1193. void CStockContainer::ClearVariantSaveValue( )
  1194. {
  1195. CSPMutex::Scoped l(m_mutex);
  1197. for( int i=0; i<m_aptrSaveValueArray.GetSize(); i++ )
  1198. {
  1199. CSPPtrArray * pArray = (CSPPtrArray *)m_aptrSaveValueArray.ElementAt( i );
  1200. if( pArray )
  1201. {
  1202. for( int j=0; j<pArray->GetSize(); j++ )
  1203. delete pArray->GetAt(j);
  1204. delete pArray;
  1205. }
  1206. }
  1207. m_aptrSaveValueArray.RemoveAll();
  1208. }
  1210. //////////////////////////////////////////////////////////////////////
  1211. // class CDomain
  1213. CDomain::CDomain( )
  1214. {
  1215. }
  1217. CDomain::CDomain( const CDomain &src )
  1218. {
  1219. *this = src;
  1220. }
  1222. CDomain::~CDomain( )
  1223. {
  1224. }
  1226. BOOL CDomain::AddStock( LPCTSTR lpszStockCode )
  1227. {
  1228. if( NULL == lpszStockCode || strlen(lpszStockCode) <= 0 )
  1229. return FALSE;
  1231. for( int k=0; k<GetSize(); k++ )
  1232. {
  1233. int nCmp = ElementAt(k).CompareNoCase(lpszStockCode);
  1234. if( 0 == nCmp )
  1235. return FALSE;
  1236. }
  1238. Add( lpszStockCode );
  1239. return TRUE;
  1240. }
  1242. BOOL CDomain::AddStockSort( LPCTSTR lpszStockCode )
  1243. {
  1244. if( NULL == lpszStockCode || strlen(lpszStockCode) <= 0 )
  1245. return FALSE;
  1247. for( int k=0; k<GetSize(); k++ )
  1248. {
  1249. int nCmp = ElementAt(k).CompareNoCase(lpszStockCode);
  1250. if( 0 == nCmp )
  1251. return FALSE;
  1252. if( nCmp > 0 )
  1253. {
  1254. InsertAt(k, lpszStockCode );
  1255. return TRUE;
  1256. }
  1257. }
  1259. Add( lpszStockCode );
  1260. return TRUE;
  1261. }
  1263. BOOL CDomain::RemoveStock( LPCTSTR lpszStockCode )
  1264. {
  1265. if( NULL == lpszStockCode || strlen(lpszStockCode) <= 0 )
  1266. return FALSE;
  1268. for( int k=0; k<GetSize(); k++ )
  1269. {
  1270. if( 0 == ElementAt(k).CompareNoCase(lpszStockCode) )
  1271. {
  1272. RemoveAt(k);
  1273. return TRUE;
  1274. }
  1275. }
  1276. return FALSE;
  1277. }
  1279. CDomain &CDomain::operator = ( const CDomain &src )
  1280. {
  1281. m_strName = src.m_strName;
  1282. Copy( src );
  1283. return *this;
  1284. }
  1286. struct fxj_block_t {
  1287. WORD wMarket;
  1288. char szCode[10];
  1289. };
  1291. int CDomain::AddFxjDomain( LPCTSTR lpszFile )
  1292. {
  1293. CSPFile file;
  1294. DWORD dwMagic;
  1295. if( !file.Open( lpszFile, CSPFile::modeRead )
  1296. || sizeof(dwMagic) != file.Read(&dwMagic,sizeof(dwMagic)) || dwMagic != 0xFF5100A5 )
  1297. return 0;
  1299. int nCount = 0;
  1300. struct fxj_block_t stock;
  1301. while( sizeof(stock) == file.Read(&stock,sizeof(stock)) )
  1302. {
  1303. if( 0 == stock.szCode[6] )
  1304. {
  1305. CSPString sCode = stock.szCode;
  1306. if( sCode.GetLength() == 4 )
  1307. sCode = "00" + sCode;
  1308. if( sCode.GetLength() == 6 )
  1309. AddStock( sCode );
  1310. }
  1311. }
  1313. return GetSize();
  1314. }
  1317. //////////////////////////////////////////////////////////////////////
  1318. // class CDomainContainer
  1320. CDomainContainer::CDomainContainer( )
  1321. {
  1322. }
  1324. CDomainContainer::CDomainContainer( CDomainContainer & src )
  1325. {
  1326. *this = src;
  1327. }
  1329. CDomainContainer::~CDomainContainer( )
  1330. {
  1331. RemoveAll( );
  1332. }
  1334. CDomainContainer & CDomainContainer::operator = ( CDomainContainer & src )
  1335. {
  1336. SetSize( src.GetSize() );
  1337. for( int i=0; i<src.GetSize(); i++ )
  1338. {
  1339. CDomain domain = src.ElementAt(i);
  1340. SetAt( i, domain );
  1341. }
  1342. return *this;
  1343. }
  1345. int CDomainContainer::AddDomain( LPCTSTR lpszDomainName )
  1346. {
  1347. if( NULL == lpszDomainName || strlen(lpszDomainName) <=0  )
  1348. return -1;
  1349. CDomain newdomain;
  1350. newdomain.m_strName = lpszDomainName;
  1351. return AddDomain( newdomain );
  1352. }
  1354. int CDomainContainer::AddDomain( CDomain & newdomain )
  1355. {
  1356. if( 0 == newdomain.m_strName.GetLength() )
  1357. return -1;
  1359. for( int i=0; i<GetSize(); i++ )
  1360. {
  1361. CDomain & domain = ElementAt(i);
  1362. if( 0 == newdomain.m_strName.CompareNoCase( domain.m_strName ) )
  1363. return -1;
  1364. }
  1365. return Add( newdomain );
  1366. }
  1368. int CDomainContainer::AddDomainReplace( CDomain & newdomain )
  1369. {
  1370. if( 0 == newdomain.m_strName.GetLength() )
  1371. return -1;
  1373. for( int i=0; i<GetSize(); i++ )
  1374. {
  1375. CDomain & domain = ElementAt(i);
  1376. if( 0 == newdomain.m_strName.CompareNoCase( domain.m_strName ) )
  1377. {
  1378. SetAt( i, newdomain );
  1379. return i;
  1380. }
  1381. }
  1382. return Add( newdomain );
  1383. }
  1385. int CDomainContainer::AddDomainReplace( CDomainContainer & newdomains )
  1386. {
  1387. int nCount = 0;
  1388. for( int i=0; i<newdomains.GetSize(); i++ )
  1389. {
  1390. if( AddDomainReplace( newdomains.ElementAt(i) ) >= 0 )
  1391. nCount ++;
  1392. }
  1393. return nCount;
  1394. }
  1396. BOOL CDomainContainer::RemoveDomain( LPCTSTR lpszDomainName )
  1397. {
  1398. if( NULL == lpszDomainName || strlen(lpszDomainName) <= 0 )
  1399. return FALSE;
  1401. for( int i=0; i<GetSize(); i++ )
  1402. {
  1403. CDomain & domain = ElementAt(i);
  1404. if( 0 == domain.m_strName.CompareNoCase( lpszDomainName ) )
  1405. {
  1406. RemoveAt( i );
  1407. return TRUE;
  1408. }
  1409. }
  1411. return FALSE;
  1412. }
  1414. BOOL CDomainContainer::AddDomainStock( LPCTSTR lpszDomainName, LPCTSTR lpszStockCode )
  1415. {
  1416. if( NULL == lpszDomainName || strlen(lpszDomainName) < 0
  1417. || NULL == lpszStockCode || strlen(lpszStockCode) < 0 )
  1418. return FALSE;
  1420. for( int i=0; i<GetSize(); i++ )
  1421. {
  1422. CDomain & domain = ElementAt(i);
  1423. if( 0 == domain.m_strName.CompareNoCase( lpszDomainName ) )
  1424. {
  1425. return domain.AddStock( lpszStockCode );
  1426. }
  1427. }
  1429. return FALSE;
  1430. }
  1432. BOOL CDomainContainer::AddDomainStock( LPCTSTR lpszDomainName, CSPStringArray & astr )
  1433. {
  1434. if( NULL == lpszDomainName || strlen(lpszDomainName) < 0 )
  1435. return FALSE;
  1437. for( int i=0; i<GetSize(); i++ )
  1438. {
  1439. CDomain & domain = ElementAt(i);
  1440. if( 0 == domain.m_strName.CompareNoCase( lpszDomainName ) )
  1441. {
  1442. for( int j=0; j<astr.GetSize(); j++ )
  1443. domain.AddStock( astr.ElementAt(j) );
  1444. return TRUE;
  1445. }
  1446. }
  1448. return FALSE;
  1449. }
  1451. BOOL CDomainContainer::RemoveDomainStock( LPCTSTR lpszDomainName, LPCTSTR lpszStockCode )
  1452. {
  1453. if( NULL == lpszDomainName || strlen(lpszDomainName) < 0
  1454. || NULL == lpszStockCode || strlen(lpszStockCode) < 0 )
  1455. return FALSE;
  1457. for( int i=0; i<GetSize(); i++ )
  1458. {
  1459. CDomain & domain = ElementAt(i);
  1460. if( 0 == domain.m_strName.CompareNoCase( lpszDomainName ) )
  1461. {
  1462. for( int k=0; k<domain.GetSize(); k++ )
  1463. {
  1464. if( 0 == domain.ElementAt(k).CompareNoCase(lpszStockCode) )
  1465. {
  1466. domain.RemoveAt(k);
  1467. return TRUE;
  1468. }
  1469. }
  1470. break;
  1471. }
  1472. }
  1474. return FALSE;
  1475. }
  1477. BOOL CDomainContainer::RemoveDomainStockAll( LPCTSTR lpszDomainName )
  1478. {
  1479. if( NULL == lpszDomainName || strlen(lpszDomainName) < 0 )
  1480. return FALSE;
  1482. for( int i=0; i<GetSize(); i++ )
  1483. {
  1484. CDomain & domain = ElementAt(i);
  1485. if( 0 == domain.m_strName.CompareNoCase( lpszDomainName ) )
  1486. {
  1487. domain.RemoveAll();
  1488. return TRUE;
  1489. }
  1490. }
  1492. return FALSE;
  1493. }
  1495. BOOL CDomainContainer::GetDomainStocks( LPCTSTR lpszDomain, CSPStringArray &astr )
  1496. {
  1497. if( NULL == lpszDomain || strlen(lpszDomain) < 0 )
  1498. return FALSE;
  1500. for( int i=0; i<GetSize(); i++ )
  1501. {
  1502. CDomain & domain = ElementAt(i);
  1503. if( 0 == domain.m_strName.CompareNoCase( lpszDomain ) )
  1504. {
  1505. astr.Copy( domain );
  1506. return TRUE;
  1507. }
  1508. }
  1510. return FALSE;
  1511. }
  1513. BOOL CDomainContainer::GetDomains( CSPStringArray & astr )
  1514. {
  1515. astr.SetSize( GetSize() );
  1517. for( int i=0; i<GetSize(); i++ )
  1518. {
  1519. CDomain & domain = ElementAt(i);
  1520. CSPString string = domain.m_strName;
  1521. astr.SetAt( i, string );
  1522. }
  1523. return TRUE;
  1524. }
  1526. BOOL CDomainContainer::GetAllDomainInfo( CStockContainer * pContainer, DWORD dwDate )
  1527. {
  1528. SP_ASSERT( pContainer );
  1529. if( NULL == pContainer )
  1530. return FALSE;
  1532. DWORD dwDateLatest = -1;
  1533. AfxGetStockContainer().GetLatestTechDate( &dwDateLatest );
  1535. for( int nDomain=0; nDomain<GetSize(); nDomain++ )
  1536. {
  1537. CDomain & domain = ElementAt(nDomain);
  1538. CStockContainer cntn;
  1539. if( cntn.RetrieveSpecify( domain ) )
  1540. {
  1541. if( -1 != dwDate && dwDateLatest != dwDate )
  1542. {
  1543. for( int i=0; i<cntn.GetSize(); i++ )
  1544. {
  1545. CStockInfo & info = cntn.ElementAt(i);
  1546. info.StatBaseIndex( dwDate );
  1547. info.StatTechIndex( dwDate );
  1548. }
  1549. }
  1550. // cntn.SetMap( );
  1551. cntn.SetAverage( );
  1553. CStockInfo info = cntn.GetAverage( );
  1554. info.SetStockName( domain.m_strName );
  1555. info.SetStockShortName( domain.m_strName );
  1556. pContainer->Add( info );
  1557. }
  1558. }
  1559. pContainer->SetMap();
  1560. pContainer->SetAverage();
  1561. return TRUE;
  1562. }
  1564. #define SF_MAX_DOMAINFILE_LENGTH 0x10000000
  1566. BOOL CDomainContainer::Load( LPCTSTR lpszFileName )
  1567. {
  1568. if( NULL == lpszFileName || strlen(lpszFileName) <= 0 )
  1569. return FALSE;
  1571. BOOL bOK = FALSE;
  1572. CSPFile file;
  1574. if( file.Open( lpszFileName, CSPFile::modeRead ) )
  1575. {
  1576. DWORD dwLen = file.GetLength();
  1577. if( 0 == dwLen || dwLen > SF_MAX_DOMAINFILE_LENGTH )
  1578. {
  1579. file.Close();
  1580. return FALSE;
  1581. }
  1583. SetSize( 0, min(dwLen / 300, 20) );
  1585. CDomain domain;
  1586. CSPString rString;
  1587. while( file.ReadString( rString ) )
  1588. {
  1589. int nIndex = rString.Find( "r" );
  1590. if( -1 == nIndex )
  1591. nIndex = rString.Find( "n" );
  1592. if( -1 != nIndex )
  1593. rString = rString.Left( nIndex );
  1594. rString.TrimLeft();
  1595. rString.TrimRight();
  1597. if( rString.GetLength() > 0 )
  1598. {
  1599. if( domain.m_strName.IsEmpty() ) // 新版块名称
  1600. domain.m_strName = rString;
  1601. else
  1602. domain.AddStock( rString );
  1603. }
  1604. else
  1605. { // 版块结束
  1606. if( !domain.m_strName.IsEmpty() )
  1607. AddDomain( domain );
  1608. domain.m_strName.Empty();
  1609. domain.RemoveAll();
  1610. }
  1611. }
  1612. if( !domain.m_strName.IsEmpty() )
  1613. Add( domain );
  1614. domain.m_strName.Empty();
  1615. domain.RemoveAll();
  1617. file.Close();
  1618. bOK = TRUE;
  1619. }
  1621. return bOK;
  1622. }
  1624. BOOL CDomainContainer::Store( LPCTSTR lpszFileName )
  1625. {
  1626. if( NULL == lpszFileName || strlen(lpszFileName) <= 0 )
  1627. return FALSE;
  1629. CSPFile file;
  1630. if( file.Open( lpszFileName, CSPFile::modeCreate | CSPFile::modeWrite ) )
  1631. {
  1632. for( int i=0; i<GetSize(); i++ )
  1633. {
  1634. CDomain & domain = ElementAt(i);
  1635. CSPString strDomain = domain.m_strName;
  1636. file.Write( strDomain.GetBuffer(strDomain.GetLength()+1), strDomain.GetLength() );
  1637. file.Write( STRING_CRLF, strlen(STRING_CRLF) );
  1638. for( int k=0; k<domain.GetSize(); k++ )
  1639. {
  1640. CSPString strStock = domain[k];
  1641. if( strStock.GetLength() > 0 )
  1642. {
  1643. file.Write( strStock.GetBuffer(strStock.GetLength()), strStock.GetLength() );
  1644. file.Write( STRING_CRLF, strlen(STRING_CRLF) );
  1645. }
  1646. }
  1647. file.Write( STRING_CRLF, strlen(STRING_CRLF) );
  1648. }
  1650. file.Close();
  1651. return TRUE;
  1652. }
  1653. return FALSE;
  1654. }