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

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

金融证券系统

开发平台：

Visual C++

Database.cpp：源码内容
  1. /*
  2. Cross Platform Core Code.
  4. Copyright(R) 2001-2002 Balang Software.
  5. All rights reserved.
  7. Using:
  8. DllMain( HANDLE, DWORD, LPVOID );
  9. class CStDatabase;
  10. */
  12. #include "StdAfx.h"
  13. #include "../Include/Database.h"
  14. #include "../Include/SpString.h"
  15. #include <direct.h>
  16. #include "SelfDB.h"
  18. #ifdef _DEBUG
  19. #define new DEBUG_NEW
  20. #undef THIS_FILE
  21. static char THIS_FILE[] = __FILE__;
  22. #endif
  24. ////////////////////////////////////////////////////////////////////////////////////////////
  25. // convertor
  27. BOOL convert_TYDAY_RECORD_to_KDATA( TYDAY_RECORD * precord, KDATA * pkd )
  28. {
  29. SP_ASSERT( precord && pkd );
  30. if( NULL == precord || NULL == pkd )
  31. return FALSE;
  32. memset( pkd, 0, sizeof(KDATA) );
  34. pkd->m_dwMarket = CStock::marketUnknown;
  35. strncpy( pkd->m_szCode, precord->code, min(sizeof(pkd->m_szCode)-1,sizeof(precord->code)) );
  37. pkd->m_date = precord->date;
  38. CSPTime sptime;
  39. if( sptime.FromStockTimeDay(pkd->m_date) )
  40. pkd->m_time = sptime.GetTime();
  42. pkd->m_fOpen = (float)( precord->open * 0.001 );
  43. pkd->m_fHigh = (float)( precord->high * 0.001 );
  44. pkd->m_fLow = (float)( precord->low * 0.001 );
  45. pkd->m_fClose = (float)( precord->close * 0.001 );
  46. pkd->m_fAmount = (float)( precord->amount * 1000. );
  47. pkd->m_fVolume = (float)( precord->volume * 100. );
  48. return TRUE;
  49. }
  51. BOOL convert_TYDAY_RECORD_MIN_to_KDATA( TYDAY_RECORD * precord, KDATA * pkd )
  52. {
  53. SP_ASSERT( precord && pkd );
  54. if( NULL == precord || NULL == pkd )
  55. return FALSE;
  56. memset( pkd, 0, sizeof(KDATA) );
  58. pkd->m_dwMarket = CStock::marketUnknown;
  59. strncpy( pkd->m_szCode, precord->code, min(sizeof(pkd->m_szCode)-1,sizeof(precord->code)) );
  61. pkd->m_date = precord->date;
  62. CSPTime sptime;
  63. if( sptime.FromStockTimeDay(pkd->m_date) )
  64. pkd->m_time = sptime.GetTime();
  66. pkd->m_fOpen = (float)( precord->open * 0.001 );
  67. pkd->m_fHigh = (float)( precord->high * 0.001 );
  68. pkd->m_fLow = (float)( precord->low * 0.001 );
  69. pkd->m_fClose = (float)( precord->close * 0.001 );
  70. pkd->m_fAmount = (float)( precord->amount * 100. );
  71. pkd->m_fVolume = (float)( precord->volume * 100. );
  72. return TRUE;
  73. }
  75. BOOL convert_KDATA_to_TYDAY_RECORD( DWORD dwSerial, const char * name, KDATA * pkd, TYDAY_RECORD * precord )
  76. {
  77. SP_ASSERT( precord && pkd );
  78. if( NULL == precord || NULL == pkd )
  79. return FALSE;
  80. memset( precord, 0, sizeof(TYDAY_RECORD) );
  82. precord->magic = 0x06;
  83. precord->magic2 = 0x08;
  85. strncpy( precord->code, pkd->m_szCode, min(sizeof(precord->code),sizeof(pkd->m_szCode)) );
  86. if( name )
  87. strncpy( precord->name, name, min(sizeof(precord->name),strlen(name)) );
  89. precord->date = pkd->m_date;
  91. precord->open = (DWORD)( pkd->m_fOpen * 1000 );
  92. precord->high = (DWORD)( pkd->m_fHigh * 1000 );
  93. precord->low = (DWORD)( pkd->m_fLow * 1000 );
  94. precord->close = (DWORD)( pkd->m_fClose * 1000 );
  95. precord->amount = (DWORD)( pkd->m_fAmount * 0.001 );
  96. precord->volume = (DWORD)( pkd->m_fVolume * 0.01 );
  97. precord->serial = dwSerial;
  98. return TRUE;
  99. }
  101. BOOL convert_KDATA_to_TYDAY_RECORD_MIN( DWORD dwSerial, const char * name, KDATA * pkd, TYDAY_RECORD * precord )
  102. {
  103. SP_ASSERT( precord && pkd );
  104. if( NULL == precord || NULL == pkd )
  105. return FALSE;
  106. memset( precord, 0, sizeof(TYDAY_RECORD) );
  108. precord->magic = 0x06;
  109. precord->magic2 = 0x08;
  111. strncpy( precord->code, pkd->m_szCode, min(sizeof(precord->code),sizeof(pkd->m_szCode)) );
  112. if( name )
  113. strncpy( precord->name, name, min(sizeof(precord->name),strlen(name)) );
  115. precord->date = pkd->m_date;
  117. precord->open = (DWORD)( pkd->m_fOpen * 1000 );
  118. precord->high = (DWORD)( pkd->m_fHigh * 1000 );
  119. precord->low = (DWORD)( pkd->m_fLow * 1000 );
  120. precord->close = (DWORD)( pkd->m_fClose * 1000 );
  121. precord->amount = (DWORD)( pkd->m_fAmount * 0.01 );
  122. precord->volume = (DWORD)( pkd->m_fVolume * 0.01 );
  123. precord->serial = dwSerial;
  124. return TRUE;
  125. }
  127. BOOL convert_FXJDAY_RECORD_to_KDATA( DWORD dwMarket, LPCTSTR lpszCode, int nKType, FXJDAY_RECORD *precord, KDATA *pkd )
  128. {
  129. SP_ASSERT( precord && pkd && lpszCode );
  130. if( NULL == precord || NULL == pkd )
  131. return FALSE;
  132. memset( pkd, 0, sizeof(KDATA) );
  134. pkd->m_dwMarket = dwMarket;
  135. strncpy( pkd->m_szCode, lpszCode, min(sizeof(pkd->m_szCode)-1,strlen(lpszCode)) );
  137. pkd->m_time = precord->m_time;
  138. CSPTime sptime(pkd->m_time);
  139. pkd->m_date = sptime.ToStockTime( CKData::IsDayOrMin(nKType) );
  141. pkd->m_fOpen = precord->open;
  142. pkd->m_fHigh = precord->high;
  143. pkd->m_fLow = precord->low;
  144. pkd->m_fClose = precord->close;
  145. pkd->m_fAmount = precord->amount;
  146. pkd->m_fVolume = (float)( precord->volume * 100. );
  147. return TRUE;
  148. }
  150. ////////////////////////////////////////////////////////////////////////////////////////////
  151. // class CStDatabase
  153. CStDatabase::CStDatabase()
  154. {
  155. m_pStore = NULL;
  156. }
  158. CStDatabase::~CStDatabase()
  159. {
  160. if( m_pStore )
  161. {
  162. delete m_pStore;
  163. m_pStore = NULL;
  164. }
  166. for( int i=0; i<m_aptrAssistant.GetSize(); i++ )
  167. {
  168. IStStore * pStore = (IStStore *)m_aptrAssistant.ElementAt(i);
  169. if( pStore )
  170. delete pStore;
  171. }
  172. m_aptrAssistant.RemoveAll();
  173. }
  175. BOOL CStDatabase::CreateSelfDB( const char * rootpath )
  176. {
  177. return CSelfDB::CreateSelfDB( rootpath );
  178. }
  180. int CStDatabase::IsValidDataType ( int nType )
  181. {
  182. return IStStore::IsValidDataType( nType );
  183. }
  185. int CStDatabase::GetSupportedDataType ( CDBType * pdbtype, int maxsize )
  186. {
  187. return IStStore::GetSupportedDataType( pdbtype, maxsize );
  188. }
  190. BOOL CStDatabase::SetRootPath( const char * rootpath, int nDBType )
  191. {
  192. if( m_pStore )
  193. delete m_pStore;
  194. m_pStore = IStStore::CreateStore( rootpath, nDBType );
  195. return (NULL != m_pStore);
  196. }
  198. BOOL CStDatabase::IsOK( )
  199. { return m_pStore && m_pStore->IsOK(); }
  200. const char *CStDatabase::GetRootPath( )
  201. { if(!IsOK()) return NULL; return m_pStore->GetRootPath(); }
  202. int CStDatabase::GetDBType( )
  203. { if(!IsOK()) return IStStore::dbtypeUnknown; return m_pStore->GetDBType(); }
  204. const char *CStDatabase::GetDBTypeName( )
  205. { if(!IsOK()) return NULL; return m_pStore->GetDBTypeName(); }
  207. DWORD CStDatabase::GetSelfTempPath( char *szTempPath, int size )
  208. {
  209. const char *szRoot = GetRootPath();
  210. if( 0 == strlen( szRoot ) )
  211. {
  212. if( NULL != szTempPath && size > 0 )
  213. szTempPath[0] = '';
  214. return 0;
  215. }
  217. char szReturn[MAX_PATH+1];
  218. memset( szReturn, 0, sizeof(szReturn) );
  219. strncpy( szReturn, szRoot, MAX_PATH );
  220. strncat( szReturn, "temp", MAX_PATH-strlen(szReturn) );
  221. strncat( szReturn, STRING_DIRSEP, MAX_PATH-strlen(szReturn) );
  224. BOOL bCreated = TRUE;
  225. if( 0 != access(szReturn,0) )
  226. bCreated = (0==_mkdir(szReturn));
  227. if( !bCreated )
  228. {
  229. if( NULL != szTempPath && size > 0 )
  230. szTempPath[0] = '';
  231. return 0;
  232. }
  233. strncpy( szTempPath, szReturn, size );
  234. return strlen(szReturn);
  235. }
  237. BOOL CStDatabase::GetLastErrorMessage(LPTSTR lpszError, UINT nMaxError)
  238. {
  239. if( nMaxError > 0 )
  240. lpszError[0] = '';
  241. return FALSE;
  242. }
  244. int CStDatabase::GetMaxStockNumber( )
  245. {
  246. if(!IsOK()) return 0;
  248. int nSize = m_pStore->GetMaxStockNumber();
  249. if( nSize > 0 )
  250. return nSize;
  252. for( int i=0; i<m_aptrAssistant.GetSize(); i++ )
  253. {
  254. IStStore * pStore = (IStStore *)m_aptrAssistant.ElementAt(i);
  255. nSize = pStore->GetMaxStockNumber();
  256. if( nSize > 0 )
  257. return nSize;
  258. }
  259. return nSize;
  260. }
  262. int CStDatabase::LoadCodetable( CStockContainer & container )
  263. {
  264. if(!IsOK()) return 0;
  266. int nSize = m_pStore->LoadCodetable( container );
  267. if( nSize > 0 )
  268. return nSize;
  270. for( int i=0; i<m_aptrAssistant.GetSize(); i++ )
  271. {
  272. IStStore * pStore = (IStStore *)m_aptrAssistant.ElementAt(i);
  273. nSize = pStore->LoadCodetable( container );
  274. if( nSize > 0 )
  275. return nSize;
  276. }
  277. return nSize;
  278. }
  280. int CStDatabase::StoreCodetable( CStockContainer & container )
  281. { if(!IsOK()) return 0; return m_pStore->StoreCodetable( container ); }
  283. int CStDatabase::LoadKDataCache( CStockContainer & container, PROGRESS_CALLBACK fnCallback, void *cookie, int nProgStart, int nProgEnd )
  284. {
  285. if(!IsOK()) return 0;
  287. int nSize = m_pStore->LoadKDataCache( container, fnCallback, cookie, nProgStart, nProgEnd );
  288. if( nSize > 0 )
  289. return nSize;
  291. for( int i=0; i<m_aptrAssistant.GetSize(); i++ )
  292. {
  293. IStStore * pStore = (IStStore *)m_aptrAssistant.ElementAt(i);
  294. nSize = pStore->LoadKDataCache( container, fnCallback, cookie, nProgStart, nProgEnd );
  295. if( nSize > 0 )
  296. return nSize;
  297. }
  298. return nSize;
  299. }
  301. int CStDatabase::LoadBasetable( CStockContainer & container )
  302. { if(!IsOK()) return 0; return m_pStore->LoadBasetable( container ); }
  303. int CStDatabase::StoreBasetable( CStockContainer & container )
  304. { if(!IsOK()) return 0; return m_pStore->StoreBasetable( container ); }
  306. int CStDatabase::LoadBaseText( CStock *pstock )
  307. {
  308. if( !pstock || !IsOK() ) return 0;
  310. int nSize = m_pStore->LoadBaseText( pstock );
  311. if( nSize > 0 )
  312. return nSize;
  314. for( int i=0; i<m_aptrAssistant.GetSize(); i++ )
  315. {
  316. IStStore * pStore = (IStStore *)m_aptrAssistant.ElementAt(i);
  317. CStock stock;
  318. stock.SetStockInfo( &(pstock->GetStockInfo()) );
  319. if( pStore && pStore->LoadBaseText( &stock ) > 0 )
  320. {
  321. nSize = pstock->MergeBaseText( stock );
  322. }
  323. }
  324. return nSize;
  325. }
  327. int CStDatabase::LoadKData( CStock *pstock, int period )
  328. {
  329. if( !pstock || !IsOK()) return 0;
  331. int nSize = m_pStore->LoadKData( pstock, period );
  333. for( int i=0; i<m_aptrAssistant.GetSize(); i++ )
  334. {
  335. IStStore * pStore = (IStStore *)m_aptrAssistant.ElementAt(i);
  336. CStock stock;
  337. stock.SetStockInfo( &(pstock->GetStockInfo()) );
  338. if( pStore->LoadKData( &stock, period ) > 0 )
  339. {
  340. nSize = pstock->MergeKData( stock, period );
  341. }
  342. }
  343. return nSize;
  344. }
  346. int CStDatabase::LoadDRData( CStock *pstock )
  347. {
  348. if( !pstock || !IsOK() )
  349. return 0;
  351. int nSize = m_pStore->LoadDRData( pstock );
  353. for( int i=0; i<m_aptrAssistant.GetSize(); i++ )
  354. {
  355. IStStore * pStore = (IStStore *)m_aptrAssistant.ElementAt(i);
  356. CStock stock;
  357. stock.SetStockInfo( &(pstock->GetStockInfo()) );
  358. if( pStore && pStore->LoadDRData( &stock ) > 0 )
  359. {
  360. nSize = pstock->MergeDRData( stock );
  361. }
  362. }
  363. return nSize;
  364. }
  366. int CStDatabase::StoreDRData( CStock *pstock )
  367. { if(!IsOK()) return 0;
  368. return m_pStore->StoreDRData( pstock ); }
  370. int CStDatabase::LoadReport( CStock *pstock )
  371. {
  372. if( !pstock || !IsOK() ) return 0;
  374. int nSize = m_pStore->LoadReport( pstock );
  375. if( nSize > 0 )
  376. return nSize;
  378. for( int i=0; i<m_aptrAssistant.GetSize(); i++ )
  379. {
  380. IStStore * pStore = (IStStore *)m_aptrAssistant.ElementAt(i);
  381. if( pStore )
  382. nSize = pStore->LoadReport( pstock );
  383. if( nSize > 0 )
  384. return nSize;
  385. }
  386. return nSize;
  387. }
  389. int CStDatabase::LoadMinute( CStock *pstock )
  390. {
  391. if( !pstock || !IsOK() ) return 0;
  393. int nSize = m_pStore->LoadMinute( pstock );
  394. if( nSize > 0 )
  395. return nSize;
  397. for( int i=0; i<m_aptrAssistant.GetSize(); i++ )
  398. {
  399. IStStore * pStore = (IStStore *)m_aptrAssistant.ElementAt(i);
  400. if( pStore )
  401. nSize = pStore->LoadMinute( pstock );
  402. if( nSize > 0 )
  403. return nSize;
  404. }
  405. return nSize;
  406. }
  408. int CStDatabase::LoadOutline( CStock *pstock )
  409. {
  410. if( !pstock || !IsOK() ) return 0;
  412. int nSize = m_pStore->LoadOutline( pstock );
  413. if( nSize > 0 )
  414. return nSize;
  416. for( int i=0; i<m_aptrAssistant.GetSize(); i++ )
  417. {
  418. IStStore * pStore = (IStStore *)m_aptrAssistant.ElementAt(i);
  419. if( pStore )
  420. nSize = pStore->LoadOutline( pstock );
  421. if( nSize > 0 )
  422. return nSize;
  423. }
  424. return nSize;
  425. }
  427. int CStDatabase::StoreReport( REPORT * pReport, int nCount, BOOL bBigTrade )
  428. { if(!IsOK()) return 0;
  429. return m_pStore->StoreReport( pReport, nCount, bBigTrade ); }
  430. int CStDatabase::StoreMinute( MINUTE * pMinute, int nCount )
  431. { if(!IsOK()) return 0;
  432. return m_pStore->StoreMinute( pMinute, nCount ); }
  433. int CStDatabase::StoreOutline( OUTLINE * pOutline, int nCount )
  434. { if(!IsOK()) return 0;
  435. return m_pStore->StoreOutline( pOutline, nCount ); }
  437. int CStDatabase::InstallCodetbl( const char * filename, const char *orgname )
  438. { if(!IsOK()) return 0;
  439. return m_pStore->InstallCodetbl( filename, orgname ); }
  440. int CStDatabase::InstallCodetblBlock( const char * filename, const char *orgname )
  441. { if(!IsOK()) return 0;
  442. return m_pStore->InstallCodetblBlock( filename, orgname ); }
  443. int CStDatabase::InstallCodetblFxjBlock( const char * filename, const char *orgname )
  444. { if(!IsOK()) return 0;
  445. return m_pStore->InstallCodetblFxjBlock( filename, orgname ); }
  446. int CStDatabase::InstallKData( CKData &kdata, BOOL bOverwrite )
  447. { if(!IsOK()) return 0;
  448. return m_pStore->InstallKData( kdata, bOverwrite ); }
  449. int CStDatabase::InstallKDataTy( const char * stkfile, int ktype, PROGRESS_CALLBACK fnCallback, void *cookie )
  450. { if(!IsOK()) return 0;
  451. return m_pStore->InstallKDataTy( stkfile, ktype, fnCallback, cookie ); }
  452. int CStDatabase::InstallKDataFxj( const char * dadfile, int ktype, PROGRESS_CALLBACK fnCallback, void *cookie )
  453. { if(!IsOK()) return 0;
  454. return m_pStore->InstallKDataFxj( dadfile, ktype, fnCallback, cookie ); }
  455. int CStDatabase::InstallDRData( CDRData &drdata )
  456. { if(!IsOK()) return 0;
  457. return m_pStore->InstallDRData( drdata ); }
  458. int CStDatabase::InstallDRDataClk( const char * filename, const char *orgname )
  459. { if(!IsOK()) return 0;
  460. return m_pStore->InstallDRDataClk( filename, orgname ); }
  461. int CStDatabase::InstallDRDataFxj( const char * fxjfilename )
  462. { if(!IsOK()) return 0;
  463. return m_pStore->InstallDRDataFxj( fxjfilename ); }
  464. int CStDatabase::InstallBasetable( const char * filename, const char *orgname )
  465. { if(!IsOK()) return 0;
  466. return m_pStore->InstallBasetable( filename, orgname ); }
  467. int CStDatabase::InstallBasetableTdx( const char * filename )
  468. { if(!IsOK()) return 0;
  469. return m_pStore->InstallBasetableTdx( filename ); }
  470. int CStDatabase::InstallBasetableFxj( const char * filename )
  471. { if(!IsOK()) return 0;
  472. return m_pStore->InstallBasetableFxj( filename ); }
  473. int CStDatabase::InstallBaseText( const char * filename, const char *orgname )
  474. { if(!IsOK()) return 0;
  475. return m_pStore->InstallBaseText( filename, orgname ); }
  476. int CStDatabase::InstallBaseText( const char * buffer, int nLen, const char *orgname )
  477. { if(!IsOK()) return 0;
  478. return m_pStore->InstallBaseText( buffer, nLen, orgname ); }
  479. int CStDatabase::InstallNewsText( const char * filename, const char *orgname )
  480. { if(!IsOK()) return 0;
  481. return m_pStore->InstallNewsText( filename, orgname ); }
  482. int CStDatabase::InstallNewsText( const char * buffer, int nLen, const char *orgname )
  483. { if(!IsOK()) return 0;
  484. return m_pStore->InstallNewsText( buffer, nLen, orgname ); }
  487. BOOL CStDatabase::AddAssistantRootPath( const char * rootpath, int nDBType )
  488. {
  489. IStStore * pStore = IStStore::CreateStore( rootpath, nDBType );
  490. if( NULL == pStore )
  491. return FALSE;
  492. m_aptrAssistant.Add( pStore );
  493. return TRUE;
  494. }
  496. void CStDatabase::RemoveAssistant( const char * rootpath )
  497. {
  498. if( NULL == rootpath || strlen(rootpath) == 0 )
  499. return;
  501. for( int i=m_aptrAssistant.GetSize()-1; i>=0; i-- )
  502. {
  503. IStStore * pStore = (IStStore *)m_aptrAssistant.ElementAt(i);
  504. if( pStore && 0 == strcmp( pStore->GetRootPath(), rootpath ) )
  505. {
  506. m_aptrAssistant.RemoveAt(i);
  507. delete pStore;
  508. }
  509. }
  510. }
  512. void CStDatabase::RemoveAllAssistant( )
  513. {
  514. for( int i=0; i<m_aptrAssistant.GetSize(); i++ )
  515. {
  516. IStStore * pStore = (IStStore *)m_aptrAssistant.ElementAt(i);
  517. if( pStore )
  518. {
  519. delete pStore;
  520. }
  521. }
  522. m_aptrAssistant.RemoveAll( );
  523. }
  525. CSPTime CStDatabase::GetTimeInitial( )
  526. {
  527. return CSPTime( 1990, 12, 19, 0, 0, 0 );
  528. }
  530. BOOL CStDatabase::GetTimeLocalRange( CSPTime *ptmLatest, CSPTime * ptmPioneer, CSPTime * ptmInitial )
  531. {
  532. CStock stock;
  533. stock.SetStockCode( CStock::marketSHSE, STKLIB_CODE_MAIN );
  534. stock.SetDatabase( this );
  535. if( !stock.PrepareData( CStock::dataK, CKData::ktypeDay ) )
  536. return FALSE;
  537. CKData & kday = stock.GetKDataDay();
  539. int nYear, nMonth, nDay, nHour, nMinute;
  540. if( ptmLatest )
  541. {
  542. if( !kday.LatestDate( nYear, nMonth, nDay, nHour, nMinute ) )
  543. return FALSE;
  544. *ptmLatest = CSPTime( nYear, nMonth, nDay, 23, 59, 59 );
  545. }
  547. if( ptmPioneer )
  548. {
  549. if( kday.GetSize() == 0 || !kday.DateAt(0, nYear, nMonth, nDay, nHour, nMinute ) )
  550. return FALSE;
  551. *ptmPioneer = CSPTime( nYear, nMonth, nDay, 0, 0, 0 );
  552. }
  554. if( ptmInitial )
  555. {
  556. *ptmInitial = GetTimeInitial( );
  557. }
  559. return TRUE;
  560. }
  562. BOOL CStDatabase::GetNeedDownloadRange( CStockInfo &info, CSPTime tmBegin, CSPTime tmEnd, CSPTime &tmDLBegin, CSPTime &tmDLEnd )
  563. {
  564. tmDLBegin = tmBegin;
  565. tmDLEnd = tmEnd;
  567. // Prepare Data
  568. CStock stock;
  569. stock.SetStockInfo( &info );
  570. stock.SetDatabase( this );
  571. if( !stock.PrepareData( CStock::dataK, CKData::ktypeDay ) )
  572. return TRUE;
  573. CKData & kday = stock.GetKDataDay();
  575. // Prepare Time
  576. CSPTime tmInitial, tmLatest, tmPioneer;
  577. CSPTime sptimeInitial;
  578. if( 0 != info.m_datebegin && sptimeInitial.FromStockTimeDay( info.m_datebegin ) )
  579. tmInitial = sptimeInitial.GetTime();
  580. else
  581. tmInitial = GetTimeInitial( );
  583. int nYear, nMonth, nDay, nHour, nMinute;
  584. if( !kday.LatestDate( nYear, nMonth, nDay, nHour, nMinute ) )
  585. return TRUE;
  586. tmLatest = CSPTime( nYear, nMonth, nDay, 23, 59, 59 );
  588. if( kday.GetSize() == 0 || !kday.DateAt(0, nYear, nMonth, nDay, nHour, nMinute ) )
  589. return TRUE;
  590. tmPioneer = CSPTime( nYear, nMonth, nDay, 0, 0, 0 );
  592. // Deal With
  593. if( tmBegin < tmInitial )
  594. tmBegin = tmInitial;
  596. if( tmBegin >= tmPioneer && tmEnd <= tmLatest )
  597. {
  598. int nCount = 0;
  599. for( int k=0; k<kday.GetSize(); k++ )
  600. {
  601. DWORD date = kday.ElementAt(k).m_date;
  602. CSPTime sptime;
  603. if( sptime.FromStockTimeDay(date) )
  604. {
  605. if( sptime.GetTime() >= tmBegin.GetTime() && sptime.GetTime() <= tmEnd.GetTime() )
  606. nCount ++;
  607. }
  608. }
  610. CSPTimeSpan span = tmEnd - tmBegin;
  611. if( nCount > span.GetDays()*4/7 )
  612. return FALSE;
  613. }
  615. if( tmEnd <= tmPioneer )
  616. {
  617. tmDLBegin = tmBegin;
  618. tmDLEnd = tmPioneer-CSPTimeSpan(1,0,0,0);
  619. }
  620. else if( tmBegin >= tmLatest )
  621. {
  622. tmDLBegin = tmLatest+CSPTimeSpan(1,0,0,0);
  623. tmDLEnd = tmEnd;
  624. }
  625. else if( tmBegin < tmPioneer && tmEnd > tmPioneer && tmEnd <= tmLatest )
  626. {
  627. tmDLBegin = tmBegin;
  628. tmDLEnd = tmPioneer-CSPTimeSpan(1,0,0,0);
  629. }
  630. else if( tmBegin >= tmPioneer && tmBegin < tmLatest && tmEnd > tmLatest )
  631. {
  632. tmDLBegin = tmLatest+CSPTimeSpan(1,0,0,0);
  633. tmDLEnd = tmEnd;
  634. }
  635. else
  636. {
  637. tmDLBegin = tmBegin;
  638. tmDLEnd = tmEnd;
  639. }
  640. return TRUE;
  641. }
  643. // 将钱龙格式K线数据 加入 通用数据包
  644. int CStDatabase::AppendToTyData( const char *code, const char *name, int nKType, LPCTSTR lpszKFile, LPCTSTR lpszTyDataFile, time_t tmBegin, time_t tmEnd )
  645. {
  646. int nCount = 0;
  647. CSPFile fileK, fileTy;
  648. if( fileK.Open( lpszKFile, CSPFile::modeRead )
  649. && fileTy.Open( lpszTyDataFile, CSPFile::modeCreate|CSPFile::modeNoTruncate|CSPFile::modeReadWrite ) )
  650. {
  651. // Init Header
  652. TYDAY_FHEADER header;
  653. memset( &header, 0, sizeof(header) );
  654. header.magic = 0x06;
  655. for( int i=0; i<sizeof(header.code); i++ )
  656. header.code[i] = ' ';
  657. header.magic2 = 0x08;
  658. for( i=0; i<sizeof(header.name); i++ )
  659. header.name[i] = ' ';
  661. CSPTime sptime = CSPTime::GetCurrentTime();
  662. header.date = sptime.ToStockTimeDay();
  663. header.datebegin= header.date;
  664. header.dateend = header.date;
  665. header.gendate = header.date;
  666. header.gentime = sptime.GetTime();
  668. if( sizeof(header) != fileTy.Read( &header, sizeof(header) ) )
  669. {
  670. fileTy.SeekToBegin();
  671. fileTy.Write( &header, sizeof(header) );
  672. }
  674. header.from = 'CL';
  676. fileTy.SeekToEnd();
  678. // generate
  679. if( CKData::IsDayOrMin(nKType) )
  680. {
  681. DWORD dateBegin = CSPTime(tmBegin).ToStockTimeDay();
  682. DWORD dateEnd = CSPTime(tmEnd).ToStockTimeDay();
  684. struct QL_Data_day qlkd;
  685. while( sizeof(qlkd) == fileK.Read( &qlkd, sizeof(qlkd) ) )
  686. {
  687. if( qlkd.day_date < dateBegin || qlkd.day_date > dateEnd )
  688. continue;
  690. KDATA kd;
  691. TYDAY_RECORD tyrecord;
  692. convert_QL_Data_day_to_KDATA( CStock::marketUnknown, code, &qlkd, &kd );
  693. convert_KDATA_to_TYDAY_RECORD( header.recordcount+1, name, &kd, &tyrecord );
  694. fileTy.Write( &tyrecord, sizeof(tyrecord) );
  696. // Modified header
  697. if( tyrecord.date < header.datebegin )
  698. header.datebegin = tyrecord.date;
  699. if( tyrecord.date > header.dateend )
  700. header.dateend = tyrecord.date;
  701. header.recordcount += 1;
  702. nCount ++;
  703. }
  704. }
  705. else
  706. {
  707. DWORD dateBegin = CSPTime(tmBegin).ToStockTimeMin();
  708. DWORD dateEnd = CSPTime(tmEnd).ToStockTimeMin();
  710. struct QL_Data_5min qlkd;
  711. while( sizeof(qlkd) == fileK.Read( &qlkd, sizeof(qlkd) ) )
  712. {
  713. if( qlkd.min_off < dateBegin || qlkd.min_off > dateEnd )
  714. continue;
  716. KDATA kd;
  717. TYDAY_RECORD tyrecord;
  718. convert_QL_Data_5min_to_KDATA( CStock::marketUnknown, code, &qlkd, &kd );
  719. convert_KDATA_to_TYDAY_RECORD_MIN( header.recordcount+1, name, &kd, &tyrecord );
  720. fileTy.Write( &tyrecord, sizeof(tyrecord) );
  722. // Modified header
  723. if( tyrecord.date < header.datebegin )
  724. header.datebegin = tyrecord.date;
  725. if( tyrecord.date > header.dateend )
  726. header.dateend = tyrecord.date;
  727. header.recordcount += 1;
  728. nCount ++;
  729. }
  730. }
  732. if( nCount > 0 )
  733. header.sharecount += 1;
  734. fileTy.SeekToBegin();
  735. fileTy.Write( &header, sizeof(header) );
  737. fileK.Close();
  738. fileTy.Close();
  739. }
  740. return nCount;
  741. }