request

#ifndef _STOCK_REQUEST_H_
#define _STOCK_REQUEST_H_
 
#include <deque>
 
#include "config.h"
#include "stock.h"
#include "NBSocket.h"
 
using namespace std;
 
#pragma pack(push)
#pragma pack(1)
 
class Request
{
public:
 
	Request();
 
	virtual void send(NBSocket * pSock);
	virtual ~Request();
	virtual char* buff() = 0;
	virtual ulong len() = 0;
 
	void SetSeqId(uint id);
	virtual void SetRequestInfo( ReqTimeInfo& stInfo );
 
private:
	uint seq_id;
};
 
struct ReqHead
{
public:
	friend class Request;
	ReqHead()
	{
	};
	ReqHead( ushort cmd_id, ushort packet_len/*the total packet len*/);
	ReqHead( uint iSeqId,  char iPacketType, ushort iPacketLen, ushort iCmdId );
	void set_len(ushort payload_len);
	ushort get_len();
	uint get_seq_id();
 
private:
	void set_seq_id(uint id);
 
protected:
	char zip;				// always 0x0c: data-uncompressed
	uint seq_id;			// 同一种命令的 seq_id。
	char packet_type;	// 00: 回应。 1,2,3... request count
	ushort len;			//	数据长度
	ushort len1;			//  数据长度重复
	ushort cmd;			// b4 bf: 分钟线。。b5 bf 单笔成交
};
 
// 0c  01  20 63 00 02  2字节长度 2字节长度  3e 05 05 00      00 00 00 00   00 00  06 00 
class StockHeartBeat : public Request
{
public:
	char* buff();
	ulong len();
private:
	struct StockHeartBeatStruct
	{
		StockHeartBeatStruct() : header(CMD_HEART_BEAT, sizeof(StockHeartBeatStruct)), count(1)
		{
			memcpy(&stock_code[0],"000001", MarketInfo::StocksCodeLen);
			location = MarketInfo::get_market_location(&stock_code[0]);
		}
		ReqHead	header;
		ushort count;
		char location;
		char stock_code[MarketInfo::StocksCodeLen];
	}s;
};
 
 
//   0c 22 07 0a 00 01 0c 00 0c 00 24 05 00 00 00 00 00 00 1e 00 00 00
class StockListReq : public Request
{
public:
	StockListReq(MarketInfo::MarketType market_code, ushort record_offset = 0, 
		ushort record_count = 200, ushort record_total = 0);
	char* buff();
	ulong len();
	operator bool ();
	StockListReq& operator++();
protected:
	struct StockListStruct
	{
		StockListStruct(MarketInfo::MarketType market_code, ushort record_offset, ushort record_count)
			: header(CMD_STOCK_LIST, sizeof(StockListStruct)),
			offset(record_offset), count(record_count),unknown1(0),unknown2(0)
		{
			block = MarketInfo::get_block_from_market_type(market_code);
		}
		ReqHead	header;
		ushort block;		//  00 00 上A, 	01 00 上B, 	02 00 深A, 	03 00 深B, 	0x0d: 权证
		ushort unknown1;
		ushort offset;
		ushort count;
		ushort unknown2;
	}s;
	ushort total;
};
 
 
 
class StockHoldChgReq : public Request
{
public:
 
	StockHoldChgReq()
	{
	}
	StockHoldChgReq(const string& stock_code)
	{
		add_stock(stock_code);
	}
	char* buff();
	ulong len();
	bool add_stock(const string& stock_code);
	static const int max_stocks_a_request = 30;
protected:
	struct StockHoldStruct
	{
		char market_locale;
		char stock_code[MarketInfo::StocksCodeLen];
	};
	struct StockHoldChgReqStruct
	{
		StockHoldChgReqStruct() : header(CMD_STOCKHOLD_CHANGE, 0), count(0){}
		bool add_one_stock(const string& stock_code)
		{
			if(count >= max_stocks_a_request)
				return false;
 
			s_buff[count].market_locale = MarketInfo::get_market_location(stock_code);
			memcpy(&s_buff[count].stock_code, stock_code.c_str(), MarketInfo::StocksCodeLen);
			count++;
			header.set_len( sizeof(StockHoldStruct) * count + 4);
 
			return true;
		}
		ReqHead	header;
		ushort count;
		StockHoldStruct s_buff[max_stocks_a_request];		
	}s;
 
};
 
