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

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

金融证券系统

开发平台：

Visual C++

QianLong.cpp：源码内容
  1. /*
  2. Cross Platform Core Code.
  4. Copyright(R) 2001-2002 Balang Software.
  5. All rights reserved.
  7. Using:
  8. class CQianLong;
  9. */
  11. #include "StdAfx.h"
  12. #include "../Include/Database.h"
  13. #include "../Include/SpString.h"
  14. #include "QianLong.h"
  16. #include <math.h>
  18. #ifdef _DEBUG
  19. #define new DEBUG_NEW
  20. #undef THIS_FILE
  21. static char THIS_FILE[] = __FILE__;
  22. #endif
  24. BOOL convert_QL_Data_5min_to_KDATA( DWORD dwMarket, const char *szCode, struct QL_Data_5min * pqlkd, KDATA *pkd )
  25. {
  26. SP_ASSERT( pqlkd && pkd );
  27. if( NULL == pqlkd || NULL == pkd )
  28. return FALSE;
  29. memset( pkd, 0, sizeof(KDATA) );
  31. pkd->m_dwMarket = dwMarket;
  32. if( szCode )
  33. strncpy( pkd->m_szCode, szCode, min(sizeof(pkd->m_szCode)-1,strlen(szCode)) );
  35. pkd->m_date = pqlkd->min_off;
  36. CSPTime sptime;
  37. if( sptime.FromStockTimeMin( pkd->m_date) )
  38. pkd->m_time = sptime.GetTime();
  40. pkd->m_fOpen = (float)fabs( pqlkd->open_price * 0.001 );
  41. pkd->m_fHigh = (float)fabs( pqlkd->high_price * 0.001 );
  42. pkd->m_fLow = (float)fabs( pqlkd->low_price * 0.001 );
  43. pkd->m_fClose = (float)fabs( pqlkd->close_price * 0.001 );
  44. pkd->m_fVolume = (float)fabs( pqlkd->min_volume * 100. );
  45. pkd->m_fAmount = (float)fabs( pqlkd->min_amount * 100. );
  46. return TRUE;
  47. }
  49. BOOL convert_QL_Data_day_to_KDATA( DWORD dwMarket, const char *szCode, struct QL_Data_day * pqlkd, KDATA *pkd )
  50. {
  51. SP_ASSERT( pqlkd && pkd );
  52. if( NULL == pqlkd || NULL == pkd )
  53. return FALSE;
  54. memset( pkd, 0, sizeof(KDATA) );
  56. pkd->m_dwMarket = dwMarket;
  57. if( szCode )
  58. strncpy( pkd->m_szCode, szCode, min(sizeof(pkd->m_szCode)-1,strlen(szCode)) );
  60. pkd->m_date = pqlkd->day_date;
  61. CSPTime sptime;
  62. if( sptime.FromStockTimeDay(pkd->m_date) )
  63. pkd->m_time = sptime.GetTime();
  65. pkd->m_fOpen = (float)fabs( pqlkd->open_price * 0.001 );
  66. pkd->m_fHigh = (float)fabs( pqlkd->high_price * 0.001 );
  67. pkd->m_fLow = (float)fabs( pqlkd->low_price * 0.001 );
  68. pkd->m_fClose = (float)fabs( pqlkd->close_price * 0.001 );
  69. pkd->m_fVolume = (float)fabs( pqlkd->day_volume * 100. );
  70. pkd->m_fAmount = (float)fabs( pqlkd->day_amount * 1000. );
  71. return TRUE;
  72. }
  74. BOOL convert_KDATA_to_QL_Data_day( KDATA * pkd, struct QL_Data_day * pqlkd )
  75. {
  76. SP_ASSERT( pqlkd && pkd );
  77. if( NULL == pqlkd || NULL == pkd )
  78. return FALSE;
  79. memset( pqlkd, 0, sizeof(struct QL_Data_day) );
  81. pqlkd->day_date = (DWORD)( pkd->m_date );
  82. pqlkd->open_price = (DWORD)( pkd->m_fOpen * 1000 );
  83. pqlkd->high_price = (DWORD)( pkd->m_fHigh * 1000 );
  84. pqlkd->low_price = (DWORD)( pkd->m_fLow * 1000 );
  85. pqlkd->close_price = (DWORD)( pkd->m_fClose * 1000 );
  86. pqlkd->day_volume = (DWORD)( pkd->m_fVolume * 0.01 );
  87. pqlkd->day_amount = (DWORD)( pkd->m_fAmount * 0.001 );
  88. return TRUE;
  89. }
  91. BOOL convert_KDATA_to_QL_Data_5min( KDATA * pkd, struct QL_Data_5min * pqlkd )
  92. {
  93. SP_ASSERT( pqlkd && pkd );
  94. if( NULL == pqlkd || NULL == pkd )
  95. return FALSE;
  96. memset( pqlkd, 0, sizeof(struct QL_Data_day) );
  98. pqlkd->min_off = (DWORD)( pkd->m_date );
  99. pqlkd->open_price = (DWORD)( pkd->m_fOpen * 1000 );
  100. pqlkd->high_price = (DWORD)( pkd->m_fHigh * 1000 );
  101. pqlkd->low_price = (DWORD)( pkd->m_fLow * 1000 );
  102. pqlkd->close_price = (DWORD)( pkd->m_fClose * 1000 );
  103. pqlkd->min_volume = (DWORD)( pkd->m_fVolume * 0.01 );
  104. pqlkd->min_amount = (DWORD)( pkd->m_fAmount * 0.01 );
  105. return TRUE;
  106. }
  108. void ConvertQLStockInfo( DWORD dwMarket, QL_Stock_info_V302 & block, CStockInfo *pInfo )
  109. {
  110. pInfo->Clear();
  112. char code[sizeof(block.stock_code)+2];
  113. memset(code,0,sizeof(code));
  114. strncpy(code,(const char *)block.stock_code,sizeof(block.stock_code));
  116. char name[sizeof(block.stock_name)+2];
  117. memset(name,0,sizeof(name));
  118. strncpy(name,(const char *)block.stock_name,sizeof(block.stock_name));
  120. pInfo->SetStockCode( dwMarket, code );
  121. pInfo->SetStockName( name );
  122. pInfo->SetType( block.stock_type );
  124. /*
  125. pInfo->m_fLast = (float)fabs( block.last_close_price * 0.001 );
  126. pInfo->m_fOpen = (float)fabs( block.open_price * 0.001 );
  127. pInfo->m_fHigh = (float)fabs( block.high_price * 0.001 );
  128. pInfo->m_fLow = (float)fabs( block.low_price * 0.001 );
  129. pInfo->m_fClose = (float)fabs( block.close_price * 0.001 );
  130. pInfo->m_fVolume = (float)fabs( block.total_volume * 100. );
  131. pInfo->m_fAmount = (float)fabs( block.total_value * 1000. );
  132. pInfo->m_fBuyPrice[0] = (float)fabs( block.buy_1_price * 0.001 );
  133. pInfo->m_fBuyVolume[0] = (float)fabs( block.buy_1_volume * 100. );
  134. pInfo->m_fBuyPrice[1] = (float)fabs( block.buy_2_price * 0.001 );
  135. pInfo->m_fBuyVolume[1] = (float)fabs( block.buy_2_volume * 100. );
  136. pInfo->m_fBuyPrice[2] = (float)fabs( block.buy_3_price * 0.001 );
  137. pInfo->m_fBuyVolume[2] = (float)fabs( block.buy_3_volume * 100. );
  138. pInfo->m_fSellPrice[0] = (float)fabs( block.sell_1_price * 0.001 );
  139. pInfo->m_fSellVolume[0] = (float)fabs( block.sell_1_volume * 100. );
  140. pInfo->m_fSellPrice[1] = (float)fabs( block.sell_2_price * 0.001 );
  141. pInfo->m_fSellVolume[1] = (float)fabs( block.sell_2_volume * 100. );
  142. pInfo->m_fSellPrice[2] = (float)fabs( block.sell_3_price * 0.001 );
  143. pInfo->m_fSellVolume[2] = (float)fabs( block.sell_3_volume * 100. );
  144. */
  145. }
  147. void ConvertQLStockInfo( DWORD dwMarket, QL_Stock_info2_V304 & block, CStockInfo *pInfo )
  148. {
  149. pInfo->Clear();
  151. char code[sizeof(block.stock_code)+2];
  152. memset(code,0,sizeof(code));
  153. strncpy(code,(const char *)block.stock_code,sizeof(block.stock_code));
  155. char name[sizeof(block.stock_name)+2];
  156. memset(name,0,sizeof(name));
  157. strncpy(name,(const char *)block.stock_name,sizeof(block.stock_name));
  159. pInfo->SetStockCode( dwMarket, code );
  160. pInfo->SetStockName( name );
  161. pInfo->SetType( block.stock_type );
  163. /*
  164. pInfo->m_fLast = (float)fabs( block.last_close_price * 0.001 );
  165. pInfo->m_fOpen = (float)fabs( block.open_price * 0.001 );
  166. pInfo->m_fHigh = (float)fabs( block.high_price * 0.001 );
  167. pInfo->m_fLow = (float)fabs( block.low_price * 0.001 );
  168. pInfo->m_fClose = (float)fabs( block.close_price * 0.001 );
  169. pInfo->m_fVolume = (float)fabs( block.total_volume * 100. );
  170. pInfo->m_fAmount = (float)fabs( block.total_value * 1000. );
  171. pInfo->m_fBuyPrice[0] = (float)fabs( block.buy_1_price * 0.001 );
  172. pInfo->m_fBuyVolume[0] = (float)fabs( block.buy_1_volume * 100. );
  173. pInfo->m_fBuyPrice[1] = (float)fabs( block.buy_2_price * 0.001 );
  174. pInfo->m_fBuyVolume[1] = (float)fabs( block.buy_2_volume * 100. );
  175. pInfo->m_fBuyPrice[2] = (float)fabs( block.buy_3_price * 0.001 );
  176. pInfo->m_fBuyVolume[2] = (float)fabs( block.buy_3_volume * 100. );
  177. pInfo->m_fSellPrice[0] = (float)fabs( block.sell_1_price * 0.001 );
  178. pInfo->m_fSellVolume[0] = (float)fabs( block.sell_1_volume * 100. );
  179. pInfo->m_fSellPrice[1] = (float)fabs( block.sell_2_price * 0.001 );
  180. pInfo->m_fSellVolume[1] = (float)fabs( block.sell_2_volume * 100. );
  181. pInfo->m_fSellPrice[2] = (float)fabs( block.sell_3_price * 0.001 );
  182. pInfo->m_fSellVolume[2] = (float)fabs( block.sell_3_volume * 100. );
  183. */
  184. }
  186. /////////////////////////////////////////////////////////////////////////////////////
  187. // class CQianlong
  188. /*
  189. struct QL_Info_data datainfo_sha[TYPE_NUM];
  190. struct QL_Info_data datainfo_szn[TYPE_NUM];
  192. unsigned char exepath[80];
  193. unsigned char appdexe[88];
  195. unsigned char ml_sys[80];
  196. unsigned char ml_dat[80];
  197. unsigned char ml_sh_day[80];
  198. unsigned char ml_sz_day[80];
  199. unsigned char ml_sh_min[80];
  200. unsigned char ml_sz_min[80];
  201. unsigned char ml_sh_wek[80];
  202. unsigned char ml_sz_wek[80];
  203. unsigned char ml_sh_mnt[80];
  204. unsigned char ml_sz_mnt[80];
  206. unsigned char sl_sys[80];
  207. unsigned char sl_dat[80];
  208. unsigned char sl_sh_day[80];
  209. unsigned char sl_sz_day[80];
  210. unsigned char sl_sh_min[80];
  211. unsigned char sl_sz_min[80];
  212. unsigned char sl_sh_wek[80];
  213. unsigned char sl_sz_wek[80];
  214. unsigned char sl_sh_mnt[80];
  215. unsigned char sl_sz_mnt[80];
  217. unsigned char hx_sys[80];
  218. unsigned char hx_dat[80];
  219. unsigned char hx_sh_day[80];
  220. unsigned char hx_sz_day[80];
  221. unsigned char hx_sh_min[80];
  222. unsigned char hx_sz_min[80];
  223. unsigned char hx_sh_wek[80];
  224. unsigned char hx_sz_wek[80];
  225. unsigned char hx_sh_mnt[80];
  226. unsigned char hx_sz_mnt[80];
  228. unsigned char dealpath[80];
  229. unsigned char dealdat[80];
  230. unsigned char tmpdir[80];
  231. unsigned char sysdir[80];
  232. unsigned char infdir[80];
  233. unsigned char datdir[80];
  234. unsigned char basdir[80];
  235. unsigned char flag_mlv304;
  237. unsigned long nowdate;
  238. unsigned char datestr[10];
  239. unsigned char flag_dynamic;
  240. unsigned char ml30_flag;
  241. unsigned char slon_flag;
  242. unsigned char hxtw_flag;
  243. */
  245. char ml_dat[] = "dat\";
  246. char ml_sh_info[] = "dat\shinfo.dat";
  247. char ml_sz_info[] = "dat\szinfo.dat";
  248. char ml_sh_now[] = "dat\shnow.dat";
  249. char ml_sz_now[] = "dat\sznow.dat";
  250. char ml_sh_pyjc[] = "dat\shpyjc.dat";
  251. char ml_sz_pyjc[] = "dat\szpyjc.dat";
  252. char ml_sh_trace[] = "dat\shtrace.dat";
  253. char ml_sz_trace[] = "dat\sztrace.dat";
  254. char ml_sh_minute[] = "dat\shminute.dat";
  255. char ml_sz_minute[] = "dat\szminute.dat";
  257. char ml_data[] = "data\";
  258. char ml_sh[] = "data\shase\";
  259. char ml_sz[] = "data\sznse\";
  260. char ml_base[] = "base\";
  261. char ml_month[] = "month\";
  262. char ml_week[] = "week\";
  263. char ml_day[] = "day\";
  264. char ml_min5[] = "min\";
  265. char ml_sh_base[] = "data\shase\base\";
  266. char ml_sz_base[] = "data\sznse\base\";
  267. char ml_sh_month[] = "data\shase\month\";
  268. char ml_sz_month[] = "data\sznse\month\";
  269. char ml_sh_week[] = "data\shase\week\";
  270. char ml_sz_week[] = "data\sznse\week\";
  271. char ml_sh_day[] = "data\shase\day\";
  272. char ml_sz_day[] = "data\sznse\day\";
  273. char ml_sh_min[] = "data\shase\min\";
  274. char ml_sz_min[] = "data\sznse\min\";
  276. char ml_ext_base[] = ".txt";
  277. char ml_ext_month[] = ".mnt";
  278. char ml_ext_week[] = ".wek";
  279. char ml_ext_day[] = ".day";
  280. char ml_ext_min5[] = ".nmn";
  283. CQianlong::CQianlong( const char * rootpath, BOOL bOK )
  284. {
  285. m_bIsOK = FALSE;
  286. memset( m_szRootPath, 0, sizeof(m_szRootPath) );
  287. if( !bOK )
  288. {
  289. if( GetAccurateRoot( rootpath, m_szRootPath, sizeof(m_szRootPath)-1 ) )
  290. m_bIsOK = TRUE;
  291. else
  292. m_bIsOK = FALSE;
  293. }
  294. else
  295. {
  296. strncpy( m_szRootPath, rootpath, sizeof(m_szRootPath)-1 );
  297. m_bIsOK = TRUE;
  298. }
  300. m_nVersion = versionUnknown;
  301. if( bOK )
  302. m_nVersion = DetectVersion( GetRootPath() );
  303. }
  305. CQianlong::~CQianlong( )
  306. {
  307. }
  309. int CQianlong::GetMaxStockNumber( )
  310. {
  311. SP_ASSERT( m_bIsOK );
  312. if( ! m_bIsOK ) return 0;
  314. // load shinfo.dat szinfo.dat
  316. int blocksize = sizeof(struct QL_Stock_info_V302);
  317. if( version304 == m_nVersion )
  318. blocksize = sizeof(struct QL_Stock_info2_V304);
  320. DWORD dwCount = 0;
  321. CSPString sFileName = GetRootPath();
  322. sFileName += ml_sh_now;
  323. CSPFile file;
  324. if( file.Open( sFileName, CSPFile::modeRead | CSPFile::shareDenyNone ) )
  325. {
  326. DWORD dwFileLen = file.GetLength();
  327. dwCount += dwFileLen / blocksize;
  328. file.Close();
  329. }
  330. sFileName = GetRootPath();
  331. sFileName += ml_sz_now;
  332. if( file.Open( sFileName, CSPFile::modeRead | CSPFile::shareDenyNone ) )
  333. {
  334. DWORD dwFileLen = file.GetLength();
  335. dwCount += dwFileLen / blocksize;
  336. file.Close();
  337. }
  338. return dwCount;
  339. }
  341. int CQianlong::LoadCodetable( CStockContainer & container )
  342. {
  343. SP_ASSERT( m_bIsOK );
  344. if( !m_bIsOK ) return 0;
  346. int maxsize = GetMaxStockNumber();
  347. container.SetSize( maxsize );
  348. CStockInfo * pdata = container.GetData();
  350. char szShortName[QL_SHORTNAME_LEN+1];
  351. memset( szShortName, 0, sizeof(szShortName) );
  352. int  nCount = 0;
  353. CSPString sFileName = GetRootPath();
  354. sFileName += ml_sh_now;
  355. CSPFile file;
  356. if( file.Open( sFileName, CSPFile::modeRead | CSPFile::shareDenyNone ) )
  357. {
  358. // pin yin file
  359. CSPString sFileNamePyjc = GetRootPath();
  360. sFileNamePyjc += ml_sh_pyjc;
  361. CSPFile filePyjc;
  362. filePyjc.Open( sFileNamePyjc, CSPFile::modeRead | CSPFile::shareDenyNone );
  364. if( version302 == m_nVersion )
  365. {
  366. struct QL_Stock_info_V302 block;
  367. while( nCount < maxsize 
  368. && sizeof(block) == file.Read( &block, sizeof(block) ) )
  369. {
  370. pdata[nCount].Clear();
  371. ConvertQLStockInfo( CStock::marketSHSE, block, &(pdata[nCount]) );
  373. // read shortname
  374. if( CSPFile::hFileNull != filePyjc.m_hFile && QL_SHORTNAME_LEN == filePyjc.Read( szShortName, QL_SHORTNAME_LEN ) )
  375. pdata[nCount].SetStockShortName( szShortName );
  377. nCount ++;
  378. }
  379. }
  380. else if( version304 == m_nVersion )
  381. {
  382. struct QL_Stock_info2_V304 block;
  383. while( nCount < maxsize 
  384. && sizeof(block) == file.Read( &block, sizeof(block) ) )
  385. {
  386. pdata[nCount].Clear();
  387. ConvertQLStockInfo( CStock::marketSHSE, block, &(pdata[nCount]) );
  389. // read shortname
  390. if( CSPFile::hFileNull != filePyjc.m_hFile && QL_SHORTNAME_LEN == filePyjc.Read( szShortName, QL_SHORTNAME_LEN ) )
  391. pdata[nCount].SetStockShortName( szShortName );
  393. nCount ++;
  394. }
  395. }
  397. if( CSPFile::hFileNull != filePyjc.m_hFile )
  398. filePyjc.Close();
  399. file.Close();
  400. }
  402. sFileName = GetRootPath();
  403. sFileName += ml_sz_now;
  404. if( file.Open( sFileName, CSPFile::modeRead | CSPFile::shareDenyNone ) )
  405. {
  406. // pin yin file
  407. CSPString sFileNamePyjc = GetRootPath();
  408. sFileNamePyjc += ml_sz_pyjc;
  409. CSPFile filePyjc;
  410. filePyjc.Open( sFileNamePyjc, CSPFile::modeRead | CSPFile::shareDenyNone );
  412. if( version302 == m_nVersion )
  413. {
  414. struct QL_Stock_info_V302 block;
  415. while( nCount < maxsize 
  416. && sizeof(block) == file.Read( &block, sizeof(block) ) )
  417. {
  418. pdata[nCount].Clear();
  419. ConvertQLStockInfo( CStock::marketSZSE, block, &(pdata[nCount]) );
  421. // read shortname
  422. if( CSPFile::hFileNull != filePyjc.m_hFile && QL_SHORTNAME_LEN == filePyjc.Read( szShortName, QL_SHORTNAME_LEN ) )
  423. pdata[nCount].SetStockShortName( szShortName );
  425. nCount ++;
  426. }
  427. }
  428. else if( version304 == m_nVersion )
  429. {
  430. struct QL_Stock_info2_V304 block;
  431. while( nCount < maxsize 
  432. && sizeof(block) == file.Read( &block, sizeof(block) ) )
  433. {
  434. pdata[nCount].Clear();
  435. ConvertQLStockInfo( CStock::marketSZSE, block, &(pdata[nCount]) );
  437. // read shortname
  438. if( CSPFile::hFileNull != filePyjc.m_hFile && QL_SHORTNAME_LEN == filePyjc.Read( szShortName, QL_SHORTNAME_LEN ) )
  439. pdata[nCount].SetStockShortName( szShortName );
  441. nCount ++;
  442. }
  443. }
  444. file.Close();
  445. }
  447. container.SetSize( nCount );
  448. return nCount;
  449. }
  451. int CQianlong::StoreCodetable( CStockContainer & container )
  452. {
  453. SP_ASSERT( FALSE );
  454. return 0;
  455. }
  457. int CQianlong::LoadKDataCache( CStockContainer & container, PROGRESS_CALLBACK fnCallback, void *cookie, int nProgStart, int nProgEnd )
  458. {
  459. SP_ASSERT( m_bIsOK );
  460. if( !m_bIsOK ) return 0;
  462. UINT nCacheDays = AfxGetProfile().GetCacheDays();
  464. // 读取行情缓存
  465. SP_ASSERT( nProgStart <= nProgEnd );
  466. int nCount = container.GetSize();
  467. int nCacheCount = 0;
  468. int nProgressSegment = nCount / 25;
  469. double dProgressRatio = ( 0 == nCount ? 1 : (nProgEnd-nProgStart)/nCount );
  470. for( int i=0; i<nCount; i++ )
  471. {
  472. container.Lock();
  474. CStockInfo & info = container.ElementAt(i);
  476. DWORD dwMarket = info.GetMarket();
  477. CSPString sCode = info.GetStockCode();
  479. // Get Data From Day K Line
  480. CSPString sFileName;
  481. GetFileName( sFileName, CStock::dataK, &info, CKData::ktypeDay );
  482. CSPFile file;
  483. if( file.Open( sFileName, CSPFile::modeRead | CSPFile::shareDenyNone ) )
  484. {
  485. DWORD dwFileLen = file.GetLength();
  486. struct QL_Data_day qlkd;
  487. info.m_kdata.SetSize( 0, nCacheDays+3 );
  488. if( dwFileLen > sizeof(qlkd)*(nCacheDays+1) )
  489. file.Seek( dwFileLen-sizeof(qlkd)*(nCacheDays+1), CSPFile::begin );
  491. while( sizeof(qlkd) == file.Read( &qlkd, sizeof(qlkd) ) )
  492. {
  493. KDATA kd;
  494. convert_QL_Data_day_to_KDATA( dwMarket, sCode, &qlkd, &kd );
  495. info.m_kdata.Add( kd );
  496. }
  497. file.Close();
  498. nCacheCount ++;
  500. if( fnCallback && !(nCacheCount % nProgressSegment) )
  501. fnCallback( PROG_PROGRESS, (int)(nProgStart+nCacheCount*dProgressRatio), NULL, cookie );
  502. }
  504. container.UnLock();
  505. }
  507. return nCount;
  508. }
  510. int CQianlong::LoadBasetable( CStockContainer & container )
  511. {
  512. SP_ASSERT( FALSE );
  513. return 0;
  514. }
  516. int CQianlong::StoreBasetable( CStockContainer & container )
  517. {
  518. SP_ASSERT( FALSE );
  519. return 0;
  520. }
  522. int CQianlong::LoadBaseText( CStock *pstock )
  523. {
  524. SP_ASSERT( m_bIsOK && pstock && pstock->GetStockInfo().IsValidStock() );
  525. if( ! m_bIsOK || ! pstock || !pstock->GetStockInfo().IsValidStock() ) return 0;
  527. CSPString sFileName;
  528. GetFileName( sFileName, CStock::dataBasetext, &(pstock->GetStockInfo()) );
  530. int nCount = 0;
  531. CSPFile file;
  532. if( file.Open( sFileName, CSPFile::modeRead | CSPFile::shareDenyNone ) )
  533. {
  534. DWORD dwLen = file.GetLength();
  535. if( pstock->AllocBaseTextMem( dwLen ) )
  536. {
  537. nCount = file.Read( pstock->GetBaseTextPtr(), dwLen );
  538. }
  539. file.Close();
  540. }
  542. return nCount;
  543. }
  545. int CQianlong::LoadKData( CStock *pstock, int nKType )
  546. {
  547. SP_ASSERT( m_bIsOK && pstock && pstock->GetStockInfo().IsValidStock() );
  548. if( ! m_bIsOK || ! pstock || !pstock->GetStockInfo().IsValidStock() ) return 0;
  550. CKData * pkdata = NULL;
  552. DWORD dwMarket = pstock->GetStockInfo().GetMarket();
  553. CSPString sCode = pstock->GetStockCode();
  555. CSPString sFileName;
  556. GetFileName( sFileName, CStock::dataK, &(pstock->GetStockInfo()), nKType );
  558. switch( nKType )
  559. {
  560. case CKData::ktypeMonth:
  561. pkdata = &(pstock->GetKDataMonth());
  562. break;
  563. case CKData::ktypeWeek:
  564. pkdata = &(pstock->GetKDataWeek());
  565. break;
  566. case CKData::ktypeDay:
  567. pkdata = &(pstock->GetKDataDay());
  568. break;
  569. case CKData::ktypeMin60:
  570. return 0;
  571. case CKData::ktypeMin30:
  572. return 0;
  573. case CKData::ktypeMin15:
  574. return 0;
  575. case CKData::ktypeMin5:
  576. pkdata = &(pstock->GetKDataMin5());
  577. break;
  578. default:
  579. return 0;
  580. }
  582. if( CKData::IsDayOrMin(nKType) )
  583. {
  584. CSPFile file;
  585. if( pkdata && file.Open( sFileName, CSPFile::modeRead | CSPFile::shareDenyNone ) )
  586. {
  587. DWORD dwLen = file.GetLength();
  588. struct QL_Data_day qlkd;
  589. int nSize = dwLen/sizeof(qlkd);
  591. int nOldMaindataType = pkdata->GetMaindataType();
  592. pkdata->Clear();
  593. pkdata->SetKType( nKType );
  594. pkdata->SetMaindataType( nOldMaindataType );
  596. pkdata->SetSize( 0, nSize+1 );
  597. while( sizeof(qlkd) == file.Read( &qlkd, sizeof(qlkd) ) )
  598. {
  599. KDATA kd;
  600. convert_QL_Data_day_to_KDATA( dwMarket, sCode, &qlkd, &kd );
  601. pkdata->Add( kd );
  602. }
  604. file.Close();
  605. }
  606. }
  607. else
  608. {
  609. CSPFile file;
  610. if( pkdata && file.Open( sFileName, CSPFile::modeRead | CSPFile::shareDenyNone ) )
  611. {
  612. DWORD dwLen = file.GetLength();
  613. struct QL_Data_5min qlkd;
  614. int nSize = dwLen/sizeof(qlkd);
  616. int nOldMaindataType = pkdata->GetMaindataType();
  617. pkdata->Clear();
  618. pkdata->SetKType( nKType );
  619. pkdata->SetMaindataType( nOldMaindataType );
  621. pkdata->SetSize( 0, nSize+1 );
  622. while( sizeof(qlkd) == file.Read( &qlkd, sizeof(qlkd) ) )
  623. {
  624. KDATA kd;
  625. convert_QL_Data_5min_to_KDATA( dwMarket, sCode, &qlkd, &kd );
  626. pkdata->Add( kd );
  627. }
  629. file.Close();
  630. }
  631. }
  633. return pkdata->GetSize();
  634. }
  636. int CQianlong::LoadDRData( CStock *pstock )
  637. {
  638. return 0;
  639. }
  641. int CQianlong::StoreDRData( CStock *pstock )
  642. {
  643. return 0;
  644. }
  646. int CQianlong::LoadReport( CStock *pstock )
  647. {
  648. // load shtrace.dat sztrace.dat
  649. return 0;
  650. }
  652. int CQianlong::LoadMinute( CStock *pstock )
  653. {
  654. // load shminute.dat szminute.dat
  655. return 0;
  656. }
  658. int CQianlong::LoadOutline( CStock *pstock )
  659. {
  660. return 0;
  661. }
  663. int CQianlong::StoreReport( REPORT * pReport, int nCount, BOOL bBigTrade )
  664. {
  665. SP_ASSERT( FALSE );
  666. return 0;
  667. }
  669. int CQianlong::StoreMinute( MINUTE * pMinute, int nCount )
  670. {
  671. SP_ASSERT( FALSE );
  672. return 0;
  673. }
  675. int CQianlong::StoreOutline( OUTLINE * pOutline, int nCount )
  676. {
  677. SP_ASSERT( FALSE );
  678. return 0;
  679. }
  681. int CQianlong::DetectVersion( const char * szRootPath )
  682. {
  683. int nRet = versionUnknown;
  684. if( ! szRootPath ) return nRet;
  686. int  nCount = 0;
  687. CSPString sFileName = szRootPath;
  688. sFileName += ml_sh_now;
  689. CSPFile file;
  690. if( file.Open( sFileName, CSPFile::modeRead | CSPFile::shareDenyNone ) )
  691. {
  692. int nErrorCount = 1;
  693. int nTotalCount = 1;
  695. struct QL_Stock_info_V302 block;
  696. while( sizeof(block) == file.Read( &block, sizeof(block) ) )
  697. {
  698. nTotalCount ++;
  699. if( block.data_id != 0 && block.data_id != 0xFF && block.data_id != 0x94 )
  700. {
  701. nErrorCount ++;
  702. }
  703. }
  705. if( (nErrorCount << 5) < nTotalCount )
  706. {
  707. nRet = version302;
  708. }
  709. else
  710. {
  711. nErrorCount = 1;
  712. nTotalCount = 1;
  713. struct QL_Stock_info2_V304 block2;
  714. file.SeekToBegin();
  715. while( sizeof(block2) == file.Read( &block2, sizeof(block2) ) )
  716. {
  717. nTotalCount ++;
  718. if( block2.data_id != 0 && block2.data_id != 0xFF )
  719. {
  720. nErrorCount ++;
  721. }
  722. }
  723. if( (nErrorCount << 5) < nTotalCount )
  724. nRet = version304;
  725. }
  727. file.Close();
  728. }
  730. return nRet;
  731. }
  733. BOOL CQianlong::GetAccurateRoot( const char * rootpath, char *accurateroot, int maxlen )
  734. {
  735. if( 0 == rootpath || strlen(rootpath)==0 )
  736. return FALSE;
  738. // get rootpath
  739. CSPString strRoot = rootpath;
  740. int nLen = strRoot.GetLength();
  741. if( strRoot[nLen-1] != '\' && strRoot[nLen-1] != '/' )
  742. strRoot += CHAR_DIRSEP;
  743. nLen = strRoot.GetLength();
  745. if( 0 != access( strRoot + ml_sh_now, 0 ) )
  746. return FALSE;
  748. if( 0 != access( strRoot + ml_sh, 0 ) )
  749. return FALSE;
  750. if( 0 != access( strRoot + ml_sh_base, 0 ) )
  751. return FALSE;
  752. if( 0 != access( strRoot + ml_sh_day, 0 ) )
  753. return FALSE;
  754. if( 0 != access( strRoot + ml_sh_min, 0 ) )
  755. return FALSE;
  757. strncpy( accurateroot, strRoot, maxlen-1);
  758. accurateroot[maxlen-1] = '';
  760. return TRUE;
  761. }
  763. int CQianlong::InstallCodetbl( const char * filename, const char *orgname )
  764. {
  765. if( NULL == filename || strlen(filename) == 0
  766. || NULL == orgname || strlen(orgname) == 0 )
  767. return 0;
  769. CSPString sFileName = GetRootPath();
  770. sFileName += ml_dat;
  771. sFileName += orgname;
  773. return CSPFile::CopyFile( filename, sFileName, FALSE );
  774. }
  776. int CQianlong::InstallCodetblBlock( const char * filename, const char *orgname )
  777. {
  778. SP_ASSERT( FALSE );
  779. return 0;
  780. }
  782. int CQianlong::InstallCodetblFxjBlock( const char * filename, const char *orgname )
  783. {
  784. SP_ASSERT( FALSE );
  785. return 0;
  786. }
  788. int CQianlong::InstallKData( CKData &kdata, BOOL bOverwrite )
  789. {
  790. UINT nOpenFlags = CSPFile::modeCreate | CSPFile::modeReadWrite;
  791. if( !bOverwrite ) nOpenFlags |= CSPFile::modeNoTruncate;
  793. int nCount = 0;
  794. CSPFile fileTo;
  795. CSPString sFileName;
  796. CStockInfo stockinfo;
  798. DWORD dwMarket = kdata.ElementAt(0).m_dwMarket;
  799. CSPString sCode = kdata.ElementAt(0).m_szCode;
  801. stockinfo.SetStockCode( dwMarket, sCode );
  802. if( !GetFileName( sFileName, CStock::dataK, &stockinfo, kdata.GetKType() ) )
  803. return 0;
  805. if( CKData::IsDayOrMin(kdata.GetKType()) )
  806. {
  807. if( fileTo.Open( sFileName, nOpenFlags ) )
  808. {
  809. for( int i=0; i<kdata.GetSize(); i++ )
  810. {
  811. struct QL_Data_day qlkdnew;
  812. convert_KDATA_to_QL_Data_day( &(kdata.ElementAt(i)), &qlkdnew );
  814. struct QL_Data_day qlkd;
  815. memset( &qlkd, 0, sizeof(qlkd) );
  816. BOOL bHas = FALSE;
  817. BOOL bInsert = FALSE;
  818. while( sizeof(qlkd) == fileTo.Read( &qlkd, sizeof(qlkd) ) )
  819. {
  820. if( qlkd.day_date == qlkdnew.day_date )
  821. {
  822. bHas = TRUE;
  823. fileTo.Seek( fileTo.GetPosition()-sizeof(qlkd), CSPFile::begin );
  824. break;
  825. }
  826. if( qlkd.day_date > qlkdnew.day_date )
  827. {
  828. bInsert = TRUE;
  829. break;
  830. }
  831. }
  832. if( bHas || !bInsert )
  833. fileTo.Write( &qlkdnew, sizeof(qlkdnew) );
  834. else if( bInsert )
  835. {
  836. int nCur = fileTo.GetPosition();
  837. int nLen = fileTo.GetLength();
  838. BYTE * pbuffer = new BYTE[nLen-nCur+1];
  839. if( pbuffer )
  840. {
  841. if( nLen - nCur > 0 ) fileTo.Read( pbuffer, nLen-nCur );
  842. fileTo.Seek( nCur-sizeof(qlkd), CSPFile::begin );
  843. fileTo.Write( &qlkdnew, sizeof(qlkdnew) );
  844. fileTo.Write( &qlkd, sizeof(qlkd) );
  845. if( nLen - nCur > 0 ) fileTo.Write( pbuffer, nLen-nCur );
  846. delete [] pbuffer;
  847. }
  848. fileTo.Seek( nCur, CSPFile::begin );
  849. }
  850. nCount ++;
  851. }
  852. }
  853. }
  854. else
  855. {
  856. if( fileTo.Open( sFileName, nOpenFlags ) )
  857. {
  858. for( int i=0; i<kdata.GetSize(); i++ )
  859. {
  860. struct QL_Data_5min qlkdnew;
  861. convert_KDATA_to_QL_Data_5min( &(kdata.ElementAt(i)), &qlkdnew );
  863. struct QL_Data_5min qlkd;
  864. memset( &qlkd, 0, sizeof(qlkd) );
  865. BOOL bHas = FALSE;
  866. BOOL bInsert = FALSE;
  867. while( sizeof(qlkd) == fileTo.Read( &qlkd, sizeof(qlkd) ) )
  868. {
  869. if( qlkd.min_off == qlkdnew.min_off )
  870. {
  871. bHas = TRUE;
  872. fileTo.Seek( fileTo.GetPosition()-sizeof(qlkd), CSPFile::begin );
  873. break;
  874. }
  875. if( qlkd.min_off > qlkdnew.min_off )
  876. {
  877. bInsert = TRUE;
  878. break;
  879. }
  880. }
  881. if( bHas || !bInsert )
  882. fileTo.Write( &qlkdnew, sizeof(qlkdnew) );
  883. else if( bInsert )
  884. {
  885. int nCur = fileTo.GetPosition();
  886. int nLen = fileTo.GetLength();
  887. BYTE * pbuffer = new BYTE[nLen-nCur+1];
  888. if( pbuffer )
  889. {
  890. if( nLen - nCur > 0 ) fileTo.Read( pbuffer, nLen-nCur );
  891. fileTo.Seek( nCur-sizeof(qlkd), CSPFile::begin );
  892. fileTo.Write( &qlkdnew, sizeof(qlkdnew) );
  893. fileTo.Write( &qlkd, sizeof(qlkd) );
  894. if( nLen - nCur > 0 ) fileTo.Write( pbuffer, nLen-nCur );
  895. delete [] pbuffer;
  896. }
  897. fileTo.Seek( nCur, CSPFile::begin );
  898. }
  899. nCount ++;
  900. }
  901. }
  902. }
  904. return nCount;
  905. }
  907. int CQianlong::InstallKDataTy( const char * stkfile, int nKType,
  908. PROGRESS_CALLBACK fnCallback, void *cookie )
  909. {
  910. if( NULL == stkfile || strlen(stkfile) == 0 )
  911. return 0;
  913. int nTotalRecordCount = 0;
  914. int nProgCount = 0;
  915. int nCount = 0;
  917. CSPFile file;
  918. if( file.Open( stkfile, CSPFile::modeRead ) )
  919. {
  920. TYDAY_FHEADER header;
  921. if( sizeof(header) == file.Read(&header,sizeof(header)) )
  922. {
  923. nTotalRecordCount = header.recordcount;
  924. TYDAY_RECORD block;
  925. CKData kdata( nKType );
  926. CSPString sCurCode;
  927. while( sizeof(block) == file.Read(&block,sizeof(block)) )
  928. {
  929. nProgCount ++;
  930. if( fnCallback && nTotalRecordCount > 0 )
  931. fnCallback( PROG_PROGRESS, DWORD(STKLIB_MAXF_PROGRESS*nProgCount/nTotalRecordCount), NULL, cookie );
  933. KDATA kdnew;
  934. if( CKData::IsDayOrMin(nKType) )
  935. convert_TYDAY_RECORD_to_KDATA( &block, &kdnew );
  936. else
  937. convert_TYDAY_RECORD_MIN_to_KDATA( &block, &kdnew );
  939. if( sCurCode.IsEmpty() )
  940. sCurCode = kdnew.m_szCode;
  942. if( 0 == strcmp(kdnew.m_szCode,sCurCode) )
  943. kdata.Add( kdnew );
  944. else
  945. {
  946. nCount += InstallKData( kdata );
  947. kdata.RemoveAll();
  949. kdata.Add( kdnew );
  950. sCurCode = kdnew.m_szCode;
  951. }
  952. }
  954. if( kdata.GetSize() > 0 )
  955. {
  956. nCount += InstallKData( kdata );
  957. kdata.RemoveAll();
  958. }
  959. }
  960. file.Close();
  961. }
  963. if( fnCallback )
  964. fnCallback( PROG_PROGRESS, STKLIB_MAX_PROGRESS, NULL, cookie );
  966. return nCount;
  967. }
  969. int CQianlong::InstallKDataFxj( const char * dadfile, int nKType,
  970. PROGRESS_CALLBACK fnCallback, void *cookie )
  971. {
  972. if( NULL == dadfile || strlen(dadfile) == 0 )
  973. return 0;
  975. int nTotalStockCount = 0;
  976. int nProgCount = 0;
  977. int nCount = 0;
  979. CSPFile file;
  980. if( file.Open( dadfile, CSPFile::modeRead ) )
  981. {
  982. FXJDAY_FHEADER header;
  983. if( sizeof(header) == file.Read(&header,sizeof(header)) )
  984. {
  985. nTotalStockCount = header.m_dwStockCount;
  986. FXJDAY_RECORD block;
  987. CKData kdata( nKType );
  988. DWORD dwMarket = CStock::marketUnknown;
  989. CSPString sCurCode;
  990. while( sizeof(block) == file.Read(&block,sizeof(block)) )
  991. {
  992. if( -1 == block.m_dwMagic )
  993. {
  994. if( kdata.GetSize() > 0 )
  995. nCount += InstallKData( kdata );
  996. kdata.RemoveAll();
  998. if( 'HS' == block.m_wMarket )
  999. dwMarket = CStock::marketSHSE;
  1000. else if( 'ZS' == block.m_wMarket )
  1001. dwMarket = CStock::marketSZSE;
  1002. else
  1003. dwMarket = CStock::marketUnknown;
  1005. char code[sizeof(block.m_szCode)+2];
  1006. memset( code, 0, sizeof(code) );
  1007. strncpy( code, block.m_szCode, min(sizeof(code)-1,sizeof(block.m_szCode)) );
  1008. sCurCode = code;
  1010. nProgCount ++;
  1011. if( fnCallback && nTotalStockCount > 0 )
  1012. fnCallback( PROG_PROGRESS, DWORD(STKLIB_MAXF_PROGRESS*nProgCount/nTotalStockCount), NULL, cookie );
  1013. }
  1014. else
  1015. {
  1016. KDATA kdnew;
  1017. if( convert_FXJDAY_RECORD_to_KDATA( dwMarket, sCurCode, nKType, &block, &kdnew ) )
  1018. kdata.Add( kdnew );
  1019. }
  1020. }
  1022. if( kdata.GetSize() > 0 )
  1023. {
  1024. nCount += InstallKData( kdata );
  1025. kdata.RemoveAll();
  1026. }
  1027. }
  1028. file.Close();
  1029. }
  1031. if( fnCallback )
  1032. fnCallback( PROG_PROGRESS, STKLIB_MAX_PROGRESS, NULL, cookie );
  1034. return nCount;
  1035. }
  1037. int CQianlong::InstallDRData( CDRData & drdata )
  1038. {
  1039. SP_ASSERT( FALSE );
  1040. return 0;
  1041. }
  1043. int CQianlong::InstallDRDataClk( const char * filename, const char *orgname )
  1044. {
  1045. SP_ASSERT( FALSE );
  1046. return 0;
  1047. }
  1049. int CQianlong::InstallDRDataFxj( const char * fxjfilename )
  1050. {
  1051. SP_ASSERT( FALSE );
  1052. return 0;
  1053. }
  1055. int CQianlong::InstallBasetable( const char * filename, const char * orgname )
  1056. {
  1057. SP_ASSERT( FALSE );
  1058. return 0;
  1059. }
  1061. int CQianlong::InstallBasetableTdx( const char * filename )
  1062. {
  1063. SP_ASSERT( FALSE );
  1064. return 0;
  1065. }
  1067. int CQianlong::InstallBasetableFxj( const char * filename )
  1068. {
  1069. SP_ASSERT( FALSE );
  1070. return 0;
  1071. }
  1073. int CQianlong::InstallBaseText( const char * filename, const char *orgname )
  1074. {
  1075. if( NULL == filename || strlen(filename) == 0
  1076. || NULL == orgname || strlen(orgname) == 0 )
  1077. return 0;
  1079. CSPString sCode = orgname;
  1080. int nIndex = sCode.Find( '.' );
  1081. if( -1 != nIndex )
  1082. {
  1083. sCode = sCode.Left(nIndex);
  1084. CStockInfo stockinfo;
  1085. stockinfo.SetStockCode( CStock::marketUnknown, sCode );
  1086. CSPString sFileName;
  1087. if( GetFileName( sFileName, CStock::dataBasetext, &stockinfo ) )
  1088. {
  1089. return CSPFile::CopyFile( filename, sFileName, FALSE );
  1090. }
  1091. }
  1093. return 0;
  1094. }
  1096. int CQianlong::InstallBaseText( const char * buffer, int nLen, const char *orgname )
  1097. {
  1098. if( NULL == buffer || nLen <= 0
  1099. || NULL == orgname || strlen(orgname) == 0 )
  1100. return 0;
  1102. CSPString sCode = orgname;
  1103. int nIndex = sCode.Find( '.' );
  1104. if( -1 != nIndex )
  1105. {
  1106. sCode = sCode.Left(nIndex);
  1107. CStockInfo stockinfo;
  1108. stockinfo.SetStockCode( CStock::marketUnknown, sCode );
  1109. CSPString sFileName;
  1110. CSPFile file;
  1111. if( GetFileName( sFileName, CStock::dataBasetext, &stockinfo )
  1112. && file.Open(sFileName,CSPFile::modeWrite|CSPFile::modeCreate) )
  1113. {
  1114. file.Write( buffer, nLen );
  1115. file.Close();
  1116. return 1;
  1117. }
  1118. }
  1120. return 0;
  1121. }
  1123. int CQianlong::InstallNewsText( const char * filename, const char *orgname )
  1124. {
  1125. SP_ASSERT( FALSE );
  1126. return 0;
  1127. }
  1129. int CQianlong::InstallNewsText( const char * buffer, int nLen, const char *orgname )
  1130. {
  1131. SP_ASSERT( FALSE );
  1132. return 0;
  1133. }
  1135. BOOL CQianlong::GetFileName( CSPString &sFileName, int nDataType,
  1136. CStockInfo * pInfo, int nKType )
  1137. {
  1138. if( NULL == pInfo || !pInfo->IsValidStock() )
  1139. return FALSE;
  1141. // 确定市场类型
  1142. if( CStock::marketUnknown == pInfo->GetMarket() )
  1143. pInfo->ResolveTypeAndMarket( );
  1145. if( CStock::dataBasetext == nDataType )
  1146. {
  1147. sFileName = GetRootPath();
  1148. if( pInfo->IsShenZhen() )
  1149. sFileName += ml_sz_base;
  1150. else
  1151. sFileName += ml_sh_base;
  1152. sFileName += CSPString(pInfo->GetStockCode()) + ml_ext_base;
  1153. return TRUE;
  1154. }
  1155. else if( CStock::dataK == nDataType )
  1156. {
  1157. sFileName = GetRootPath();
  1158. if( pInfo->IsShenZhen() )
  1159. sFileName += ml_sz;
  1160. else
  1161. sFileName += ml_sh;
  1163. switch( nKType )
  1164. {
  1165. case CKData::ktypeMonth:
  1166. sFileName += CSPString(ml_month) + pInfo->GetStockCode() + ml_ext_month;
  1167. break;
  1168. case CKData::ktypeWeek:
  1169. sFileName += CSPString(ml_week) + pInfo->GetStockCode() + ml_ext_week;
  1170. break;
  1171. case CKData::ktypeDay:
  1172. sFileName += CSPString(ml_day) + pInfo->GetStockCode() + ml_ext_day;
  1173. break;
  1174. case CKData::ktypeMin60:
  1175. return FALSE;
  1176. case CKData::ktypeMin30:
  1177. return FALSE;
  1178. case CKData::ktypeMin15:
  1179. return FALSE;
  1180. case CKData::ktypeMin5:
  1181. sFileName += CSPString(ml_min5) + pInfo->GetStockCode() + ml_ext_min5;
  1182. break;
  1183. default:
  1184. SP_ASSERT( FALSE );
  1185. return FALSE;
  1186. }
  1187. return TRUE;
  1188. }
  1189. else if( CStock::dataDR == nDataType )
  1190. {
  1191. return FALSE;
  1192. }
  1194. return FALSE;
  1195. }