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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 行业应用 > 金融证券系统 > 查看源码
response.cpp
资源名称：stocks.rar　[点击查看]
上传用户：wenyu2k02
上传日期：2016-04-13
资源大小：28k
文件大小：12k
源码类别：

金融证券系统

开发平台：

Delphi

response.cpp：源码内容
  3. #include "config.h"
  5. #include <string>
  6. #include <vector>
  7. #include <set>
  8. #include <map>
  9. #include <iostream>
  11. #include <boost/thread/detail/config.hpp>
  12. #include <boost/thread/thread.hpp>
  13. #include <boost/thread/recursive_mutex.hpp>
  14. #include <boost/date_time/gregorian/gregorian.hpp>
  15. #include <boost/date_time/posix_time/posix_time_types.hpp>
  16. // #include <boost/smart_assert/assert.hpp>
  17. #include <boost/static_assert.hpp>
  19. #include <loki/Factory.h>
  21. #include "../zlib/zlib.h"
  23. #include "request.h"
  24. #include "response.h"
  25. #include "stock.h"
  26. #include "util.hpp"
  28. namespace StockMarket{
  30. recursive_mutex res_fact_mutex;
  31. recursive_mutex process_packet_mutex;
  33. StockRes::StockRes():raw_data(0), raw_len(0), data(0),len(0),current(0),left(0),dataNew(false)
  34. {}
  35. StockRes::StockRes(uchar* pData, ulong data_len) : raw_data(pData), raw_len(data_len)
  36. {
  37. this->read(pData, data_len);
  38. }
  39. StockRes::~StockRes()
  40. {
  41. if(dataNew) delete[] data;
  42. }
  43. uint StockRes::read(const uchar* pData, ulong data_len)
  44. {
  45. raw_data = current = data = pData;
  46. dataNew = false;
  48. ulong len1 = get_packet_len();
  49. len1 = len1 < data_len ? len1 : data_len;
  50. raw_len = left = len = len1;
  52. ulong len2 = *(ushort*)(pData + 14);
  54. skip_byte(16 - 4); // this time, the data and len are re-adjust !! // reserve the len2 for umcompress_if
  55. umcompress_if();
  56. if(len != len2)
  57. {
  58. throw StockResWrongData(8);
  59. }
  60. return len1;
  61. }
  62. ulong StockRes::buff_left()
  63. {
  64. return left;
  65. }
  66. bool StockRes::end()
  67. {
  68. return 0 == left;
  69. }
  70. void StockRes::reset()
  71. {
  72. current = data;
  73. left = len;
  74. }
  75. void StockRes::skip_byte(ulong count)
  76. {
  77. if(count > left) 
  78. throw StockResWrongData(1);
  79. current += count;
  80. left -= count;
  81. }
  82. void StockRes::skip_data(ulong count)
  83. {
  84. while(count --)
  85. {
  86. if(current[0] < 0x80) 
  87. skip_byte(1);
  88. else if(current[1] < 0x80)
  89. skip_byte(2);
  90. else
  91. skip_byte(3);
  92. }
  93. }
  94. char StockRes::get_char()
  95. {
  96. char v = (*current);
  97. skip_byte(1);
  98. return v;
  99. }
  100. uchar StockRes::get_uchar()
  101. {
  102. uchar v = (uchar)(*current);
  103. skip_byte(1);
  104. return v;
  105. }
  106. short StockRes::get_short()
  107. {
  108. short v = *(short*)current;
  109. skip_byte(2);
  110. return v;
  111. }
  112. ushort StockRes::get_ushort()
  113. {
  114. ushort v = *(ushort*)current;
  115. skip_byte(2);
  116. return v;
  117. }
  118. int StockRes::get_int()
  119. {
  120. int v = *(int*)current;
  121. skip_byte(4);
  122. return v;
  123. }
  124. uint StockRes::get_uint()
  125. {
  126. uint v = *(uint*)current;
  127. skip_byte(4);
  128. return v;
  129. }
  130. float StockRes::get_float()
  131. {
  132. float v = *(float*)current;
  133. BOOST_STATIC_ASSERT(sizeof(float) == 4);
  134. skip_byte(4);
  135. return v;
  136. }
  138. int StockRes::parse_data()
  139. {
  140. if((current[0] >= 0x40 && current[0] < 0x80)  || current[0] >= 0xc0) // negative
  141. {
  142. return 0x40 - parse_data2();
  143. }
  144. else
  145. return parse_data2();
  146. }
  147. int StockRes::parse_data2() // we don't know this is correct yet
  148. {
  149. // 8f ff ff ff 1f == -49
  150. // bd ff ff ff 1f == -3
  151. // b0 fe ff ff 1f == -80
  152. // 8c 01  == 76
  153. // a8 fb b6 01 == 1017 万
  154. // a3 8e 11    == 14.02 万
  155. // 82 27         == 2498
  156. int v;
  157. int nBytes = 0;
  158. while(current[nBytes] >= 0x80)
  159. {
  160. ++nBytes;
  161. }
  162. ++nBytes;
  164. switch(nBytes)
  165. {
  166. case 1:
  167. v = current[0];
  168. break;
  169. case 2:
  170. v = current[1] * 0x40 + current[0] - 0x80;
  171. break;
  172. case 3:
  173. v = (current[2] * 0x80 + current[1] - 0x80) * 0x40 + current[0] - 0x80;
  174. break;
  175. case 4:
  176. v = ((current[3] * 0x80 + current[2] - 0x80) * 0x80 + current[1] - 0x80) * 0x40 + current[0] - 0x80;
  177. break;
  178. case 5:
  179. // over flow, positive to negative
  180. v = (((current[4] * 0x80 + current[3] - 0x80) * 0x80 + current[2] - 0x80) * 0x80 + current[1] - 0x80)* 0x40 + current[0] - 0x80;
  181. break;
  182. case 6:
  183. // over flow, positive to negative
  184. v = ((((current[5] * 0x80 + current[4] -0x80) * 0x80 +  current[3] - 0x80) * 0x80 + current[2] - 0x80) * 0x80 + current[1] - 0x80) * 0x40 + current[0] - 0x80;
  185. break;
  186. default:
  187. throw StockResWrongData(10);
  188. }
  189. skip_byte(nBytes);
  190. return v;
  191. }
  193. // if the data is compressed, then uncompressed them; Or else do nothing
  194. void StockRes::umcompress_if()
  195. {
  196. len = *(ushort*)(current);
  197. ulong new_len = *(ushort*)(current + 2);
  198. ulong new_len2 = new_len;
  199. skip_byte(4); // now the current moved to the real or compressed data
  200. if(0x78 == current[0] && 0x9c == (uchar)current[1])
  201. {
  202. uchar* new_data = new uchar[new_len];
  203. if(0 == uncompress((Byte*)new_data, &new_len, (Byte*)current, len) && new_len == new_len2)
  204. {
  205. dataNew = true;
  206. current = data = new_data;
  207. left = len = new_len;
  208. }
  209. else
  210. {
  211. delete[] new_data;
  212. throw StockResWrongData(2);
  213. }
  214. }
  215. else
  216. {
  217. data += 16;
  218. current = data;
  219. }
  220. }
  221. void StockHeartBeatRes ::operator()(){}
  223. ushort StockRes::get_packet_len()
  224. {
  225. return get_packet_len(raw_data);
  226. }
  227. ushort StockRes::get_packet_len(const uchar* pData)
  228. {
  229. return (*(ushort*)(pData + 12)) + 16;
  230. }
  231. uint StockRes::get_seq_id()
  232. {
  233. return get_seq_id(raw_data);
  234. }
  235. uint StockRes::get_seq_id(const uchar* pData)
  236. {
  237. return *(uint*)(pData + 5);
  238. }
  239. ushort StockRes::get_cmd_id()
  240. {
  241. return get_cmd_id(raw_data);
  242. }
  243. ushort StockRes::get_cmd_id(const uchar* pData)
  244. {
  245. return *(ushort*)(pData + 10);
  246. }
  247. StockListRes::StockListRes():StockRes()
  248. {}
  249. StockListRes::StockListRes(uchar* pData, ulong data_len):StockRes(pData, data_len)
  250. {
  251. // assert(CMD_STOCK_LIST == get_cmd_id());
  252. }
  253. void StockListRes::operator()()
  254. {
  255. posix_time::ptime now(posix_time::second_clock::local_time());
  256. posix_time::time_duration td(now.time_of_day());
  257. // uchar market = *(data + 4); // not market, but market location that is no use
  258. string code1((char*)(data + 5), MarketInfo::StocksCodeLen);
  259. short market = MarketInfo::get_market_type(code1);
  260. if(market >= MarketInfo::MARKET_UNKNOWN)
  261. {
  262. throw StockResWrongData(9);
  263. }
  264. MarketInfo::stocks_count[market] = get_ushort();
  266. StockBid::Bid bid; // zero it.
  267. ushort count = get_ushort();
  268. while(count--)
  269. {
  270. std::string code((char*)(current + 1), MarketInfo::StocksCodeLen);
  271. // Set up the lists of all stocks.
  272. if(MarketInfo::stocks_set[market].size() < MarketInfo::stocks_count[market]
  273. && market == MarketInfo::get_market_type(code)
  274. && (!(market == MarketInfo::MARKET_INDEX && code[0] < '3')))
  275. {
  276. MarketInfo::stocks_set[market].insert(code);
  277. }
  278. else
  279. {
  280. continue;
  281. }
  283. skip_byte(MarketInfo::StocksCodeLen + 1);
  285. bid.minute = (uint)(td.hours() * 60 + td.minutes());
  286. if(bid.minute > 15 * 60) 
  287. bid.minute = 15 * 60;
  288. else if(11 * 60 + 30 < bid.minute && bid.minute < 13 * 60)
  289. bid.minute = 11 * 60 + 30;
  291. bid.act = get_ushort();
  292. bid.price = parse_data();
  293. bid.y_close = parse_data() + bid.price;
  294. bid.open    = parse_data() + bid.price;
  295. bid.high    = parse_data() + bid.price;
  296. bid.low    = parse_data() + bid.price;
  297. bid.buy    = parse_data() + bid.price;
  298. bid.sell    = parse_data() + bid.price;
  299. bid.total_vol = parse_data2();
  300. bid.avail_vol = parse_data2();
  301. skip_byte(4);
  302. bid.inner_vol = parse_data2();
  303. bid.outer_vol = parse_data2();
  304. bid.updown   = parse_data();
  305. skip_data(1);
  306. bid.buy_price1 = parse_data() + bid.price;
  307. bid.sell_price1 = parse_data() + bid.price;
  308. bid.buy_vol1 =   parse_data2();
  309. bid.sell_vol1 =   parse_data2();
  310. bid.buy_price2 = parse_data() + bid.price;
  311. bid.sell_price2 = parse_data() + bid.price;
  312. bid.buy_vol2 =   parse_data2();
  313. bid.sell_vol2 =   parse_data2();
  314. bid.buy_price3 = parse_data() + bid.price;
  315. bid.sell_price3 = parse_data() + bid.price;
  316. bid.buy_vol3 =   parse_data2();
  317. bid.sell_vol3 =   parse_data2();
  318. bid.buy_price4 = parse_data() + bid.price;
  319. bid.sell_price4 = parse_data() + bid.price;
  320. bid.buy_vol4 =   parse_data2();
  321. bid.sell_vol4 =   parse_data2();
  322. bid.buy_price5 = parse_data() + bid.price;
  323. bid.sell_price5 = parse_data() + bid.price;
  324. bid.buy_vol5 =   parse_data2();
  325. bid.sell_vol5 =   parse_data2();
  327. recursive_mutex::scoped_lock guard(bid_mutex);
  329. if(!(market == MarketInfo::MARKET_INDEX && code[0] < '3'))
  330. instant_price_list[code][date_to_uint(gregorian::day_clock::local_day())].push_back(bid);
  332. // find next item.
  333. if(0 != count)
  334. {
  335. skip_byte(8);
  336. const uchar* p = 0;
  337. if(0 != (p = stock_code_search(current, 15)))
  338. {
  339. skip_byte(p - current - 1);
  340. }
  341. else
  342. {
  343. throw StockResWrongData(3);
  344. }
  345. }
  346. }
  347. return;
  348. }
  350. StockHoldChgRes::StockHoldChgRes():StockRes()
  351. {}
  352. StockHoldChgRes::StockHoldChgRes(uchar* pData, ulong data_len):StockRes(pData, data_len)
  353. {
  354. // assert(CMD_STOCKHOLD_CHANGE == get_cmd_id());
  355. }
  356. void StockHoldChgRes::operator()()
  357. {
  358. GBBQ gbbq;
  359. ushort stock_count = get_ushort();
  360. while(stock_count -- > 0)
  361. {
  362. skip_byte(1);
  363. if(!stockcode_is_valid(current))
  364. {
  365. throw StockResWrongData(4);
  366. }
  367. string s((char*)current, MarketInfo::StocksCodeLen);
  368. int uints = atoi(s.c_str());
  369. skip_byte(MarketInfo::StocksCodeLen);
  370. ushort record_count = get_ushort();
  371. while( record_count -- > 0)
  372. {
  373. skip_byte(MarketInfo::StocksCodeLen + 2);
  374. uint dt = get_uint();
  375. gbbq.code = s;
  376. gbbq.chg_type = get_uchar();
  377. gbbq.data.gb.old_cir = get_float();
  378. gbbq.data.gb.old_ttl = get_float();
  379. gbbq.data.gb.new_cir = get_float();
  380. gbbq.data.gb.new_ttl = get_float();
  381. stock_basic_info::Instance().add_stock_gbbq(dt, gbbq);
  382. }
  383. }
  384. }
  386. StockResWrongData::StockResWrongData( int i) : n_(i)
  387. {}
  388. const char * StockResWrongData::what() const throw()
  389. {
  390. return "StockResWrongData";
  391. }
  393. void ProcessResponsePacket(const uchar * pData , size_t len, bool test)
  394. {
  395. static uint packet_len = 0;
  396. static uint packet_curr_pos = 0;
  397. static uchar packet_buff[TCP_BUFSIZE_READ];
  399. recursive_mutex::scoped_lock guard(process_packet_mutex);
  400. // cout << hex<< (int)pData[0] << (int)pData[1] << (int)pData[2] << (int)pData[3];
  401. // cout << " len= " << len <<endl;
  403. if(test)
  404. {
  405. packet_len = len;
  406. }
  407. else
  408. {
  409. // application layer assembly 应用层组包
  410. if(pData[0] == 0xb1 && pData[1] == 0xcb && pData[2] == 0x74 && pData[3] == 0x00)
  411. {
  412. packet_curr_pos = 0;
  413. packet_len = StockRes::get_packet_len(pData);
  414. // cout  << "packet_len= " << packet_len << endl;
  415. }
  416. }
  417. if(packet_curr_pos + len <= packet_len)
  418. {
  419. memcpy(&packet_buff[0] + packet_curr_pos, pData, len);
  420. packet_curr_pos += len;
  421. }
  422. else
  423. {
  424. return;
  425. }
  426. if(packet_curr_pos == packet_len)
  427. {
  428. // 组包完成, 调整指针
  429. pData = &packet_buff[0];
  430. len = packet_len;
  431. packet_len = packet_curr_pos = 0;
  432. }
  433. else
  434. {
  435. return;
  436. }
  438. const uchar *orig_ptr = pData; uint orig_len = len;
  440. int cmd_id = StockRes::get_cmd_id(pData);
  441. try{
  442. boost::scoped_ptr <StockRes> pCmd(ResponseFactory::Instance().CreateObject(cmd_id));
  444. uint processed;
  445. while(len > 0)
  446. {
  447. processed = pCmd->read(pData, len);
  448. (*pCmd)();
  449. Request::res_seq_id(StockRes::get_seq_id(pData));
  451. len -= processed;
  452. pData += processed;
  453. }
  454. }
  455. catch(StockResWrongData& e)
  456. {
  457. if(!test)
  458. {
  459. log_packet((const char*)orig_ptr, orig_len);
  460. }
  461. cout << "Exception Id = " << e.n_ << endl;
  462. }
  463. catch(...)
  464. {
  465. cout << "Command" << cmd_id << " not implemented";
  466. }
  467. packet_len = packet_curr_pos = 0;
  468. }
  470. StockRes* CreateStockListRes()
  471. {
  472. return new StockListRes;
  473. }
  474. StockRes* CreateStockHoldChgRes()
  475. {
  476. return new StockHoldChgRes;
  477. }
  479. StockRes* CreateStockHeartBeatRes()
  480. {
  481. return new StockHeartBeatRes;
  482. }
  484. }