/*
获取股票数量 深市

发送
0c 0c 18 6c 00 01 08 00 08 00 4e 04 00 00 75 c7 33 01
接收
Bc cb 74 00 0c 0c 18 6c 00 00 4e 04 02 00 02 00 e7 19

In [61]: 0x19e7
Out[61]: 6631

沪市
发送
0c 0c 18 6c 00 01 08 00 08 00 4e 04 01 00 75 c7 33 01
接收
Bc cb 74 00 0c 0c 18 6c 00 00 4e 04 02 00 02 00 b3 33

In [63]: 0x333b
Out[63]: 13115
 
*/
 
class GetStockCountReq : public Request
{
public:
	GetStockCountReq( uchar cReqMarket ) : s( cReqMarket )
	{
	}
	char* buff();
	ulong len();
private:
	struct GetStockCountReqStruct
	{
		GetStockCountReqStruct( uchar cReqMarket ) : header( 0, 
			PKT_TYPE_REQUEST, sizeof ( GetStockCountReqStruct ), CMD_GET_STOCK_COUNT ),
			cMarket( cReqMarket ), cPack(0x00) , iPostFix(POSTFIX_GET_STOCK_COUNT)
		{
		}
		ReqHead	header;
		uchar cMarket;
		uchar cPack;
		uint iPostFix;
	}s;
};
 
/*
获取股票实时行情 深市

发送
0c 01 00 00 00 02 13 00 13 00 3e 05  05 00 00 00 00 00 00 00 01 00 00 30 30 30 30 30 31
接收
b1 cb 74 0 c 1 0 0 0 0 3e 5 53 0 53 0 64 4c 1 0 0 30 30 30 30 31 6e e bb 11 10 c c 46 85 
87 ef d fb 11 97 f8 36 b6 1 9a 2f f6 4d 87 aa 1f 90 ce 17 1 a7 d 0 1 99 e 95 2f 41 2 88 1 
95 18 42 3 b2 2b a4 c 43 4 8d 20 b0 4 44 5 8c 4b 8b f 8 11 0 1c 20 9 11 0 6e e 

 
*/
 
class GetStockQuotesReq : public Request
{
public:
	GetStockQuotesReq( const vector<QuotePara>& vecPara );
	char* buff();
	ulong len();
private:
	struct GetStockQuotesReqStruct
	{
		GetStockQuotesReqStruct( const vector<QuotePara>& vecPara );
		ReqHead	header;
		uchar sPack[10];
		char sPara[4096];
		ulong lParaLen;
	}s;
};
 
/*
 
pkg = bytearray.fromhex(u'0c 1b 08 00 01 01 0e 00 0e 00 1d 05')
        pkg.extend(struct.pack("<H6sI", market, code, 0))
        self.send_pkg = pkg
 
发送 0c 1b 08 00 01 01 0e 00 0e 00 1d 05  00 00    30 30 30 30 30 31  00 00 00 00 
获取分时行情
*/
 
class GetMinuteTimeDataReq : public Request
{
public:
	GetMinuteTimeDataReq(  ushort iReqMarket, const  char* sReqStockCode  ) :
	  s( iReqMarket, sReqStockCode )
	{
	}
	char* buff();
	ulong len();
private:
	struct GetMinuteTimeDataReqStruct
	{
		GetMinuteTimeDataReqStruct( ushort iReqMarket, const  char* sReqStockCode );
		ReqHead	header;
		ushort iMarket;
		uchar sStockCode[6];
		uint iPack;
	}s;
};
 
/*
 
pkg = bytearray.fromhex(u'0c 1b 08 00 01 01 0e 00 0e 00 1d 05')
        pkg.extend(struct.pack("<H6sI", market, code, 0))
        self.send_pkg = pkg
 
获取历史分时行情
*/
 
class GetHisMinuteTimeDataReq : public Request
{
public:
	GetHisMinuteTimeDataReq(  uint iDate, uchar cReqMarket, const  char* sReqStockCode  ) :
	  s( iDate, cReqMarket, sReqStockCode )
	{
	}
	char* buff();
	ulong len();
private:
	struct GetHisMinuteTimeDataReqStruct
	{
		GetHisMinuteTimeDataReqStruct( uint iDate, uchar cReqMarket, const  char* sReqStockCode );
		ReqHead	header;
		uint iDate;
		uchar cMarket;
		uchar sStockCode[6];
	}s;
};
 
