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

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

金融证券系统

开发平台：

Visual C++

SelfDB.cpp：源码内容
  1. /*
  2. Cross Platform Core Code.
  4. Copyright(R) 2001-2002 Balang Software.
  5. All rights reserved.
  7. Using:
  8. class CClkFile;
  9. class CSelfDB;
  10. */
  12. #include "StdAfx.h"
  13. #include "../Include/Database.h"
  14. #include "../Include/SpString.h"
  15. #include "SpLock.h"
  16. #include <direct.h>
  17. #include "SelfDB.h"
  19. #ifdef _DEBUG
  20. #define new DEBUG_NEW
  21. #undef THIS_FILE
  22. static char THIS_FILE[] = __FILE__;
  23. #endif
  25. /////////////////////////////////////////////////////////////////////////////////////
  26. // SelfDB strings
  27. extern char ml_dat[];
  28. extern char ml_dat[];
  29. extern char ml_sh_info[];
  30. extern char ml_sz_info[];
  31. extern char ml_sh_now[];
  32. extern char ml_sz_now[];
  33. extern char ml_sh_pyjc[];
  34. extern char ml_sz_pyjc[];
  35. extern char ml_sh_trace[];
  36. extern char ml_sz_trace[];
  37. extern char ml_sh_minute[];
  38. extern char ml_sz_minute[];
  40. extern char ml_data[];
  41. extern char ml_sh[];
  42. extern char ml_sz[];
  43. extern char ml_base[];
  44. extern char ml_month[];
  45. extern char ml_week[];
  46. extern char ml_day[];
  47. extern char ml_min5[];
  48. extern char ml_sh_base[];
  49. extern char ml_sz_base[];
  50. extern char ml_sh_month[];
  51. extern char ml_sz_month[];
  52. extern char ml_sh_week[];
  53. extern char ml_sz_week[];
  54. extern char ml_sh_day[];
  55. extern char ml_sz_day[];
  56. extern char ml_sh_min[];
  57. extern char ml_sz_min[];
  58. extern char ml_ext_base[];
  59. extern char ml_ext_month[];
  60. extern char ml_ext_week[];
  61. extern char ml_ext_day[];
  62. extern char ml_ext_min5[];
  64. char self_ext_xdr[] = ".dat";
  66. char self_sh_xdr[] = "data\shase\xdrdata\";
  67. char self_sz_xdr[] = "data\sznse\xdrdata\";
  68. char self_news[] = "data\news\";
  70. char self_chna_xdr[] = "data\CHNA.pwr"; // 除权文件，与分析家格式相同
  71. char self_chna_basetbl[]= "data\CHNA.bst"; // 财务资料表
  73. // 代码表文件
  74. char self_sh_code[] = "data\SHSE.cod"; // 上海代码表
  75. char self_sz_code[] = "data\SZSE.cod"; // 深圳代码表
  77. // 行情缓存文件
  78. char self_sh_report[] = "dat\SHSE.rpt"; // 上海行情保存文件
  79. char self_sz_report[] = "dat\SZSE.rpt"; // 深圳行情保存文件
  80. char self_sh_minute[] = "dat\SHSE.min"; // 上海分时保存文件
  81. char self_sz_minute[] = "dat\SZSE.min"; // 深圳分时保存文件
  82. char self_outline[] = "dat\clkoutln.out";
  84. /////////////////////////////////////////////////////////////////////////////////////
  85. // SelfDB convertor
  87. BOOL convert_CLK_DRDATA_to_DRDATA( DWORD dwMarket, const char *szCode, CLK_DRDATA * pdbdr, DRDATA * pdr )
  88. {
  89. SP_ASSERT( pdbdr && pdr );
  90. if( NULL == pdbdr || NULL == pdr )
  91. return FALSE;
  92. memset( pdr, 0, sizeof(DRDATA) );
  94. pdr->m_dwMarket = dwMarket;
  95. if( szCode )
  96. strncpy( pdr->m_szCode, szCode, min(sizeof(pdr->m_szCode)-1,strlen(szCode)) );
  98. pdr->m_date = pdbdr->date;
  99. CSPTime sptime;
  100. if( sptime.FromStockTimeDay(pdr->m_date) )
  101. pdr->m_time = sptime.GetTime();
  103. pdr->m_fProfit = (float)( pdbdr->bonus * 0.0001 );
  104. pdr->m_fGive = (float)( pdbdr->bonus_share * 0.001 );
  105. pdr->m_fPei = (float)( pdbdr->ration_share * 0.001 );
  106. pdr->m_fPeiPrice= (float)( pdbdr->ration_value * 0.001 );
  108. return TRUE;
  109. }
  111. BOOL convert_DRDATA_to_CLK_DRDATA( DRDATA * pdr, CLK_DRDATA * pdbdr )
  112. {
  113. SP_ASSERT( pdbdr && pdr );
  114. if( NULL == pdbdr || NULL == pdr )
  115. return FALSE;
  116. memset( pdbdr, 0, sizeof(CLK_DRDATA) );
  118. pdbdr->date = pdr->m_date;
  120. pdbdr->bonus = (DWORD)( pdr->m_fProfit * 10000 );
  121. pdbdr->bonus_share = (DWORD)( pdr->m_fGive * 1000 );
  122. pdbdr->ration_share = (DWORD)( pdr->m_fPei * 1000 );
  123. pdbdr->ration_value = (DWORD)( pdr->m_fPeiPrice * 1000 );
  124. return TRUE;
  125. }
  127. BOOL convert_FXJ_DRDATA_to_DRDATA( DWORD dwMarket, const char *szCode, FXJ_DRDATA * pfxjdr, DRDATA * pdr )
  128. {
  129. SP_ASSERT( pfxjdr && pdr );
  130. if( NULL == pfxjdr || NULL == pdr )
  131. return FALSE;
  132. memset( pdr, 0, sizeof(DRDATA) );
  134. pdr->m_dwMarket = dwMarket;
  135. if( szCode )
  136. strncpy( pdr->m_szCode, szCode, min(sizeof(pdr->m_szCode)-1,strlen(szCode)) );
  138. pdr->m_time = pfxjdr->m_time;
  139. CSPTime sptime( pdr->m_time );
  140. pdr->m_date = sptime.ToStockTimeDay();
  142. pdr->m_fProfit = pfxjdr->m_fProfit;
  143. pdr->m_fGive = pfxjdr->m_fGive;
  144. pdr->m_fPei = pfxjdr->m_fPei;
  145. pdr->m_fPeiPrice= pfxjdr->m_fPeiPrice;
  147. return TRUE;
  148. }
  150. double StringToDouble( const char *sz, int nLen )
  151. {
  152. char szTemp[32];
  153. if( NULL == sz || nLen >= sizeof(szTemp) )
  154. {
  155. SP_ASSERT( FALSE );
  156. return 0;
  157. }
  159. memset( szTemp, 0, sizeof(szTemp) );
  160. memcpy( szTemp, sz, nLen );
  162. int nPos = 0;
  163. while( isspace(szTemp[nPos]) && nPos < nLen )
  164. nPos ++;
  165. if( nPos == nLen )
  166. return 0;
  167. return atof( &szTemp[nPos] );
  168. }
  170. BOOL convert_TDX_BASEDATA_to_BASEDATA( TDX_BASEDATA * ptdxbd, BASEDATA *pbd )
  171. {
  172. SP_ASSERT( ptdxbd && pbd );
  173. if( NULL == ptdxbd || NULL == pbd )
  174. return FALSE;
  175. memset( pbd, 0, sizeof(BASEDATA) );
  177. pbd->m_dwMarket = CStock::marketCHNA;
  178. strncpy( pbd->m_szCode, ptdxbd->m_szCode, min(sizeof(pbd->m_szCode)-1,sizeof(ptdxbd->m_szCode)) );
  180. CStockInfo info;
  181. if( AfxGetStockContainer().GetStockInfo( pbd->m_szCode, &info ) )
  182. {
  183. int nSize = info.m_basedata.GetSize();
  184. if( nSize > 0 )
  185. memcpy( pbd, &(info.m_basedata.ElementAt(nSize-1)), sizeof(BASEDATA) );
  186. pbd->m_dwMarket = info.GetMarket();
  187. }
  189. // char m_szDomain[STKLIB_MAX_DOMAIN]; // 板块
  190. // char m_szProvince[STKLIB_MAX_PROVINCE]; // 省份
  192. if( '0' == ptdxbd->m_szMarket )
  193. pbd->m_dwMarket = CStock::marketSZSE;
  194. else if( '1' == ptdxbd->m_szMarket )
  195. pbd->m_dwMarket = CStock::marketSHSE;
  197. pbd->m_date = (DWORD)StringToDouble( ptdxbd->m_szDate_modified, sizeof(ptdxbd->m_szDate_modified) );
  198. pbd->m_reporttype = CStock::reportAnnals; // 报告类型：年报、中报、季报
  199. CSPTime sptime;
  200. if( sptime.FromStockTimeDay( pbd->m_date ) )
  201. {
  202. pbd->m_time = sptime.GetTime();
  203. int nMonth = sptime.GetMonth();
  204. if( nMonth >= 4 && nMonth <= 6 )
  205. pbd->m_reporttype = CStock::reportQuarter;
  206. else if( nMonth >= 7 && nMonth <= 9 )
  207. pbd->m_reporttype = CStock::reportMid;
  208. else if( nMonth >= 10 && nMonth <= 12 )
  209. pbd->m_reporttype = CStock::reportQuarter3;
  210. }
  212. // float m_fErate_dollar; // 当期美元汇率
  213. // float m_fErate_hkdollar; // 当期港币汇率
  215. // ★偿债能力
  216. // float m_fRatio_liquidity; // 流动比率
  217. // float m_fRatio_quick; // 速动比率
  218. // float m_fVelocity_receivables; // 应收帐款周率
  220. // ★经营能力
  221. // float m_fVelocity_merchandise; // 存货周转率
  222. pbd->m_fMain_income = (float)StringToDouble( ptdxbd->m_szMain_income, sizeof(ptdxbd->m_szMain_income) ) * 1000;
  223. // float m_fCash_ps; // 每股净现金流量
  225. // ★资本结构
  226. pbd->m_datebegin = (DWORD)StringToDouble( ptdxbd->m_szDate_begin, sizeof(ptdxbd->m_szDate_begin) );
  227. pbd->m_fShare_count_total = (float)StringToDouble( ptdxbd->m_szShare_count_total, sizeof(ptdxbd->m_szShare_count_total) ) * 10000;
  228. pbd->m_fShare_count_a = (float)StringToDouble( ptdxbd->m_szShare_count_currency, sizeof(ptdxbd->m_szShare_count_currency) ) * 10000;
  229. pbd->m_fShare_count_b = (float)StringToDouble( ptdxbd->m_szShare_count_b, sizeof(ptdxbd->m_szShare_count_b) ) * 10000;
  230. pbd->m_fShare_count_h = (float)StringToDouble( ptdxbd->m_szShare_count_h, sizeof(ptdxbd->m_szShare_count_h) ) * 10000;
  231. pbd->m_fShare_count_national= (float)StringToDouble( ptdxbd->m_szShare_count_national, sizeof(ptdxbd->m_szShare_count_national) ) * 10000;
  232. pbd->m_fShare_count_corp = (float)StringToDouble( ptdxbd->m_szShare_count_corp, sizeof(ptdxbd->m_szShare_count_corp) ) * 10000;
  233. if( CStock::typeshB == info.GetType() || CStock::typeszB == info.GetType() ) // A B股 交换
  234. {
  235. float fTemp = pbd->m_fShare_count_a;
  236. pbd->m_fShare_count_a = pbd->m_fShare_count_b;
  237. pbd->m_fShare_count_b = fTemp;
  238. }
  240. if( pbd->m_fShare_count_total > 1e-4 )
  241. pbd->m_fProfit_psud = (float)StringToDouble( ptdxbd->m_szProfit_ud, sizeof(ptdxbd->m_szProfit_ud) ) * 1000 / pbd->m_fShare_count_total;
  242. pbd->m_fAsset = (float)StringToDouble( ptdxbd->m_szAsset, sizeof(ptdxbd->m_szAsset) ) * 1000;
  243. if( pbd->m_fAsset > 1e-4 )
  244. {
  245. pbd->m_fRatio_holderright= (float)( 100 * StringToDouble( ptdxbd->m_szNet_asset, sizeof(ptdxbd->m_szNet_asset) ) * 1000 / pbd->m_fAsset );
  246. pbd->m_fRatio_longdebt = (float)( 100 * StringToDouble( ptdxbd->m_szDebt_long, sizeof(ptdxbd->m_szDebt_long) ) * 1000 / pbd->m_fAsset );
  247. pbd->m_fRatio_debt = (float)( 100 * ( StringToDouble( ptdxbd->m_szDebt_long, sizeof(ptdxbd->m_szDebt_long) ) * 1000 / pbd->m_fAsset
  248. + StringToDouble( ptdxbd->m_szDebt_long, sizeof(ptdxbd->m_szDebt_long) ) * 1000 / pbd->m_fAsset ) );
  249. }
  251. // ★投资收益能力
  252. pbd->m_fNetasset_ps_regulate= (float)StringToDouble( ptdxbd->m_szNet_asset_ps_regulate, sizeof(ptdxbd->m_szNet_asset_ps_regulate) );
  253. if( pbd->m_fShare_count_total > 1e-4 )
  254. {
  255. pbd->m_fNetasset_ps = (float)StringToDouble( ptdxbd->m_szNet_asset, sizeof(ptdxbd->m_szNet_asset) ) * 1000 / pbd->m_fShare_count_total;
  256. pbd->m_fEps = (float)StringToDouble( ptdxbd->m_szNet_profit, sizeof(ptdxbd->m_szNet_profit) ) * 1000 / pbd->m_fShare_count_total;
  257. pbd->m_fEps_deduct = (float)( pbd->m_fEps - StringToDouble( ptdxbd->m_szOut_profit, sizeof(ptdxbd->m_szOut_profit) ) * 1000 / pbd->m_fShare_count_total );
  258. }
  260. pbd->m_fNet_profit = (float)StringToDouble( ptdxbd->m_szNet_profit, sizeof(ptdxbd->m_szNet_profit) ) * 1000;
  261. pbd->m_fMain_profit = (float)StringToDouble( ptdxbd->m_szMain_profit, sizeof(ptdxbd->m_szMain_profit) ) * 1000;
  262. pbd->m_fTotal_profit = (float)StringToDouble( ptdxbd->m_szTotal_profit, sizeof(ptdxbd->m_szTotal_profit) ) * 1000;
  264. // ★盈利能力
  265. if( pbd->m_fMain_income > 1e-4 )
  266. pbd->m_fProfit_margin = (float)( 100 * pbd->m_fMain_profit / pbd->m_fMain_income );
  267. if( pbd->m_fNetasset_ps > 1e-4 )
  268. pbd->m_fNetasset_yield = (float)( 100 * pbd->m_fEps / pbd->m_fNetasset_ps );
  270. return TRUE;
  271. }
  273. BOOL convert_FXJ_BASEDATA_to_BASEDATA( FXJ_BASEDATA * pfxjbd, BASEDATA *pbd, DWORD dwDate )
  274. {
  275. SP_ASSERT( pfxjbd && pbd );
  276. if( NULL == pfxjbd || NULL == pbd )
  277. return FALSE;
  278. memset( pbd, 0, sizeof(BASEDATA) );
  280. pbd->m_dwMarket = CStock::marketCHNA;
  281. strncpy( pbd->m_szCode, pfxjbd->m_szCode, min(sizeof(pbd->m_szCode)-1,sizeof(pfxjbd->m_szCode)) );
  283. CStockInfo info;
  284. if( AfxGetStockContainer().GetStockInfo( pbd->m_szCode, &info ) )
  285. {
  286. int nSize = info.m_basedata.GetSize();
  287. if( nSize > 0 )
  288. memcpy( pbd, &(info.m_basedata.ElementAt(nSize-1)), sizeof(BASEDATA) );
  289. pbd->m_dwMarket = info.GetMarket();
  290. }
  292. // char m_szDomain[STKLIB_MAX_DOMAIN]; // 板块
  293. // char m_szProvince[STKLIB_MAX_PROVINCE]; // 省份
  295. if( 'ZS' == pfxjbd->m_wMarket )
  296. pbd->m_dwMarket = CStock::marketSZSE;
  297. else if( 'HS' == pfxjbd->m_wMarket )
  298. pbd->m_dwMarket = CStock::marketSHSE;
  300. pbd->m_date = dwDate;
  301. pbd->m_reporttype = CStock::reportAnnals; // 报告类型：年报、中报、季报
  302. CSPTime sptime;
  303. if( sptime.FromStockTimeDay( pbd->m_date ) )
  304. {
  305. pbd->m_time = sptime.GetTime();
  306. int nMonth = sptime.GetMonth();
  307. if( nMonth >= 4 && nMonth <= 6 )
  308. pbd->m_reporttype = CStock::reportQuarter;
  309. else if( nMonth >= 7 && nMonth <= 9 )
  310. pbd->m_reporttype = CStock::reportMid;
  311. else if( nMonth >= 10 && nMonth <= 12 )
  312. pbd->m_reporttype = CStock::reportQuarter3;
  313. }
  315. // float m_fErate_dollar; // 当期美元汇率
  316. // float m_fErate_hkdollar; // 当期港币汇率
  318. // ★偿债能力
  319. // float m_fRatio_liquidity; // 流动比率
  320. // float m_fRatio_quick; // 速动比率
  321. // float m_fVelocity_receivables; // 应收帐款周率
  323. // ★经营能力
  324. // float m_fVelocity_merchandise; // 存货周转率
  325. pbd->m_fMain_income = pfxjbd->m_fData[21]*1000;
  326. // float m_fCash_ps; // 每股净现金流量
  328. // ★盈利能力
  329. if( pbd->m_fMain_income > 1e-4 )
  330. pbd->m_fProfit_margin = (float)( 100 * pfxjbd->m_fData[22]*1000 / pbd->m_fMain_income );
  331. pbd->m_fNetasset_yield = pfxjbd->m_fData[38];
  333. // ★资本结构
  334. // DWORD m_datebegin // 上市日期
  335. pbd->m_fShare_count_total = pfxjbd->m_fData[2]*10000;
  336. pbd->m_fShare_count_a = pfxjbd->m_fData[8]*10000;
  337. pbd->m_fShare_count_b = pfxjbd->m_fData[6]*10000;
  338. pbd->m_fShare_count_h = pfxjbd->m_fData[7]*10000;
  339. pbd->m_fShare_count_national= pfxjbd->m_fData[3]*10000;
  340. pbd->m_fShare_count_corp = pfxjbd->m_fData[5]*10000;
  341. // if( CStock::typeshB == info.GetType() || CStock::typeszB == info.GetType() ) // A B股 交换
  342. // {
  343. // float fTemp = pbd->m_fShare_count_a;
  344. // pbd->m_fShare_count_a = pbd->m_fShare_count_b;
  345. // pbd->m_fShare_count_b = fTemp;
  346. // }
  348. pbd->m_fProfit_psud = pfxjbd->m_fData[33];
  349. pbd->m_fAsset = pfxjbd->m_fData[11]*1000;
  350. pbd->m_fRatio_holderright = pfxjbd->m_fData[37];
  351. if( pbd->m_fAsset > 1e-4 )
  352. pbd->m_fRatio_longdebt = (float)( 100 * pfxjbd->m_fData[17] * 1000 / pbd->m_fAsset );
  353. pbd->m_fRatio_debt = 100 - pbd->m_fRatio_holderright;
  355. // ★投资收益能力
  356. pbd->m_fNetasset_ps = pfxjbd->m_fData[35];
  357. pbd->m_fNetasset_ps_regulate= pfxjbd->m_fData[36];
  358. pbd->m_fEps = pfxjbd->m_fData[34];
  359. if( pbd->m_fShare_count_total > 1e-4 )
  360. pbd->m_fEps_deduct = (float)( pbd->m_fEps - pfxjbd->m_fData[25] * 1000 / pbd->m_fShare_count_total );
  362. pbd->m_fNet_profit = pfxjbd->m_fData[31]*1000;
  363. pbd->m_fMain_profit = pfxjbd->m_fData[22]*1000;
  364. pbd->m_fTotal_profit = pfxjbd->m_fData[29]*1000;
  366. return TRUE;
  367. }
  369. /////////////////////////////////////////////////////////////////////////////////////
  370. // class CClkFile
  372. CClkFile::CClkFile( )
  373. {
  374. Close( );
  375. }
  377. CClkFile::~CClkFile( )
  378. {
  379. Close( );
  380. }
  382. BOOL CClkFile::Open( LPCTSTR lpszFileName )
  383. {
  384. Close( );
  386. if( !m_file.Open( lpszFileName, CSPFile::modeReadWrite ) )
  387. return FALSE;
  389. if( sizeof(m_header) != m_file.Read( &m_header, sizeof(m_header) ) )
  390. {
  391. SP_ASSERT( FALSE );
  392. return FALSE;
  393. }
  395. if( CLK_FHEADER_MAGIC != m_header.m_dwMagic )
  396. {
  397. SP_ASSERT( FALSE );
  398. return FALSE;
  399. }
  401. return TRUE;
  402. }
  404. void CClkFile::Close( )
  405. {
  406. if( m_file.m_hFile != (UINT)CSPFile::hFileNull )
  407. {
  408. m_header.m_time = time(NULL);
  409. m_file.Seek( 0, CSPFile::begin );
  410. m_file.Write( &m_header, sizeof(m_header) );
  411. m_file.Close();
  412. }
  414. memset( &m_header, 0, sizeof(m_header) );
  415. memset( &m_CurIndexRecord, 0, sizeof(m_CurIndexRecord) );
  416. m_dwPosCurIndex = -1;
  417. }
  419. // 创建空的数据文件
  420. BOOL CClkFile::BuildEmptyFile( LPCTSTR lpszFileName,
  421. DWORD dwDataType, // 数据分类说明，see CStock::DataType
  422. DWORD dwMarket, // 市场，see CStock::StockMarket，如果文件包含多个市场，则=0无效
  423. DWORD dwIndexRecordCount, // 索引区记录单元个数
  424. DWORD dwRecordPerBlock, // 每个Block的记录数
  425. BOOL bRebuildIfExists )
  426. {
  427. SP_ASSERT( NULL != lpszFileName && strlen(lpszFileName) > 0 );
  428. if( NULL == lpszFileName || strlen(lpszFileName) <= 0 )
  429. return FALSE;
  431. // 如果文件存在
  432. if( !bRebuildIfExists && 0 == access(lpszFileName,0) )
  433. return TRUE;
  435. CLK_FHEADER header;
  436. memset( &header, 0,sizeof(header) );
  437. header.m_dwMagic = CLK_FHEADER_MAGIC;
  438. header.m_dwVerMajor = CLK_FHEADER_VERMAJOR;
  439. header.m_dwVerMinor = CLK_FHEADER_VERMINOR;
  440. strcpy( header.m_szDescript, "CLKing Stock File Structure. See www.ninebulls.com for more information." );
  441. header.m_dwDataType = dwDataType;
  442. header.m_dwMarket = dwMarket;
  443. header.m_time = time(NULL);
  445. // 索引区信息
  446. header.m_dwPosFirstIndex = sizeof(header);
  447. header.m_dwIndexRecordSize = sizeof(CLK_INDEXRECORD);
  448. header.m_dwIndexRecordCount = dwIndexRecordCount;
  449. header.m_dwStockCount = 0;
  451. // 数据区信息
  452. switch( dwDataType )
  453. {
  454. case CStock::dataReport:
  455. header.m_dwDataRecordSize = sizeof(REPORT);
  456. break;
  457. case CStock::dataMinute:
  458. header.m_dwDataRecordSize = sizeof(MINUTE);
  459. break;
  460. case CStock::dataK:
  461. header.m_dwDataRecordSize = sizeof(KDATA);
  462. default:
  463. SP_ASSERT(FALSE);
  464. return FALSE;
  465. }
  466. header.m_dwRecordPerBlock = dwRecordPerBlock;
  467. header.m_dwBlockSize = sizeof(CLK_BLOCKHEADER) + header.m_dwDataRecordSize * header.m_dwRecordPerBlock;
  468. header.m_dwPosFirstBlock = sizeof(CLK_FHEADER) + header.m_dwIndexRecordSize * header.m_dwIndexRecordCount;
  469. header.m_dwPosFirstBlankBlock = -1;
  471. CSPFile file;
  472. if( !file.Open( lpszFileName, CSPFile::modeCreate | CSPFile::modeReadWrite ) )
  473. {
  474. SP_ASSERT( FALSE );
  475. return FALSE;
  476. }
  477. file.Write( &header, sizeof(header) );
  479. for( DWORD i=0; i<header.m_dwIndexRecordCount; i++ )
  480. {
  481. CLK_INDEXRECORD index;
  482. memset( &index, 0, sizeof(index) );
  483. index.m_dwMagic = CLK_INDEXRECORD_MAGIC;
  484. index.m_dwPosFirstBlock = -1;
  485. file.Write( &index, sizeof(index) );
  486. }
  488. file.Flush();
  489. return TRUE;
  490. }
  492. // 重新创建，如果日期不是tmNow
  493. BOOL CClkFile::RemoveFileIfOutoftime( LPCTSTR lpszFileName, time_t tmNow )
  494. {
  495. SP_ASSERT( NULL!=lpszFileName && strlen(lpszFileName) > 0 );
  496. if( NULL==lpszFileName || strlen(lpszFileName) <= 0 )
  497. return FALSE;
  499. CClkFile file;
  500. if( file.Open(lpszFileName) )
  501. {
  502. CSPTime ft( file.m_header.m_time );
  503. CSPTime tNow( tmNow );
  505. if( CLK_FHEADER_VERMAJOR == file.m_header.m_dwVerMajor 
  506. && CLK_FHEADER_VERMINOR == file.m_header.m_dwVerMinor ) // 版本相同
  507. {
  508. if( ft.GetYear() == tNow.GetYear() && ft.GetMonth() == tNow.GetMonth() && ft.GetDay() == tNow.GetDay() )
  509. return FALSE;
  510. int nDayOfWeek = tNow.GetDayOfWeek();
  511. if( 1 == nDayOfWeek || 7 == nDayOfWeek )
  512. return FALSE;
  514. BOOL bEmpty = FALSE; // file.EmptyAll( );
  515. file.Close();
  517. if( !bEmpty )
  518. return ::DeleteFile( lpszFileName );
  519. return TRUE;
  520. }
  521. else
  522. {
  523. file.Close();
  524. return ::DeleteFile( lpszFileName );
  525. }
  526. }
  528. return FALSE;
  529. }
  531. static CSPMutex g_mutexClkFile;
  533. BOOL CClkFile::EmptyAll( )
  534. {
  535. CSPMutex::Scoped locker(g_mutexClkFile);
  537. SP_ASSERT( CSPFile::hFileNull != m_file.m_hFile );
  538. if( CSPFile::hFileNull == m_file.m_hFile )
  539. return FALSE;
  541. // 顺序寻找
  542. DWORD dwCount = 0;
  543. for( DWORD i=0; i<m_header.m_dwIndexRecordCount; i++ )
  544. {
  545. DWORD dwPosIndex = m_header.m_dwPosFirstIndex + m_header.m_dwIndexRecordSize * i;
  546. if( m_file.GetPosition() != dwPosIndex )
  547. m_file.Seek( dwPosIndex, CSPFile::begin );
  549. CLK_INDEXRECORD index;
  550. if( sizeof(index) != m_file.Read(&index,sizeof(index)) )
  551. return FALSE;
  552. if( CLK_INDEXRECORD_MAGIC != index.m_dwMagic )
  553. return FALSE;
  554. if( strlen(index.m_szCode) <= 0 )
  555. continue;
  557. EmptyBlockChain( index.m_dwPosFirstBlock );
  558. index.m_dwDataRecordCountTotal = 0;
  559. m_file.Seek( dwPosIndex, CSPFile::begin );
  560. m_file.Write( &index, sizeof(index) );
  562. dwCount ++;
  563. }
  565. m_file.Flush();
  566. SP_ASSERT( dwCount == m_header.m_dwStockCount );
  567. return dwCount > 0; // == m_header.m_dwStockCount;
  568. }
  570. // 保存数据，并修改相应索引信息
  571. DWORD CClkFile::StoreDataRecord(DWORD dwMarket, const char * szCode,
  572. void * pData, DWORD dwDataElementSize, DWORD dwDataElementCount,
  573. BOOL bOverWrite ) // 返回成功保存记录数
  574. {
  575. CSPMutex::Scoped locker(g_mutexClkFile);
  577. SP_ASSERT( CSPFile::hFileNull != m_file.m_hFile );
  578. if( CSPFile::hFileNull == m_file.m_hFile )
  579. return 0;
  581. CLK_INDEXRECORD index;
  582. DWORD dwPosIndexFind = -1;
  583. if( !GetDataInfo( dwMarket, szCode, index, dwPosIndexFind, TRUE ) )
  584. return 0;
  586. if( bOverWrite )
  587. {
  588. EmptyBlockChain( index.m_dwPosFirstBlock );
  589. index.m_dwDataRecordCountTotal = 0;
  590. }
  592. if( -1 == index.m_dwPosFirstBlock || 0 == index.m_dwPosFirstBlock )
  593. index.m_dwPosFirstBlock = GetFirstBlankBlockPos( TRUE, TRUE );
  594. DWORD dwCount = WriteData( index.m_dwPosFirstBlock, pData, dwDataElementSize, dwDataElementCount, FALSE );
  595. index.m_dwDataRecordCountTotal += dwCount;
  596. SetDataInfo( dwPosIndexFind, index, FALSE );
  598. // m_file.Flush();
  599. return dwCount;
  600. }
  602. // 得到某一股票的数据记录数
  603. DWORD CClkFile::GetDataRecordCount( DWORD dwMarket, const char * szCode )
  604. {
  605. CSPMutex::Scoped locker(g_mutexClkFile);
  607. CLK_INDEXRECORD index;
  608. DWORD dwPosIndexFind = -1;
  609. if( GetDataInfo( dwMarket, szCode, index, dwPosIndexFind, FALSE ) )
  610. return index.m_dwDataRecordCountTotal;
  611. return 0;
  612. }
  614. // 读取某一股票的数据记录
  615. DWORD CClkFile::LoadDataRecord( DWORD dwMarket, const char * szCode,
  616. void * pData, DWORD dwDataElementSize, DWORD dwMaxDataElement )// 返回成功读取记录数
  617. {
  618. CSPMutex::Scoped locker(g_mutexClkFile);
  620. SP_ASSERT( CSPFile::hFileNull != m_file.m_hFile );
  621. if( CSPFile::hFileNull == m_file.m_hFile )
  622. return 0;
  624. CLK_INDEXRECORD index;
  625. DWORD dwPosIndexFind = -1;
  626. if( !GetDataInfo( dwMarket, szCode, index, dwPosIndexFind, FALSE ) )
  627. return 0;
  629. if( dwMaxDataElement < index.m_dwDataRecordCountTotal )
  630. return 0;
  632. return ReadData( index.m_dwPosFirstBlock, pData, dwDataElementSize, dwMaxDataElement );
  633. }
  635. DWORD CClkFile::Hash( LPCTSTR key, DWORD dwMax )
  636. {
  637. DWORD dwHash = 0;
  638. while (*key)
  639. dwHash = (dwHash<<5) + dwHash + *key++;
  640. return dwHash % dwMax;
  641. }
  643. // 得到某一股票的索引区信息，如果bAddIfNotExists并且不存在，则添加
  644. BOOL CClkFile::GetDataInfo( DWORD dwMarket, const char * szCode, CLK_INDEXRECORD & idxRet, DWORD & dwPosIndexFind, BOOL bAddIfNotExists )
  645. {
  646. SP_ASSERT( CSPFile::hFileNull != m_file.m_hFile );
  647. if( CSPFile::hFileNull == m_file.m_hFile )
  648. return FALSE;
  650. // 是否当前Cache
  651. if( m_CurIndexRecord.m_dwMarket == dwMarket
  652. && 0 == strcmp( m_CurIndexRecord.m_szCode, szCode ) )
  653. {
  654. idxRet = m_CurIndexRecord;
  655. dwPosIndexFind = m_dwPosCurIndex;
  656. return TRUE;
  657. }
  659. DWORD posBegin = Hash( szCode, m_header.m_dwIndexRecordCount );
  660. // Hash顺序寻找
  661. for( DWORD i=posBegin; i<m_header.m_dwIndexRecordCount; i++ )
  662. {
  663. DWORD dwPosIndex = m_header.m_dwPosFirstIndex + m_header.m_dwIndexRecordSize * i;
  664. if( m_file.GetPosition() != dwPosIndex )
  665. m_file.Seek( dwPosIndex, CSPFile::begin );
  667. CLK_INDEXRECORD index;
  668. if( sizeof(index) != m_file.Read(&index,sizeof(index))
  669. || CLK_INDEXRECORD_MAGIC != index.m_dwMagic )
  670. {
  671. SP_ASSERT( FALSE );
  672. return FALSE;
  673. }
  674. if( dwMarket == index.m_dwMarket
  675. && 0 == strcmp( szCode, index.m_szCode ) )
  676. {
  677. idxRet = index;
  678. dwPosIndexFind = dwPosIndex;
  679. m_CurIndexRecord = index;
  680. m_dwPosCurIndex = dwPosIndex;
  681. return TRUE;
  682. }
  683. if( 0 == strlen(index.m_szCode) )
  684. {
  685. if( bAddIfNotExists )
  686. {
  687. index.m_dwMarket = dwMarket;
  688. strncpy( index.m_szCode, szCode, min(sizeof(index.m_szCode)-1,strlen(szCode)) );
  689. index.m_dwDataRecordCountTotal = 0;
  690. index.m_dwPosFirstBlock = GetFirstBlankBlockPos( TRUE, TRUE );
  692. m_file.Seek( dwPosIndex, CSPFile::begin );
  693. m_file.Write( &index, sizeof(index) );
  695. // 文件头
  696. m_header.m_dwStockCount += 1;
  697. m_file.Seek( 0, CSPFile::begin );
  698. m_file.Write( &m_header, sizeof(m_header) );
  699. // m_file.Flush();
  701. // return
  702. idxRet = index;
  703. dwPosIndexFind = dwPosIndex;
  704. m_CurIndexRecord = index;
  705. m_dwPosCurIndex = dwPosIndex;
  706. return TRUE;
  707. }
  708. return FALSE;
  709. }
  711. // 循环
  712. if( m_header.m_dwIndexRecordCount-1 == i )
  713. i = -1;
  714. if( posBegin-1 == i )
  715. break;
  716. }
  718. return FALSE;
  719. }
  721. // 保存某一股票的索引区信息
  722. BOOL CClkFile::SetDataInfo( DWORD dwPosIndex, CLK_INDEXRECORD idx, BOOL bFlush )
  723. {
  724. SP_ASSERT( CSPFile::hFileNull != m_file.m_hFile );
  725. if( CSPFile::hFileNull == m_file.m_hFile )
  726. return FALSE;
  728. // 是否当前Cache
  729. if( m_CurIndexRecord.m_dwMarket == idx.m_dwMarket
  730. && 0 == strcmp( m_CurIndexRecord.m_szCode, idx.m_szCode ) )
  731. {
  732. m_CurIndexRecord = idx;
  733. }
  735. if( -1 != dwPosIndex )
  736. {
  737. m_file.Seek( dwPosIndex, CSPFile::begin );
  738. m_file.Write( &idx, sizeof(idx) );
  739. if( bFlush )
  740. m_file.Flush();
  741. return TRUE;
  742. }
  744. return FALSE;
  745. }
  747. // 得到某一空数据块
  748. DWORD CClkFile::GetFirstBlankBlockPos( BOOL bAddIfNotExists, BOOL bUseIt )
  749. {
  750. SP_ASSERT( CSPFile::hFileNull != m_file.m_hFile );
  751. if( CSPFile::hFileNull == m_file.m_hFile )
  752. return -1;
  754. DWORD dwPosBlock = m_header.m_dwPosFirstBlankBlock;
  755. if( -1 != dwPosBlock && 0 != dwPosBlock )
  756. {
  757. m_file.Seek( dwPosBlock, CSPFile::begin );
  759. CLK_BLOCKHEADER bheader;
  760. if( sizeof(bheader) == m_file.Read(&bheader,sizeof(bheader)) )
  761. {
  762. SP_ASSERT( CLK_BLOCKHEADER_MAGIC == bheader.m_dwMagic );
  763. SP_ASSERT( !bheader.m_bUsed );
  765. if( bUseIt )
  766. {
  767. bheader.m_bUsed = bUseIt;
  768. bheader.m_dwDataRecordCount = 0;
  769. bheader.m_dwPosNextBlock = -1;
  770. m_file.Seek( dwPosBlock, CSPFile::begin );
  771. m_file.Write( &bheader, sizeof(bheader) );
  773. m_header.m_dwPosFirstBlankBlock = bheader.m_dwPosNextBlock;
  774. m_file.Seek( 0, CSPFile::begin );
  775. m_file.Write( &m_header, sizeof(m_header) );
  776. // m_file.Flush();
  777. }
  778. return dwPosBlock;
  779. }
  780. }
  782. // Add
  783. if( bAddIfNotExists )
  784. {
  785. SP_ASSERT( bUseIt ); // Must Use It
  787. DWORD dwDataSize = m_header.m_dwDataRecordSize*m_header.m_dwRecordPerBlock;
  788. if( dwDataSize <= 0 )
  789. return -1;
  791. m_file.SeekToEnd( );
  792. dwPosBlock = m_file.GetPosition();
  794. CLK_BLOCKHEADER bheader;
  795. memset( &bheader, 0, sizeof(bheader) );
  796. bheader.m_dwMagic = CLK_BLOCKHEADER_MAGIC;
  797. bheader.m_bUsed = bUseIt;
  798. bheader.m_dwPosNextBlock = -1;
  799. bheader.m_dwPosFirstRecord = dwPosBlock + sizeof(bheader);
  800. m_file.Write( &bheader, sizeof(bheader) );
  801. char * temp = new char[dwDataSize];
  802. if( !temp )
  803. return -1;
  804. memset( temp, 0, m_header.m_dwDataRecordSize );
  805. m_file.Write( temp, dwDataSize );
  806. delete [] temp;
  807. // m_file.Flush();
  808. }
  810. return dwPosBlock;
  811. }
  813. // 清空数据Block链中的数据，并将除第一个Block外的其他Block置为未用
  814. DWORD CClkFile::EmptyBlockChain( DWORD dwPosFirstBlock )
  815. {
  816. SP_ASSERT( CSPFile::hFileNull != m_file.m_hFile );
  817. if( CSPFile::hFileNull == m_file.m_hFile )
  818. return FALSE;
  820. DWORD dwCount = 0;
  821. DWORD dwPosBlock = dwPosFirstBlock;
  823. while( -1 != dwPosBlock && 0 != dwPosBlock )
  824. {
  825. m_file.Seek( dwPosBlock, CSPFile::begin );
  827. DWORD dwPosNextBlock = -1;
  828. CLK_BLOCKHEADER bheader;
  829. if( sizeof(bheader) != m_file.Read(&bheader,sizeof(bheader))
  830. || CLK_BLOCKHEADER_MAGIC != bheader.m_dwMagic )
  831. {
  832. SP_ASSERT( FALSE );
  833. }
  834. else
  835. {
  836. dwPosNextBlock = bheader.m_dwPosNextBlock;
  837. }
  839. // Empty it
  840. bheader.m_bUsed = (dwPosFirstBlock == dwPosBlock); // 第一块继续使用
  841. bheader.m_dwDataRecordCount = 0;
  842. bheader.m_dwPosNextBlock = -1;
  843. if( !bheader.m_bUsed )
  844. bheader.m_dwPosNextBlock = m_header.m_dwPosFirstBlankBlock;
  845. m_file.Seek( dwPosBlock, CSPFile::begin );
  846. m_file.Write( &bheader, sizeof(bheader) );
  848. // 加入Blank Block Chain
  849. if( !bheader.m_bUsed )
  850. {
  851. m_header.m_dwPosFirstBlankBlock = dwPosBlock;
  852. m_file.Seek( 0, CSPFile::begin );
  853. m_file.Write( &m_header, sizeof(m_header) );
  854. }
  855. // m_file.Flush();
  856. dwCount ++;
  858. dwPosBlock = dwPosNextBlock;
  859. }
  861. return dwCount;
  862. }
  864. // 读数据记录
  865. DWORD CClkFile::ReadData( DWORD dwPosBlock, void * pData, DWORD dwDataElementSize, DWORD dwMaxDataElement )
  866. {
  867. SP_ASSERT( CSPFile::hFileNull != m_file.m_hFile );
  868. if( CSPFile::hFileNull == m_file.m_hFile )
  869. return FALSE;
  871. if( NULL == pData || dwMaxDataElement == 0 )
  872. return 0;
  874. DWORD dwCount = 0;
  876. while( -1 != dwPosBlock && 0 != dwPosBlock )
  877. {
  878. m_file.Seek( dwPosBlock, CSPFile::begin );
  880. CLK_BLOCKHEADER bheader;
  881. if( sizeof(bheader) != m_file.Read(&bheader,sizeof(bheader))
  882. || CLK_BLOCKHEADER_MAGIC != bheader.m_dwMagic )
  883. {
  884. SP_ASSERT( FALSE );
  885. return dwCount;
  886. }
  888. for( DWORD i=0; i<bheader.m_dwDataRecordCount; i++ )
  889. {
  890. DWORD dwPos = bheader.m_dwPosFirstRecord + i * m_header.m_dwDataRecordSize;
  891. if( m_file.GetPosition() != dwPos )
  892. m_file.Seek( dwPos, CSPFile::begin );
  893. m_file.Read( ((BYTE *)pData)+dwDataElementSize*dwCount, min(dwDataElementSize,m_header.m_dwDataRecordSize) );
  894. dwCount ++;
  895. if( dwCount >= dwMaxDataElement )
  896. return dwCount;
  897. }
  899. dwPosBlock = bheader.m_dwPosNextBlock;
  900. }
  902. return dwCount;
  903. }
  905. // 写数据记录
  906. DWORD CClkFile::WriteData( DWORD dwPosBlock, void * pData, DWORD dwDataElementSize, DWORD dwDataElementCount, BOOL bFlush )
  907. {
  908. SP_ASSERT( CSPFile::hFileNull != m_file.m_hFile );
  909. if( CSPFile::hFileNull == m_file.m_hFile )
  910. return 0;
  912. SP_ASSERT( -1 != dwPosBlock && 0 != dwPosBlock );
  913. if( -1 == dwPosBlock || 0 == dwPosBlock )
  914. return 0;
  916. DWORD dwCount = 0;
  918. while( dwCount < dwDataElementCount && -1 != dwPosBlock && 0 != dwPosBlock )
  919. {
  920. m_file.Seek( dwPosBlock, CSPFile::begin );
  922. CLK_BLOCKHEADER bheader;
  923. if( sizeof(bheader) != m_file.Read(&bheader,sizeof(bheader))
  924. || CLK_BLOCKHEADER_MAGIC != bheader.m_dwMagic )
  925. {
  926. SP_ASSERT( FALSE );
  927. return dwCount;
  928. }
  930. if( -1 != bheader.m_dwPosNextBlock && 0 != bheader.m_dwPosNextBlock )
  931. {
  932. SP_ASSERT( bheader.m_dwDataRecordCount == m_header.m_dwRecordPerBlock );
  933. if( bheader.m_dwDataRecordCount == m_header.m_dwRecordPerBlock )
  934. {
  935. dwPosBlock = bheader.m_dwPosNextBlock;
  936. continue;
  937. }
  938. }
  940. // Write
  941. DWORD dwCountOld = dwCount;
  942. for( DWORD i=bheader.m_dwDataRecordCount; i<m_header.m_dwRecordPerBlock; i++ )
  943. {
  944. DWORD dwPos = bheader.m_dwPosFirstRecord + i * m_header.m_dwDataRecordSize;
  945. if( m_file.GetPosition() != dwPos )
  946. m_file.Seek( dwPos, CSPFile::begin );
  947. m_file.Write( ((BYTE *)pData)+dwDataElementSize*dwCount, min(dwDataElementSize,m_header.m_dwDataRecordSize) );
  948. dwCount ++;
  949. if( dwCount >= dwDataElementCount )
  950. break;
  951. }
  953. // 修改Block Header
  954. bheader.m_bUsed = TRUE;
  955. bheader.m_dwDataRecordCount += (dwCount-dwCountOld);
  956. bheader.m_dwPosNextBlock = -1;
  957. if( dwCount < dwDataElementCount )
  958. bheader.m_dwPosNextBlock = GetFirstBlankBlockPos( TRUE, TRUE );
  959. m_file.Seek( dwPosBlock, CSPFile::begin );
  960. m_file.Write( &bheader, sizeof(bheader) );
  962. // 新Block
  963. dwPosBlock = bheader.m_dwPosNextBlock;
  964. }
  966. if( bFlush )
  967. m_file.Flush();
  968. return dwCount;
  969. }
  971. /////////////////////////////////////////////////////////////////////////////////////
  972. // class CSelfDB
  974. CSelfDB::CSelfDB( const char * rootpath, BOOL bOK )
  975. : CQianlong( rootpath, bOK )
  976. {
  977. }
  979. CSelfDB::~CSelfDB( )
  980. {
  981. }
  983. CSPString CSelfDB::GetNewsPath( DWORD dwMarket )
  984. {
  985. CSPString strPath = AfxGetProfile().GetSelfDBPath();
  986. strPath += self_news;
  987. return strPath;
  988. }
  990. CSPString CSelfDB::GetBasePath( DWORD dwMarket )
  991. {
  992. CSPString strPath = AfxGetProfile().GetSelfDBPath();
  993. switch( dwMarket )
  994. {
  995. case CStock::marketSHSE:
  996. strPath += ml_sh_base;
  997. break;
  998. case CStock::marketSZSE:
  999. strPath += ml_sz_base;
  1000. break;
  1001. default:
  1002. strPath += ml_sh_base;
  1003. SP_ASSERT( FALSE );
  1004. }
  1005. return strPath;
  1006. }
  1008. BOOL CSelfDB::CreateSelfDB( const char * rootpath )
  1009. {
  1010. if( NULL == rootpath || strlen(rootpath) == 0 )
  1011. return FALSE;
  1013. // get rootpath
  1014. CSPString strRoot = rootpath;
  1015. int nLen = strRoot.GetLength();
  1016. if( strRoot[nLen-1] != '\' && strRoot[nLen-1] != '/' )
  1017. strRoot += CHAR_DIRSEP;
  1018. nLen = strRoot.GetLength();
  1020. if( 0 != access( strRoot, 0 ) )
  1021. return FALSE;
  1023. if( 0 != access( strRoot + ml_dat, 0 ) )
  1024. mkdir( strRoot + ml_dat );
  1025. if( 0 != access( strRoot + ml_data, 0 ) )
  1026. mkdir( strRoot + ml_data );
  1028. if( 0 != access( strRoot + ml_sh, 0 ) )
  1029. mkdir( strRoot + ml_sh );
  1030. if( 0 != access( strRoot + ml_sh_base, 0 ) )
  1031. mkdir( strRoot + ml_sh_base );
  1032. if( 0 != access( strRoot + ml_sh_month, 0 ) )
  1033. mkdir( strRoot + ml_sh_month );
  1034. if( 0 != access( strRoot + ml_sh_week, 0 ) )
  1035. mkdir( strRoot + ml_sh_week );
  1036. if( 0 != access( strRoot + ml_sh_day, 0 ) )
  1037. mkdir( strRoot + ml_sh_day );
  1038. if( 0 != access( strRoot + ml_sh_min, 0 ) )
  1039. mkdir( strRoot + ml_sh_min );
  1040. if( 0 != access( strRoot + self_sh_xdr, 0 ) )
  1041. mkdir( strRoot + self_sh_xdr );
  1043. if( 0 != access( strRoot + ml_sz, 0 ) )
  1044. mkdir( strRoot + ml_sz );
  1045. if( 0 != access( strRoot + ml_sz_base, 0 ) )
  1046. mkdir( strRoot + ml_sz_base );
  1047. if( 0 != access( strRoot + ml_sz_month, 0 ) )
  1048. mkdir( strRoot + ml_sz_month );
  1049. if( 0 != access( strRoot + ml_sz_week, 0 ) )
  1050. mkdir( strRoot + ml_sz_week );
  1051. if( 0 != access( strRoot + ml_sz_day, 0 ) )
  1052. mkdir( strRoot + ml_sz_day );
  1053. if( 0 != access( strRoot + ml_sz_min, 0 ) )
  1054. mkdir( strRoot + ml_sz_min );
  1055. if( 0 != access( strRoot + self_sz_xdr, 0 ) )
  1056. mkdir( strRoot + self_sz_xdr );
  1058. if( 0 != access( strRoot + self_news, 0 ) )
  1059. mkdir( strRoot + self_news );
  1061. return TRUE;
  1062. }
  1064. int LoadCodeTable( CStockContainer & container, LPCTSTR lpszFileName, DWORD dwMarket )
  1065. {
  1066. int nCount = 0;
  1068. char seps[]   = ",trn";
  1069. char quotation_mark[] = """;
  1071. BOOL bHasQuotationMark = FALSE;
  1072. CSPFile file;
  1073. if( file.Open( lpszFileName, CSPFile::modeRead | CSPFile::shareDenyNone ) )
  1074. {
  1075. CSPString rString;
  1076. while( file.ReadString( rString ) )
  1077. {
  1078. CStockInfo info;
  1080. // 600000,浦发银行,17,PFYH,"PuFaYinHang"
  1081. // 英文名称可以用双引号引起来
  1082. int nToken = 0;
  1083. while( !rString.IsEmpty() )
  1084. {
  1085. nToken ++;
  1087. CSPString sTemp;
  1089. int nIndex = -1;
  1090. if( 5 == nToken && -1 != (nIndex=rString.Find( quotation_mark )) )
  1091. {
  1092. rString = rString.Mid( nIndex+1 );
  1093. nIndex = rString.Find( quotation_mark );
  1094. if( -1 != nIndex ) sTemp = rString.Left( nIndex );
  1095. if( -1 != nIndex ) rString = rString.Mid( nIndex+1 );
  1096. nIndex = rString.FindOneOf( seps );
  1097. if( -1 != nIndex )
  1098. rString = rString.Mid( nIndex+1 );
  1099. else
  1100. rString.Empty();
  1101. }
  1102. else
  1103. {
  1104. nIndex = rString.FindOneOf( seps );
  1105. if( -1 != nIndex )
  1106. {
  1107. sTemp = rString.Left( nIndex );
  1108. rString = rString.Mid( nIndex+1 );
  1109. }
  1110. else
  1111. {
  1112. sTemp = rString;
  1113. rString.Empty();
  1114. }
  1115. }
  1117. if( 1 == nToken )
  1118. info.SetStockCode( dwMarket, sTemp );
  1119. else if( 2 == nToken )
  1120. info.SetStockName( sTemp );
  1121. else if( 3 == nToken )
  1122. info.SetType( atol(sTemp) );
  1123. else if( 4 == nToken )
  1124. info.SetStockShortName( sTemp );
  1125. else if( 5 == nToken )
  1126. {
  1127. info.SetStockNameEnu( sTemp );
  1128. break;
  1129. }
  1130. }
  1132. if( info.IsValidStock() )
  1133. container.Add( info );
  1134. nCount ++;
  1135. }
  1137. file.Close();
  1138. }
  1140. return nCount;
  1141. }
  1143. int CSelfDB::LoadCodetable( CStockContainer & container )
  1144. {
  1145. if( !m_bIsOK ) return 0;
  1147. container.SetSize( 0, 2000 );
  1149. // 上海指数
  1150. CSPString sFileName = GetRootPath();
  1151. sFileName += self_sh_code;
  1152. LoadCodeTable( container, sFileName, CStock::marketSHSE );
  1154. // 深圳指数
  1155. sFileName = GetRootPath();
  1156. sFileName += self_sz_code;
  1157. LoadCodeTable( container, sFileName, CStock::marketSZSE );
  1159. if( container.GetSize() <= 0 )
  1160. CQianlong::LoadCodetable( container );
  1162. return container.GetSize();
  1163. }
  1165. int CSelfDB::StoreCodetable( CStockContainer & container )
  1166. {
  1167. if( !m_bIsOK ) return 0;
  1169. if( container.GetSize() <= 0 )
  1170. return 0;
  1172. // 上海指数
  1173. CSPString sFileNameSH = GetRootPath();
  1174. sFileNameSH += self_sh_code;
  1176. // 深圳指数
  1177. CSPString sFileNameSZ = GetRootPath();
  1178. sFileNameSZ += self_sz_code;
  1180. CSPFile fileSHSE, fileSZSE;
  1181. if( !fileSHSE.Open( sFileNameSH, CSPFile::modeCreate | CSPFile::modeWrite )
  1182. || !fileSZSE.Open( sFileNameSZ, CSPFile::modeCreate | CSPFile::modeWrite ) )
  1183. {
  1184. return 0;
  1185. }
  1187. container.Lock();
  1188. for( int i=0; i<container.GetSize(); i++ )
  1189. {
  1190. CStockInfo & info = container.ElementAt(i);
  1191. CSPString str;
  1193. str.Format( "%s,%s,%d,%s,"%s"rn", info.GetStockCode(), info.GetStockNameChs(), info.GetType(),
  1194. info.GetStockShortName(), info.GetStockNameEnu() );
  1196. if( info.IsShangHai() )
  1197. {
  1198. fileSHSE.Write( str, str.GetLength() );
  1199. }
  1200. if( info.IsShenZhen() )
  1201. {
  1202. fileSZSE.Write( str, str.GetLength() );
  1203. }
  1204. }
  1205. container.UnLock();
  1207. return container.GetSize();
  1208. }
  1210. int CSelfDB::LoadKData( CStock *pstock, int nKType )
  1211. {
  1212. // WILLCHECK
  1213. int ret = CQianlong::LoadKData( pstock, nKType );
  1215. if( CKData::ktypeMin5 == nKType && LoadMinute( pstock ) > 0 )
  1216. {
  1217. CKData & kdataMin5 = pstock->GetKDataMin5();
  1218. CMinute & minute = pstock->GetMinute();
  1219. CKData kdataNew;
  1220. if( minute.ToKData( kdataNew ) && CKData::ktypeMin5 == kdataNew.GetKType() )
  1221. {
  1222. kdataMin5.MergeKData( &kdataNew );
  1223. }
  1225. return kdataMin5.GetSize();
  1226. }
  1227. return ret;
  1228. }
  1230. int CSelfDB::LoadBasetable( CStockContainer & container )
  1231. {
  1232. container.Lock();
  1234. CSPMapStringToPtr map;
  1235. map.InitHashTable( container.GetSize() + container.GetSize() + 100 );
  1237. for( int i=0; i<container.GetSize(); i++ )
  1238. {
  1239. CStockInfo & info = container.ElementAt(i);
  1240. map.SetAt( info.GetStockCode(), (void *)i );
  1241. info.m_basedata.RemoveAll();
  1242. }
  1244. CSPString sFileName = GetRootPath();
  1245. sFileName += self_chna_basetbl;
  1246. CSPFile file;
  1247. if( file.Open( sFileName, CSPFile::modeRead | CSPFile::shareDenyNone ) )
  1248. {
  1249. BASEDATA block;
  1250. while( sizeof(block) == file.Read( &block, sizeof(block) ) )
  1251. {
  1252. void * pArrayID = NULL;
  1253. if( map.Lookup( block.m_szCode, pArrayID ) )
  1254. {
  1255. int nIndex = ((int)pArrayID);
  1256. if( nIndex >= 0 && nIndex < container.GetSize() )
  1257. {
  1258. container.ElementAt(nIndex).m_basedata.InsertBaseDataSort( block );
  1259. }
  1260. }
  1261. }
  1262. file.Close();
  1263. }
  1265. container.UnLock();
  1266. return container.GetSize();
  1267. }
  1269. int CSelfDB::StoreBasetable( CStockContainer & container )
  1270. {
  1271. SP_ASSERT( m_bIsOK && container.GetSize() > 0 );
  1272. if( !m_bIsOK || container.GetSize() <= 0 ) return 0;
  1274. int nCount = 0;
  1275. CSPString sRoot = GetRootPath();
  1276. CSPString sFileName = sRoot + self_chna_basetbl;
  1278. container.Lock();
  1279. CSPFile file;
  1280. if( file.Open( sFileName, CSPFile::modeWrite | CSPFile::modeCreate ) )
  1281. {
  1282. for( int i=0; i<container.GetSize(); i++ )
  1283. {
  1284. CStockInfo & info = container.ElementAt(i);
  1285. for( int k=0; k<info.m_basedata.GetSize(); k++ )
  1286. {
  1287. BASEDATA & block = info.m_basedata.ElementAt(k);
  1288. if( k == info.m_basedata.GetSize() - 1 )
  1289. {
  1290. block.m_fYield_average = info.m_fYield_average;
  1291. block.m_fYield_stddev = info.m_fYield_stddev;
  1292. block.m_fBeite = info.m_fBeite;
  1293. }
  1294. file.Write( &block, sizeof(block) );
  1295. }
  1296. nCount ++;
  1297. }
  1298. }
  1300. container.UnLock();
  1301. return nCount;
  1302. }
  1304. int CSelfDB::LoadDRData( CStock *pstock )
  1305. {
  1306. SP_ASSERT( m_bIsOK && pstock && pstock->GetStockInfo().IsValidStock() );
  1307. if( !m_bIsOK || !pstock || !pstock->GetStockInfo().IsValidStock() ) return 0;
  1309. CSPString sFileName;
  1310. GetFileName( sFileName, CStock::dataDR, &(pstock->GetStockInfo()) );
  1312. CDRData & drdata = pstock->GetDRData();
  1314. DWORD dwMarket = pstock->GetStockInfo().GetMarket();
  1315. CSPString sCode = pstock->GetStockCode();
  1316. CSPFile file;
  1317. if( file.Open( sFileName, CSPFile::modeRead | CSPFile::shareDenyNone ) )
  1318. {
  1319. DWORD dwLen = file.GetLength();
  1320. CLK_DRDATA dbdr;
  1321. int nSize = dwLen/sizeof(dbdr);
  1322. drdata.SetSize( 0, nSize );
  1324. while( sizeof(dbdr) == file.Read( &dbdr, sizeof(dbdr) ) )
  1325. {
  1326. DRDATA dr;
  1327. if( convert_CLK_DRDATA_to_DRDATA( dwMarket, sCode, &dbdr, &dr ) )
  1328. drdata.InsertDRDataSort( dr );
  1329. }
  1331. file.Close();
  1332. return drdata.GetSize();
  1333. }
  1335. // Load From FXJ_DRDATA
  1336. sFileName = GetRootPath();
  1337. sFileName += self_chna_xdr;
  1338. WORD wFxjMarket = 'HS';
  1339. if( CStock::marketSZSE == dwMarket )
  1340. wFxjMarket = 'ZS';
  1341. if( file.Open( sFileName, CSPFile::modeRead | CSPFile::shareDenyNone ) )
  1342. {
  1343. if( 8 == file.Seek( 8, CSPFile::begin ) )
  1344. {
  1345. BOOL bMy = FALSE;
  1346. FXJ_DRDATA fxjdr;
  1347. while( sizeof(fxjdr) == file.Read( &fxjdr, sizeof(fxjdr) ) )
  1348. {
  1349. BOOL bMyOld = bMy;
  1350. if( -1 == fxjdr.m_dwMagic )
  1351. bMy = ( fxjdr.m_wMarket == wFxjMarket && 0 == strncmp( sCode, fxjdr.m_szCode, min(sizeof(fxjdr.m_szCode),sCode.GetLength()) ) );
  1352. else if( bMy )
  1353. {
  1354. DRDATA dr;
  1355. if( convert_FXJ_DRDATA_to_DRDATA( dwMarket, sCode, &fxjdr, &dr ) )
  1356. drdata.InsertDRDataSort( dr );
  1357. }
  1358. if( bMyOld && !bMy )
  1359. break;
  1360. }
  1361. }
  1362. }
  1364. return drdata.GetSize();
  1365. }
  1367. int CSelfDB::StoreDRData( CStock *pstock )
  1368. {
  1369. SP_ASSERT( m_bIsOK && pstock && pstock->GetStockInfo().IsValidStock() );
  1370. if( !m_bIsOK || !pstock || !pstock->GetStockInfo().IsValidStock() ) return 0;
  1372. CSPString sFileName;
  1373. GetFileName( sFileName, CStock::dataDR, &(pstock->GetStockInfo()) );
  1375. CDRData & drdata = pstock->GetDRData();
  1377. if( drdata.GetSize() == 0 )
  1378. {
  1379. ::DeleteFile( sFileName );
  1380. return 0;
  1381. }
  1383. // Compare
  1384. CStock stocktemp;
  1385. stocktemp.SetStockInfo( &(pstock->GetStockInfo()) );
  1386. if( LoadDRData( &stocktemp ) > 0 && stocktemp.GetDRData().IsSameAs(&drdata) )
  1387. return drdata.GetSize();
  1389. // Store
  1390. CSPFile file;
  1391. if( file.Open( sFileName, CSPFile::modeCreate | CSPFile::modeWrite | CSPFile::shareDenyNone ) )
  1392. {
  1393. for( int i=0; i<drdata.GetSize(); i++ )
  1394. {
  1395. CLK_DRDATA dbdr;
  1396. convert_DRDATA_to_CLK_DRDATA( &(drdata.ElementAt(i)), &dbdr );
  1397. file.Write( &dbdr, sizeof(dbdr) );
  1398. }
  1399. }
  1401. return drdata.GetSize();
  1402. }
  1404. DWORD ReadReport( CStock * pstock, LPCTSTR lpszFileName )
  1405. {
  1406. SP_ASSERT( pstock && pstock->GetStockInfo().IsValidStock() );
  1407. if( !pstock || !pstock->GetStockInfo().IsValidStock() )
  1408. return 0;
  1410. CReport & aReport = pstock->GetReport();
  1411. aReport.RemoveAll();
  1413. // 读取
  1414. CClkFile file;
  1415. if( file.Open( lpszFileName ) )
  1416. {
  1417. DWORD dwDataRecordCount = file.GetDataRecordCount( pstock->GetStockInfo().GetMarket(), pstock->GetStockCode() );
  1418. aReport.SetSize( dwDataRecordCount );
  1419. DWORD dwCount = file.LoadDataRecord(pstock->GetStockInfo().GetMarket(), pstock->GetStockCode(),
  1420. aReport.GetData(), sizeof(REPORT), dwDataRecordCount );
  1421. aReport.SetSize( dwCount );
  1423. aReport.Sort( );
  1424. int nOldSize = aReport.GetSize();
  1425. aReport.RemoveDirty( );
  1426. if( nOldSize - aReport.GetSize() > 50 )
  1427. {
  1428. SP_VERIFY( aReport.GetSize() == (int)file.StoreDataRecord( pstock->GetStockInfo().GetMarket(), pstock->GetStockCode(),
  1429. aReport.GetData(), sizeof(REPORT), aReport.GetSize(), TRUE ) );
  1430. }
  1431. }
  1432. return aReport.GetSize();
  1433. }
  1435. int CSelfDB::LoadReport( CStock *pstock )
  1436. {
  1437. SP_ASSERT( m_bIsOK && pstock && pstock->GetStockInfo().IsValidStock() );
  1438. if( !m_bIsOK || !pstock || !pstock->GetStockInfo().IsValidStock() ) return 0;
  1440. pstock->GetReport().RemoveAll();
  1442. CSPString sFileName;
  1443. SP_VERIFY( GetFileName( sFileName, CStock::dataReport, &(pstock->GetStockInfo()) ) );
  1444. ReadReport( pstock, sFileName );
  1446. return pstock->GetReport().GetSize();
  1447. }
  1450. DWORD ReadMinute( CStock * pstock, LPCTSTR lpszFileName )
  1451. {
  1452. SP_ASSERT( pstock && pstock->GetStockInfo().IsValidStock() );
  1453. if( !pstock || !pstock->GetStockInfo().IsValidStock() )
  1454. return 0;
  1456. CMinute & aMinute = pstock->GetMinute();
  1457. aMinute.RemoveAll();
  1459. // 读取
  1460. CClkFile file;
  1461. if( file.Open( lpszFileName ) )
  1462. {
  1463. DWORD dwDataRecordCount = file.GetDataRecordCount( pstock->GetStockInfo().GetMarket(), pstock->GetStockCode() );
  1464. aMinute.SetSize( dwDataRecordCount );
  1465. DWORD dwCount = file.LoadDataRecord(pstock->GetStockInfo().GetMarket(), pstock->GetStockCode(),
  1466. aMinute.GetData(), sizeof(MINUTE), dwDataRecordCount );
  1467. aMinute.SetSize( dwCount );
  1469. aMinute.Sort( );
  1470. aMinute.RemoveDirty( );
  1471. }
  1472. return aMinute.GetSize();
  1473. }
  1475. int CSelfDB::LoadMinute( CStock *pstock )
  1476. {
  1477. SP_ASSERT( m_bIsOK && pstock && pstock->GetStockInfo().IsValidStock() );
  1478. if( !m_bIsOK || !pstock || !pstock->GetStockInfo().IsValidStock() ) return 0;
  1480. pstock->GetMinute().RemoveAll();
  1482. CSPString sFileName;
  1483. SP_VERIFY( GetFileName( sFileName, CStock::dataMinute, &(pstock->GetStockInfo()) ) );
  1484. ReadMinute( pstock, sFileName );
  1486. return pstock->GetMinute().GetSize();
  1487. }
  1489. int CSelfDB::LoadOutline( CStock *pstock )
  1490. {
  1491. SP_ASSERT( m_bIsOK && pstock && pstock->GetStockInfo().IsValidStock() );
  1492. if( !m_bIsOK || !pstock || !pstock->GetStockInfo().IsValidStock() ) return 0;
  1494. COutline & aOutline = pstock->GetOutline();
  1495. aOutline.RemoveAll();
  1497. CSPString sFileName;
  1498. SP_VERIFY( GetFileName( sFileName, CStock::dataOutline, &(pstock->GetStockInfo()) ) );
  1500. CSPFile file;
  1501. if( file.Open( sFileName, CSPFile::modeRead ) )
  1502. {
  1503. OUTLINE outline;
  1504. aOutline.SetSize( aOutline.GetSize(), file.GetLength()/sizeof(outline) + 10 );
  1505. while( sizeof(outline) == file.Read(&outline,sizeof(outline)) )
  1506. aOutline.Add( outline );
  1507. }
  1509. return aOutline.GetSize();
  1510. }
  1512. int CSelfDB::StoreReport( REPORT * pReport, int nCount, BOOL bBigTrade )
  1513. {
  1514. SP_ASSERT( m_bIsOK && pReport && nCount > 0 );
  1515. if( !m_bIsOK || !pReport || nCount <= 0 ) return 0;
  1517. static BOOL bFirstCall = TRUE;
  1518. if( bFirstCall )
  1519. {
  1520. bFirstCall = FALSE;
  1522. // remove old
  1523. CSPString sRoot = GetRootPath();
  1524. CClkFile::RemoveFileIfOutoftime( sRoot+self_sh_report, pReport->m_time );
  1525. CClkFile::RemoveFileIfOutoftime( sRoot+self_sz_report, pReport->m_time );
  1526. }
  1528. CSPString sFileName;
  1529. CClkFile file;
  1530. DWORD dwStoreCount = 0;
  1531. for( int i=0; i<nCount; i++ )
  1532. {
  1533. CStockInfo info;
  1534. CSPString sFileNameNew;
  1535. if( !info.SetStockCode( pReport[i].m_dwMarket, pReport[i].m_szCode )
  1536. || !GetFileName( sFileNameNew, CStock::dataReport, &info ) )
  1537. continue;
  1539. if( 0 != sFileNameNew.Compare( sFileName ) )
  1540. {
  1541. sFileName = sFileNameNew;
  1542. SP_VERIFY( CClkFile::BuildEmptyFile( sFileName, CStock::dataReport, pReport->m_dwMarket, 5000, 125, FALSE ) );
  1543. SP_VERIFY( file.Open( sFileName ) );
  1544. }
  1546. // store
  1547. if( bBigTrade )
  1548. {
  1549. dwStoreCount += file.StoreDataRecord( pReport[i].m_dwMarket, STKLIB_CODE_ZLDD,
  1550. &(pReport[i]), sizeof(REPORT), 1, FALSE );
  1551. }
  1552. else
  1553. {
  1554. dwStoreCount += file.StoreDataRecord( pReport[i].m_dwMarket, pReport[i].m_szCode,
  1555. &(pReport[i]), sizeof(REPORT), 1, FALSE );
  1556. }
  1557. }
  1559. return dwStoreCount;
  1560. }
  1562. int CSelfDB::StoreMinute( MINUTE * pMinute, int nCount )
  1563. {
  1564. SP_ASSERT( m_bIsOK && pMinute && nCount > 0 );
  1565. if( !m_bIsOK || !pMinute || nCount <= 0 ) return 0;
  1567. static BOOL bFirstCall = TRUE;
  1568. if( bFirstCall )
  1569. {
  1570. bFirstCall = FALSE;
  1572. // remove old
  1573. CSPString sRoot = GetRootPath();
  1574. CClkFile::RemoveFileIfOutoftime( sRoot+self_sh_minute, pMinute->m_time );
  1575. CClkFile::RemoveFileIfOutoftime( sRoot+self_sz_minute, pMinute->m_time );
  1576. }
  1579. CSPString sFileName;
  1580. CClkFile file;
  1581. DWORD dwStoreCount = 0;
  1582. CMinute aMinute;
  1583. for( int i=0; i<nCount; i++ )
  1584. {
  1585. CStockInfo info;
  1586. CSPString sFileNameNew;
  1587. if( !info.SetStockCode( pMinute[i].m_dwMarket, pMinute[i].m_szCode )
  1588. || !GetFileName( sFileNameNew, CStock::dataMinute, &info ) )
  1589. continue;
  1591. if( 0 != sFileNameNew.Compare( sFileName ) )
  1592. {
  1593. sFileName = sFileNameNew;
  1594. SP_VERIFY( CClkFile::BuildEmptyFile( sFileName, CStock::dataMinute, pMinute->m_dwMarket, 5000, 250, FALSE ) );
  1595. SP_VERIFY( file.Open( sFileName ) );
  1596. }
  1598. if( aMinute.GetSize() > 0
  1599. && (aMinute[0].m_dwMarket != pMinute[i].m_dwMarket || 0 != strncmp(aMinute[0].m_szCode,pMinute[i].m_szCode,sizeof(pMinute[i].m_szCode))) )
  1600. {
  1601. dwStoreCount ++;
  1603. // store
  1604. file.StoreDataRecord( aMinute[0].m_dwMarket, aMinute[0].m_szCode,
  1605. aMinute.GetData(), sizeof(MINUTE), aMinute.GetSize(), TRUE );
  1606. aMinute.RemoveAll();
  1607. }
  1609. aMinute.Add( pMinute[i] );
  1610. }
  1612. if( aMinute.GetSize() > 0 )
  1613. {
  1614. dwStoreCount ++;
  1616. // store
  1617. file.StoreDataRecord( aMinute[0].m_dwMarket, aMinute[0].m_szCode,
  1618. aMinute.GetData(), sizeof(MINUTE), aMinute.GetSize(), TRUE );
  1619. aMinute.RemoveAll();
  1620. }
  1622. return dwStoreCount;
  1623. }
  1625. int CSelfDB::StoreOutline( OUTLINE * pOutline, int nCount )
  1626. {
  1627. SP_ASSERT( m_bIsOK && pOutline && nCount > 0 );
  1628. if( !m_bIsOK || !pOutline || nCount <= 0 ) return 0;
  1630. CSPString sFileName;
  1631. SP_VERIFY( GetFileName(sFileName,CStock::dataOutline,NULL) );
  1633. CSPFile file;
  1634. if( file.Open( sFileName, CSPFile::modeCreate | CSPFile::modeWrite ) )
  1635. {
  1636. file.Write( pOutline, sizeof(OUTLINE)*nCount );
  1637. file.Close();
  1638. return nCount;
  1639. }
  1640. return 0;
  1641. }
  1643. BOOL CSelfDB::GetAccurateRoot( const char * rootpath, char *accurateroot, int maxlen )
  1644. {
  1645. if( 0 == rootpath || strlen(rootpath)==0 )
  1646. return FALSE;
  1648. // get rootpath
  1649. CSPString strRoot = rootpath;
  1650. int nLen = strRoot.GetLength();
  1651. if( strRoot[nLen-1] != '\' && strRoot[nLen-1] != '/' )
  1652. strRoot += CHAR_DIRSEP;
  1653. nLen = strRoot.GetLength();
  1655. if( 0 != access( strRoot + ml_dat, 0 ) )
  1656. return FALSE;
  1657. if( 0 != access( strRoot + ml_data, 0 ) )
  1658. return FALSE;
  1659. if( 0 != access( strRoot + ml_sh, 0 ) )
  1660. return FALSE;
  1661. if( 0 != access( strRoot + ml_sh_base, 0 ) )
  1662. return FALSE;
  1663. if( 0 != access( strRoot + ml_sh_month, 0 ) )
  1664. return FALSE;
  1665. if( 0 != access( strRoot + ml_sh_week, 0 ) )
  1666. return FALSE;
  1667. if( 0 != access( strRoot + ml_sh_day, 0 ) )
  1668. return FALSE;
  1669. if( 0 != access( strRoot + ml_sh_min, 0 ) )
  1670. return FALSE;
  1671. if( 0 != access( strRoot + self_sh_xdr, 0 ) )
  1672. return FALSE;
  1673. if( 0 != access( strRoot + self_news, 0 ) )
  1674. return FALSE;
  1676. strncpy( accurateroot, strRoot, maxlen-1);
  1677. accurateroot[maxlen-1] = '';
  1679. return TRUE;
  1680. }
  1682. int CSelfDB::InstallCodetbl( const char * filename, const char *orgname )
  1683. {
  1684. if( NULL == filename || strlen(filename) == 0
  1685. || NULL == orgname || strlen(orgname) == 0 )
  1686. return 0;
  1688. CSPString sFileName = GetRootPath();
  1690. CSPString sOrgName = "dat\";
  1691. sOrgName += orgname;
  1692. if( 0 == sOrgName.CompareNoCase(ml_sh_info)
  1693. || 0 == sOrgName.CompareNoCase(ml_sz_info)
  1694. || 0 == sOrgName.CompareNoCase(ml_sh_now)
  1695. || 0 == sOrgName.CompareNoCase(ml_sz_now)
  1696. || 0 == sOrgName.CompareNoCase(ml_sh_pyjc)
  1697. || 0 == sOrgName.CompareNoCase(ml_sz_pyjc)
  1698. || 0 == sOrgName.CompareNoCase(ml_sh_trace)
  1699. || 0 == sOrgName.CompareNoCase(ml_sz_trace)
  1700. || 0 == sOrgName.CompareNoCase(ml_sh_minute)
  1701. || 0 == sOrgName.CompareNoCase(ml_sz_minute) )
  1702. sFileName += ml_dat;
  1703. else
  1704. sFileName += ml_data;
  1706. sFileName += orgname;
  1708. return CSPFile::CopyFile( filename, sFileName, FALSE );
  1709. }
  1711. int CSelfDB::InstallCodetblBlock( const char * filename, const char *orgname )
  1712. {
  1713. if( NULL == filename || strlen(filename) == 0
  1714. || NULL == orgname || strlen(orgname) == 0 )
  1715. return 0;
  1717. int nRet = 0;
  1718. CDomainContainer newdomains;
  1719. if( newdomains.Load( filename ) )
  1720. {
  1721. nRet = AfxGetDomainContainer().AddDomainReplace( newdomains );
  1722. AfxGetDomainContainer().Store( AfxGetProfile().GetDomainFile() );
  1723. }
  1724. return nRet;
  1725. }
  1727. int CSelfDB::InstallCodetblFxjBlock( const char * filename, const char *orgname )
  1728. {
  1729. if( NULL == filename || strlen(filename) == 0
  1730. || NULL == orgname || strlen(orgname) == 0 )
  1731. return 0;
  1733. CSPString sName = orgname;
  1734. int nIndex = sName.Find( '.' );
  1735. if( -1 != nIndex )
  1736. sName = sName.Left(nIndex);
  1737. CDomain domain;
  1738. domain.m_strName = sName;
  1739. int nRet = domain.AddFxjDomain( filename );
  1740. if( nRet > 0 )
  1741. {
  1742. AfxGetDomainContainer().AddDomainReplace( domain );
  1743. }
  1744. return nRet;
  1745. }
  1747. int CSelfDB::InstallDRData( CDRData & drdata )
  1748. {
  1749. if( drdata.GetSize() <= 0 )
  1750. return 0;
  1752. CSPString sFileName;
  1753. CStockInfo stockinfo;
  1754. DWORD dwMarket = drdata.ElementAt(0).m_dwMarket;
  1755. CSPString sCode = drdata.ElementAt(0).m_szCode;
  1756. stockinfo.SetStockCode( dwMarket, sCode );
  1757. if( !GetFileName( sFileName, CStock::dataDR, &stockinfo ) )
  1758. return 0;
  1760. int nCount = 0;
  1762. CSPFile fileTo;
  1763. if( fileTo.Open( sFileName, CSPFile::modeCreate | CSPFile::modeNoTruncate | CSPFile::modeReadWrite ) )
  1764. {
  1765. for( int i=0; i<drdata.GetSize(); i++ )
  1766. {
  1767. CLK_DRDATA dbdrnew;
  1768. convert_DRDATA_to_CLK_DRDATA( &(drdata.ElementAt(i)), &dbdrnew );
  1770. fileTo.SeekToBegin( );
  1771. CLK_DRDATA dbdr;
  1772. memset( &dbdr, 0, sizeof(dbdr) );
  1773. BOOL bHas = FALSE;
  1774. BOOL bInsert = FALSE;
  1775. while( sizeof(dbdr) == fileTo.Read( &dbdr, sizeof(dbdr) ) )
  1776. {
  1777. if( dbdr.date == dbdrnew.date )
  1778. {
  1779. bHas = TRUE;
  1780. fileTo.Seek( fileTo.GetPosition()-sizeof(dbdr), CSPFile::begin );
  1781. break;
  1782. }
  1783. if( dbdr.date > dbdrnew.date )
  1784. {
  1785. bInsert = TRUE;
  1786. break;
  1787. }
  1788. }
  1789. if( bHas || !bInsert )
  1790. fileTo.Write( &dbdrnew, sizeof(dbdrnew) );
  1791. else if( bInsert )
  1792. {
  1793. int nCur = fileTo.GetPosition();
  1794. int nLen = fileTo.GetLength();
  1795. BYTE * pbuffer = new BYTE[nLen-nCur+1];
  1796. if( pbuffer )
  1797. {
  1798. if( nLen - nCur > 0 ) fileTo.Read( pbuffer, nLen-nCur );
  1799. fileTo.Seek( nCur-sizeof(dbdr), CSPFile::begin );
  1800. fileTo.Write( &dbdrnew, sizeof(dbdrnew) );
  1801. fileTo.Write( &dbdr, sizeof(dbdr) );
  1802. if( nLen - nCur > 0 ) fileTo.Write( pbuffer, nLen-nCur );
  1803. delete [] pbuffer;
  1804. }
  1805. }
  1806. nCount ++;
  1807. fileTo.Flush();
  1808. }
  1809. fileTo.Close();
  1810. }
  1811. return nCount;
  1812. }
  1814. int CSelfDB::InstallDRDataClk( const char * filename, const char *orgname )
  1815. {
  1816. if( NULL == filename || strlen(filename) == 0
  1817. || NULL == orgname || strlen(orgname) == 0 )
  1818. return 0;
  1820. CSPString sFileName;
  1821. CSPString sCode = orgname;
  1822. int nIndex = sCode.Find( '.' );
  1823. if( -1 != nIndex )
  1824. sCode = sCode.Left(nIndex);
  1826. CStockInfo info;
  1827. info.SetStockCode( CStock::marketUnknown, sCode );
  1828. DWORD dwMarket = info.GetMarket();
  1830. CDRData drdata;
  1831. CSPFile file;
  1832. if( file.Open( filename, CSPFile::modeRead ) )
  1833. {
  1834. CLK_DRDATA dbdr;
  1835. while( sizeof(dbdr) == file.Read(&dbdr,sizeof(dbdr)) )
  1836. {
  1837. DRDATA dr;
  1838. convert_CLK_DRDATA_to_DRDATA( dwMarket, sCode, &dbdr, &dr );
  1839. drdata.Add( dr );
  1840. }
  1841. file.Close();
  1842. }
  1843. return InstallDRData( drdata );
  1844. }
  1846. int CSelfDB::InstallDRDataFxj( const char * fxjfilename )
  1847. {
  1848. if( NULL == fxjfilename || strlen(fxjfilename) == 0 )
  1849. return 0;
  1851. CSPString sFileName = GetRootPath();
  1852. sFileName += self_chna_xdr;
  1854. return CSPFile::CopyFile( fxjfilename, sFileName, FALSE );
  1855. }
  1857. int CSelfDB::InstallBasetable( const char * filename, const char * orgname )
  1858. {
  1859. if( NULL == filename || strlen(filename) == 0
  1860. || NULL == orgname || strlen(orgname) == 0 )
  1861. return 0;
  1863. CSPString sFileName = GetRootPath();
  1864. sFileName += ml_data;
  1865. sFileName += orgname;
  1867. return CSPFile::CopyFile( filename, sFileName, FALSE );
  1868. }
  1870. int CSelfDB::InstallBasetableTdx( const char * filename )
  1871. {
  1872. if( NULL == filename || strlen(filename) == 0 )
  1873. return 0;
  1875. int nCount = 0;
  1877. CSPString sRoot = GetRootPath();
  1878. CSPString sFileNameSHSZ = sRoot + self_chna_basetbl;
  1879. CSPFile fileSHSZ, fileTdx;
  1880. if( fileSHSZ.Open( sFileNameSHSZ, CSPFile::modeWrite | CSPFile::modeCreate )
  1881. && fileTdx.Open( filename, CSPFile::modeRead ) )
  1882. {
  1883. fileTdx.Seek( TDX_FHEADER_SIZE, CSPFile::begin );
  1885. TDX_BASEDATA tdxblock;
  1886. while( sizeof(tdxblock) == fileTdx.Read( &tdxblock, sizeof(tdxblock) ) )
  1887. {
  1888. BASEDATA block;
  1889. if( convert_TDX_BASEDATA_to_BASEDATA( &tdxblock, &block ) )
  1890. {
  1891. fileSHSZ.Write( &block, sizeof(block) );
  1892. nCount ++;
  1893. }
  1894. }
  1895. }
  1897. return nCount;
  1898. }
  1900. int CSelfDB::InstallBasetableFxj( const char * filename )
  1901. {
  1902. if( NULL == filename || strlen(filename) == 0 )
  1903. return 0;
  1905. DWORD dwDate = CSPTime::GetCurrentTime().ToStockTimeDay();
  1906. {
  1907. CSPString sTemp = filename;
  1908. int index1 = sTemp.ReverseFind( '/' );
  1909. int index2 = sTemp.ReverseFind( '\' );
  1910. int index = max(index1,index2);
  1911. if( index > 0 )
  1912. sTemp = sTemp.Mid(index+1);
  1913. DWORD dwTemp = atol(sTemp);
  1914. CSPTime sptime;
  1915. if( sptime.FromStockTimeDay( dwTemp ) )
  1916. dwDate = dwTemp;
  1917. }
  1919. int nCount = 0;
  1921. CSPString sRoot = GetRootPath();
  1922. CSPString sFileNameSHSZ = sRoot + self_chna_basetbl;
  1923. CSPFile fileSHSZ, fileFxj;
  1924. if( fileSHSZ.Open( sFileNameSHSZ, CSPFile::modeWrite | CSPFile::modeCreate )
  1925. && fileFxj.Open( filename, CSPFile::modeRead ) )
  1926. {
  1927. fileFxj.Seek( FXJ_FHEADER_SIZE, CSPFile::begin );
  1929. FXJ_BASEDATA fxjblock;
  1930. while( sizeof(fxjblock) == fileFxj.Read( &fxjblock, sizeof(fxjblock) ) )
  1931. {
  1932. BASEDATA block;
  1933. if( convert_FXJ_BASEDATA_to_BASEDATA( &fxjblock, &block, dwDate ) )
  1934. {
  1935. fileSHSZ.Write( &block, sizeof(block) );
  1936. nCount ++;
  1937. }
  1938. }
  1939. }
  1941. return nCount;
  1942. }
  1944. int CSelfDB::InstallNewsText( const char * filename, const char *orgname )
  1945. {
  1946. if( NULL == filename || strlen(filename) == 0
  1947. || NULL == orgname || strlen(orgname) == 0 )
  1948. return 0;
  1950. CSPString sFileName = GetRootPath();
  1951. sFileName += self_news;
  1952. sFileName += orgname;
  1954. return CSPFile::CopyFile( filename, sFileName, FALSE );
  1955. }
  1957. int CSelfDB::InstallNewsText( const char * buffer, int nLen, const char *orgname )
  1958. {
  1959. if( NULL == buffer || nLen <= 0
  1960. || NULL == orgname || strlen(orgname) == 0 )
  1961. return 0;
  1963. CSPString sFileName = GetRootPath();
  1964. sFileName += self_news;
  1965. sFileName += orgname;
  1967. CSPFile file;
  1968. if( file.Open(sFileName,CSPFile::modeWrite|CSPFile::modeCreate) )
  1969. {
  1970. file.Write( buffer, nLen );
  1971. file.Close();
  1972. return 1;
  1973. }
  1974. return 0;
  1975. }
  1977. BOOL CSelfDB::GetFileName( CSPString &sFileName, int nDataType,
  1978. CStockInfo * pInfo, int nKType )
  1979. {
  1980. if( CStock::dataOutline == nDataType )
  1981. {
  1982. sFileName = GetRootPath();
  1983. sFileName += self_outline;
  1984. return TRUE;
  1985. }
  1987. if( NULL == pInfo || !pInfo->IsValidStock() )
  1988. return FALSE;
  1990. // 如果钱龙文件存在，就返回钱龙文件名（dataDR除外）
  1991. CSPString sFileNameQL;
  1992. if( CStock::dataDR != nDataType
  1993. && CQianlong::GetFileName( sFileNameQL, nDataType, pInfo, nKType )
  1994. && 0 == access(sFileNameQL,0) )
  1995. {
  1996. sFileName = sFileNameQL;
  1997. return TRUE;
  1998. }
  2000. // 确定市场类型
  2001. if( CStock::marketUnknown == pInfo->GetMarket() )
  2002. pInfo->ResolveTypeAndMarket( );
  2004. // 如果在 ml_sh 目录下找到文件，就返回找到的文件名
  2005. // 否则，若钱龙文件名长度大于0，就返回钱龙文件名，等于0就返回 ml_sh 下的文件名
  2006. if( CStock::dataBasetext == nDataType )
  2007. {
  2008. sFileName = GetRootPath();
  2009. sFileName += ml_sh_base;
  2010. sFileName += CSPString(pInfo->GetStockCode()) + ml_ext_base;
  2011. if( 0 != access(sFileName,0) && sFileNameQL.GetLength() > 0 )
  2012. sFileName = sFileNameQL;
  2013. return TRUE;
  2014. }
  2015. else if( CStock::dataK == nDataType )
  2016. {
  2017. sFileName = GetRootPath();
  2018. sFileName += ml_sh;
  2020. switch( nKType )
  2021. {
  2022. case CKData::ktypeMonth:
  2023. sFileName += CSPString(ml_month) + pInfo->GetStockCode() + ml_ext_month;
  2024. break;
  2025. case CKData::ktypeWeek:
  2026. sFileName += CSPString(ml_week) + pInfo->GetStockCode() + ml_ext_week;
  2027. break;
  2028. case CKData::ktypeDay:
  2029. sFileName += CSPString(ml_day) + pInfo->GetStockCode() + ml_ext_day;
  2030. break;
  2031. case CKData::ktypeMin60:
  2032. return FALSE;
  2033. case CKData::ktypeMin30:
  2034. return FALSE;
  2035. case CKData::ktypeMin15:
  2036. return FALSE;
  2037. case CKData::ktypeMin5:
  2038. sFileName += CSPString(ml_min5) + pInfo->GetStockCode() + ml_ext_min5;
  2039. break;
  2040. default:
  2041. return FALSE;
  2042. }
  2043. if( 0 != access(sFileName,0) && sFileNameQL.GetLength() > 0 )
  2044. sFileName = sFileNameQL;
  2045. return TRUE;
  2046. }
  2047. else if( CStock::dataDR == nDataType )
  2048. {
  2049. sFileName = GetRootPath();
  2050. if( pInfo->IsShenZhen() )
  2051. sFileName += self_sz_xdr;
  2052. else
  2053. sFileName += self_sh_xdr;
  2054. sFileName += CSPString(pInfo->GetStockCode()) + self_ext_xdr;
  2055. if( 0 == access(sFileName,0) )
  2056. return TRUE;
  2058. CSPString sTemp = GetRootPath();
  2059. sTemp += self_sh_xdr;
  2060. sTemp += CSPString(pInfo->GetStockCode()) + self_ext_xdr;
  2061. if( 0 == access(sTemp,0) )
  2062. sFileName = sTemp;
  2063. return TRUE;
  2064. }
  2065. else if( CStock::dataReport == nDataType )
  2066. {
  2067. sFileName = GetRootPath();
  2068. if( pInfo->IsShenZhen() )
  2069. sFileName += self_sz_report;
  2070. else
  2071. sFileName += self_sh_report;
  2072. return TRUE;
  2073. }
  2074. else if( CStock::dataMinute == nDataType )
  2075. {
  2076. sFileName = GetRootPath();
  2077. if( pInfo->IsShenZhen() )
  2078. sFileName += self_sz_minute;
  2079. else
  2080. sFileName += self_sh_minute;
  2081. return TRUE;
  2082. }
  2083. return FALSE;
  2084. }