/*
 
def setParams(self, market, code, start, count):
        if type(code) is six.text_type:
            code = code.encode("utf-8")
        pkg = bytearray.fromhex(u'0c 17 08 01 01 01 0e 00 0e 00 c5 0f')
        pkg.extend(struct.pack("<H6sHH", market, code, start, count))
        self.send_pkg = pkg
 
获取分时成交
*/
 
class GetTransactionDataReq : public Request
{
public:
	GetTransactionDataReq(  ushort iReqMarket, const  char* sReqStockCode, 
		ushort  iStart, ushort iCount   ) :
	  s( iReqMarket,   sReqStockCode, iStart, iCount )
	{
	}
	char* buff();
	ulong len();
private:
	struct GetTransactionDataReqStruct
	{
		GetTransactionDataReqStruct( ushort cReqMarket, const  char* sReqStockCode, 
			ushort iStart, ushort iCount );
		ReqHead	header;
		ushort iMarket;
		uchar sStockCode[6];
		ushort iStart;
		ushort iCount;
	}s;
};
 
 
/*
 
class GetHistoryTransactionData(BaseParser):

    def setParams(self, market, code, start, count, date):
        if type(code) is six.text_type:
            code = code.encode("utf-8")

        if type(date) is (type(date) is six.text_type) or (type(date) is six.binary_type):
            date = int(date)

        pkg = bytearray.fromhex(u'0c 01 30 01 00 01 12 00 12 00 b5 0f')
        pkg.extend(struct.pack("<IH6sHH", date, market, code, start, count))
        self.send_pkg = pkg
 
获取历史分时成交
*/
 
class GetHisTransactionDataReq : public Request
{
public:
	GetHisTransactionDataReq(  uint iDate, ushort iReqMarket, const  char* sReqStockCode, 
		ushort  iStart, ushort iCount   ) :
	  s( iDate, iReqMarket,   sReqStockCode, iStart, iCount )
	{
	}
	char* buff();
	ulong len();
private:
	struct GetHisTransactionDataReqStruct
	{
		GetHisTransactionDataReqStruct( uint iDate, ushort iReqMarket, const  char* sReqStockCode, 
			ushort iStart, ushort iCount );
		ReqHead	header;
		uint iDate;
		ushort iMarket;
		uchar sStockCode[6];
		ushort iStart;
		ushort iCount;
	}s;
};
 
/*
 
    def setParams(self, category, market, code, start, count):
        if type(code) is six.text_type:
            code = code.encode("utf-8")

        self.category = category

        values = (
            0x10c,
            0x01016408,
            0x1c,
            0x1c,
            0x052d,
            market,
            code,
            category,
            1,
            start,
            count,
            0, 0, 0  # I + I +  H total 10 zero
        )

        pkg = struct.pack("<HIHHHH6sHHHHIIH", *values)
        self.send_pkg = pkg
 
获取指数k线
*/
 
class GetIndexBarsReq : public Request
{
public:
	GetIndexBarsReq(  ushort iCategory, ushort iReqMarket, const  char* sReqStockCode, 
		ushort  iStart, ushort iCount   ) :
	  s( iCategory, iReqMarket,   sReqStockCode, iStart, iCount ),m_iCategory( iCategory )
	{
	}
	char* buff();
	ulong len();
	virtual void SetRequestInfo( ReqTimeInfo& stInfo );
private:
	struct GetIndexBarsReqStruct
	{
		GetIndexBarsReqStruct( ushort iCategory, ushort iReqMarket, const  char* sReqStockCode, 
			ushort iStart, ushort iCount );
		ReqHead	header;
		ushort iMarket;
		uchar sStockCode[6];
		ushort iCategory;
		ushort iPack1;
		ushort iStart;
		ushort iCount;
		char sPack[10];
	}s;
	int m_iCategory;
};
 
 
#pragma pack(pop)
 
typedef shared_ptr<Request> CmdData_t;
typedef deque<CmdData_t > CmdQueue_t;
 
 
#endif
 

#include "stdafx.h"
#include "config.h"
 
#include <vector>
#include <set>
#include <map>
#include <iostream>
 
 
#include "tcpSocket.h"
#include "stock.h"
#include "request.h"
#include "util.hpp"
 
#define REQ_BUF_FUNC_IMP(sClassName) char* sClassName::buff()\
{\
	return (char*)&s;\
}
 
#define REQ_LEN_FUNC_IMP(sClassName) ulong sClassName::len()\
{\
	return sizeof(s);\
}
 
 
Request::Request()
{
}
 
void Request::SetSeqId(uint id)
{
	seq_id = id;
}
 
 
void Request::send(NBSocket * pSock)
{
	ReqHead* pHead = (ReqHead*)buff();
	pHead->set_seq_id(seq_id);
 
	string sNow;
	getNowStr( sNow );
 
	//cout << sNow << ":NBSocket Send:"  << get_raw_string( string((char*)buff(), len() ) )  << endl;
 
	pSock->Send(buff(), len());
}
 
 
Request::~Request()
{
}
 
void Request::SetRequestInfo( ReqTimeInfo& stInfo )
{
}
 
 
 
ReqHead::ReqHead( ushort cmd_id, ushort packet_len/*the total packet len*/ = 0)
{
	zip = 0x0c;
	seq_id = 0;
	packet_type = 1;
	len = len1 = packet_len - sizeof(ReqHead) + 2;
	cmd = cmd_id;
}
 
ReqHead::ReqHead( uint iSeqId,  char iPacketType, ushort iPacketLen, ushort iCmdId )
{
	zip = 0x0c;
	seq_id = iSeqId;
	packet_type = iPacketType;
	len = len1 = iPacketLen - sizeof(ReqHead) + 2;
	cmd = iCmdId;
}
 
uint ReqHead::get_seq_id()
{
	return seq_id;
}
 
void ReqHead::set_seq_id(uint id)
{
	seq_id = id;
}
 
void ReqHead::set_len(ushort payload_len)
{
	len = len1 = payload_len;
}
 
ushort ReqHead::get_len()
{
	return len;
}
 
REQ_BUF_FUNC_IMP(StockHeartBeat)
 
ulong StockHeartBeat::len()
{
	return sizeof(StockHeartBeatStruct);
}
 
StockListReq::StockListReq(MarketInfo::MarketType market_code, ushort record_offset
	, ushort record_count, ushort record_total)
	: s(market_code, record_offset, record_count), total(record_total)
{
	if(0 == record_total)
	{
		total = record_count;
	}
}
 
REQ_BUF_FUNC_IMP(StockListReq)
 
ulong StockListReq::len()
{
	return sizeof(s);
}
 
StockListReq::operator bool ()
{
	return s.offset < total;
}
StockListReq& StockListReq::operator ++ ()
{
	if(s.offset + s.count < total)
	{
		s.offset = s.offset + s.count ;
		s.count = (total - s.offset) > s.count ? s.count : (total - s.offset);
	}
	else
	{
		s.offset = total;
	}
	return *this;
}
 
char* StockHoldChgReq::buff()
{
	return (char*)&s;
}
ulong StockHoldChgReq::len()
{
	return sizeof(ReqHead) + sizeof(ushort) + sizeof(StockHoldStruct) * s.count;
}
bool StockHoldChgReq::add_stock(const string& stock_code)
{
	return s.add_one_stock(stock_code);
}
 
 
REQ_BUF_FUNC_IMP(GetStockCountReq)
REQ_LEN_FUNC_IMP(GetStockCountReq)
 
REQ_BUF_FUNC_IMP(GetStockQuotesReq)
 
GetStockQuotesReq::GetStockQuotesReq( const vector<QuotePara>& vecPara )
	: s( vecPara )
{
	s.header.set_len(  sizeof( s.sPack ) +  s.lParaLen + 2 ) ;
}
 
GetStockQuotesReq::GetStockQuotesReqStruct::GetStockQuotesReqStruct( 
	const vector<QuotePara>& vecPara ) : header( 0, 
	PKT_TYPE_QUOTES, 0, CMD_GET_STOCK_QUOTES )
{
	memset( sPack, 0, sizeof( sPack ) );
	sPack[0]=(uchar)0x05;
	sPack[8]=(uchar)0x01;
	string sParaList;
	vector<QuotePara>::const_iterator itr = vecPara.begin();
	for ( ; itr != vecPara.end(); ++itr )
	{
		sParaList.append( 1, (char)itr->cMarket );
		sParaList.append( string( itr->sStockCode, sizeof( itr->sStockCode) ) );
	}
	lParaLen = sParaList.length();
	//cout << "lParaLen is " << lParaLen << ", sizeof( sPara ) is  " << sizeof( sPara )   << endl;
	if ( lParaLen < sizeof( sPara )  )
	{
		memcpy( sPara, sParaList.c_str(), lParaLen );
	}
	else
	{
		lParaLen = 0;
		memset( sPara, 0, sizeof( sPara )  );
	}
}
 
 
ulong GetStockQuotesReq::len()
{
	return  sizeof ( ReqHead )  + sizeof( s.sPack ) +  s.lParaLen ;
}
 
 
REQ_BUF_FUNC_IMP(GetMinuteTimeDataReq)
REQ_LEN_FUNC_IMP(GetMinuteTimeDataReq)
 
GetMinuteTimeDataReq::GetMinuteTimeDataReqStruct::GetMinuteTimeDataReqStruct( 
	ushort iReqMarket, const  char* sReqStockCode ) : header( 0, 
			PKT_TYPE_REQUEST, sizeof (  GetMinuteTimeDataReqStruct ), CMD_GET_MINUTE_DATA ),
			iMarket( iMarket ),iPack(0)
{
	strncpy( (char*)sStockCode, (char*)sReqStockCode, sizeof( sStockCode ) );
}
 
REQ_BUF_FUNC_IMP(GetHisMinuteTimeDataReq)
REQ_LEN_FUNC_IMP(GetHisMinuteTimeDataReq)
 
GetHisMinuteTimeDataReq::GetHisMinuteTimeDataReqStruct::GetHisMinuteTimeDataReqStruct( 
	uint iReqDate, uchar cReqMarket, const  char* sReqStockCode ) : header( 0, 
			PKT_TYPE_REQUEST, sizeof (  GetHisMinuteTimeDataReqStruct ), CMD_GET_HIS_MINUTE_DATA ),
			iDate( iReqDate ), cMarket( cMarket ) 
{
	strncpy( (char*)sStockCode, (char*)sReqStockCode, sizeof( sStockCode ) );
}
 
REQ_BUF_FUNC_IMP(GetTransactionDataReq)
REQ_LEN_FUNC_IMP(GetTransactionDataReq)
 
GetTransactionDataReq::GetTransactionDataReqStruct::GetTransactionDataReqStruct( 
	ushort iReqMarket, const  char* sReqStockCode,  ushort iReqStart, ushort iReqCount  )
	: header( 0,  PKT_TYPE_REQUEST, sizeof (  GetTransactionDataReqStruct ), CMD_GET_TRANSACTION_DATA ),
	iMarket( iReqMarket ), iStart( iReqStart ), iCount( iReqCount )
{
	strncpy( (char*)sStockCode, (char*)sReqStockCode, sizeof( sStockCode ) );
}
 
REQ_BUF_FUNC_IMP(GetHisTransactionDataReq)
REQ_LEN_FUNC_IMP(GetHisTransactionDataReq)
 
GetHisTransactionDataReq::GetHisTransactionDataReqStruct::GetHisTransactionDataReqStruct( 
	uint iReqDate, ushort iReqMarket, const  char* sReqStockCode,  ushort iReqStart, ushort iReqCount  )
	: header( 0,  PKT_TYPE_REQUEST, sizeof (  GetHisTransactionDataReqStruct ), CMD_GET_HIS_TRANSACTION_DATA ),
	iDate(iReqDate), iMarket( iReqMarket ), iStart( iReqStart ), iCount( iReqCount )
{
	strncpy( (char*)sStockCode, (char*)sReqStockCode, sizeof( sStockCode ) );
}
 
REQ_BUF_FUNC_IMP(GetIndexBarsReq)
REQ_LEN_FUNC_IMP(GetIndexBarsReq)
 
GetIndexBarsReq::GetIndexBarsReqStruct::GetIndexBarsReqStruct( 
	ushort iReqCategory, ushort iReqMarket, const  char* sReqStockCode, 
		ushort  iReqStart, ushort iReqCount  )
	: header( 0,  PKT_TYPE_REQUEST, sizeof (  GetIndexBarsReqStruct ), CMD_GET_INDEX_BARS ),
	iMarket( iReqMarket ),iCategory(iReqCategory), iPack1(1), iStart( iReqStart ), iCount( iReqCount )
{
	strncpy( (char*)sStockCode, (char*)sReqStockCode, sizeof( sStockCode ) );
	memset( sPack, 0, sizeof( sPack ) );
 
}
 
void GetIndexBarsReq::SetRequestInfo( ReqTimeInfo& stInfo )
{
	stInfo.iCategory = m_iCategory;
}