tw.cpp

接收证券行情数据接口的VC源代码,配合上mystock,可很好了解股票软件的内部源代码

	return 0;
}

int TryGetReport(BYTE* buffer, size_t len, PRCV_DATA pRCV_DATA)
{
	if(len < sizeof(TW_ANS))
		return 0;

	TW_ANS * pans = (TW_ANS*)buffer;
	if(TW_MAGIC != pans->m_header.m_magic)
		return 0;
	if(0x00 != pans->m_tag1 || 0x03 != pans->m_tag2)
		return 0;
	CTWStockArray astocks;
	BOOL bStockOK = GetSerialStock(pans->m_serial, astocks);

	// get it, fill pRCV_DATA
	size_t dataoffset = 43;
	int datalen = len - dataoffset;
	if(pRCV_DATA && bStockOK && astocks.GetSize() > 0 && datalen >= (int)sizeof(TW_ANS_REPORT))
	{
		TW_ANS_REPORT * preport = (TW_ANS_REPORT*)(buffer+dataoffset);

		memset(pRCV_DATA, 0, sizeof(RCV_DATA));
		pRCV_DATA->m_wDataType	=	RCV_REPORT;	// no use
		pRCV_DATA->m_nPacketNum	=	astocks.GetSize();
		pRCV_DATA->m_bDISK		=	FALSE;
		pRCV_DATA->m_pReport	=	new RCV_REPORT_STRUCTEx[astocks.GetSize()];
		memset(pRCV_DATA->m_pReport, 0, sizeof(RCV_REPORT_STRUCTEx)*astocks.GetSize());

		CSPTime tLatest = CTSCache::GetInstance().GetLocalLatest();
		for(int i=0; i<astocks.GetSize() && i<datalen/(int)sizeof(TW_ANS_REPORT); i++)
		{
			pRCV_DATA->m_pReport[i].m_cbSize = sizeof(RCV_REPORT_STRUCTEx);
			pRCV_DATA->m_pReport[i].m_time = tLatest.GetTime();

			pRCV_DATA->m_pReport[i].m_wMarket = (astocks[i].m_type & 0x20) ? SZ_MARKET_EX : SH_MARKET_EX;
			strncpy(pRCV_DATA->m_pReport[i].m_szLabel, astocks[i].m_code,
					min(sizeof(pRCV_DATA->m_pReport[i].m_szLabel),sizeof(astocks[i].m_code)));
	
			// unknown pRCV_DATA->m_pReport[i].m_fLastClose	= (float)(0.001*preport->m_open);
			pRCV_DATA->m_pReport[i].m_fOpen		= (float)(0.001*preport[i].m_open);
			pRCV_DATA->m_pReport[i].m_fHigh		= (float)(0.001*preport[i].m_high);
			pRCV_DATA->m_pReport[i].m_fLow		= (float)(0.001*preport[i].m_low);
			pRCV_DATA->m_pReport[i].m_fNewPrice	= (float)(0.001*preport[i].m_new);
			pRCV_DATA->m_pReport[i].m_fVolume	= (float)(0.01*preport[i].m_volume);
			pRCV_DATA->m_pReport[i].m_fAmount	= (float)(0.01*preport[i].m_amount);

			pRCV_DATA->m_pReport[i].m_fBuyPrice[0]= (float)(0.001*preport[i].m_buy1);
			pRCV_DATA->m_pReport[i].m_fBuyPrice[1]= (float)(0.001*preport[i].m_buy2);
			pRCV_DATA->m_pReport[i].m_fBuyPrice[2]= (float)(0.001*preport[i].m_buy3);
			pRCV_DATA->m_pReport[i].m_fBuyVolume[0]= (float)(0.01*preport[i].m_buy1vol);
			pRCV_DATA->m_pReport[i].m_fBuyVolume[1]= (float)(0.01*preport[i].m_buy2vol);
			pRCV_DATA->m_pReport[i].m_fBuyVolume[2]= (float)(0.01*preport[i].m_buy3vol);
			pRCV_DATA->m_pReport[i].m_fSellPrice[0]= (float)(0.001*preport[i].m_sell1);
			pRCV_DATA->m_pReport[i].m_fSellPrice[1]= (float)(0.001*preport[i].m_sell2);
			pRCV_DATA->m_pReport[i].m_fSellPrice[2]= (float)(0.001*preport[i].m_sell3);
			pRCV_DATA->m_pReport[i].m_fSellVolume[0]= (float)(0.01*preport[i].m_sell1vol);
			pRCV_DATA->m_pReport[i].m_fSellVolume[1]= (float)(0.01*preport[i].m_sell2vol);
			pRCV_DATA->m_pReport[i].m_fSellVolume[2]= (float)(0.01*preport[i].m_sell3vol);
		}

		return len;
	}

	return 0;
}

int TryGetMinute(BYTE* buffer, size_t len, PRCV_DATA pRCV_MINUTE, PRCV_DATA pRCV_REPORT)
{
	if(len < sizeof(TW_ANS))
		return 0;

	TW_ANS * pans = (TW_ANS*)buffer;
	if(TW_MAGIC != pans->m_header.m_magic)
		return 0;
	if(0x01 != pans->m_tag1 || 0x04 != pans->m_tag2)
		return 0;
	TW_STOCK	stock;
	memset(&stock, 0, sizeof(stock));
	BOOL bStockOK = GetSerialStock(pans->m_serial, stock);

	// get it, fill pRCV_DATA
	size_t dataoffset = 43;
	int datalen = len - dataoffset;
	if(pRCV_MINUTE && pRCV_REPORT && bStockOK && datalen >= (int)(sizeof(TW_ANS_MINUTE)-240*sizeof(TW_MINUTE)))
	{
		TW_ANS_MINUTE * pminute = (TW_ANS_MINUTE*)(buffer+dataoffset);

		CSPTime tLatest = CTSCache::GetInstance().GetLocalLatest();

		int nCount = min(241,pminute->m_offset+1);

		int count1 = 0, count2 = 0;
		for(int k=0; k<nCount; k++)
		{
			if(pminute->m_minutes[k].m_data1 <= pminute->m_high && pminute->m_minutes[k].m_data1 >= pminute->m_low)
				count1 ++;
			if(pminute->m_minutes[k].m_data2 <= pminute->m_high && pminute->m_minutes[k].m_data2 >= pminute->m_low)
				count2 ++;
		}
		int mode = (count1 > count2 ? 1 : 2);

		// minute
		memset(pRCV_MINUTE, 0, sizeof(RCV_DATA));
		pRCV_MINUTE->m_wDataType	=	FILE_MINUTE_EX;
		pRCV_MINUTE->m_nPacketNum	=	1+nCount;
		pRCV_MINUTE->m_bDISK		=	FALSE;
		pRCV_MINUTE->m_pMinute		=	new RCV_MINUTE_STRUCTEx[1+nCount];
		memset(pRCV_MINUTE->m_pMinute, 0, sizeof(RCV_MINUTE_STRUCTEx)*(1+nCount));
		pRCV_MINUTE->m_pMinute[0].m_head.m_dwHeadTag	=	EKE_HEAD_TAG;
		pRCV_MINUTE->m_pMinute[0].m_head.m_wMarket		=	(stock.m_type & 0x20) ? SZ_MARKET_EX : SH_MARKET_EX;
		strncpy(pRCV_MINUTE->m_pMinute[0].m_head.m_szLabel, stock.m_code,
				min(sizeof(pRCV_MINUTE->m_pMinute[0].m_head.m_szLabel),sizeof(stock.m_code)));
		
		for(int i=0; i<nCount; i++)
		{
			pRCV_MINUTE->m_pMinute[i+1].m_time = CSPTime::GetTradeOffsetToTime(i,tLatest.GetTime());
			if(1 == mode)
			{
				pRCV_MINUTE->m_pMinute[i+1].m_fPrice = (float)(0.001 * pminute->m_minutes[i].m_data1);
				pRCV_MINUTE->m_pMinute[i+1].m_fVolume = (float)(0.01 * pminute->m_minutes[i].m_data2);
			}
			else
			{
				pRCV_MINUTE->m_pMinute[i+1].m_fPrice = (float)(0.001 * pminute->m_minutes[i].m_data2);
				pRCV_MINUTE->m_pMinute[i+1].m_fVolume = (float)(0.01 * pminute->m_minutes[i].m_data1);
			}
			pRCV_MINUTE->m_pMinute[i+1].m_fAmount = (float)(100. * pRCV_MINUTE->m_pMinute[i+1].m_fVolume * pRCV_MINUTE->m_pMinute[i+1].m_fPrice);
		}

		// report
		memset(pRCV_REPORT, 0, sizeof(RCV_DATA));
		pRCV_REPORT->m_wDataType	=	RCV_REPORT;	// no use
		pRCV_REPORT->m_nPacketNum	=	11;
		pRCV_REPORT->m_bDISK		=	FALSE;
		pRCV_REPORT->m_pReport		=	new RCV_REPORT_STRUCTEx[11];
		memset(pRCV_REPORT->m_pReport, 0, sizeof(RCV_REPORT_STRUCTEx)*11);
		for(i=0;i <11; i++)
		{
			pRCV_REPORT->m_pReport[i].m_cbSize = sizeof(RCV_REPORT_STRUCTEx);
			pRCV_REPORT->m_pReport[i].m_time = CSPTime::GetTradeOffsetToTime(pminute->m_details[i].m_offset,tLatest.GetTime());

			pRCV_REPORT->m_pReport[i].m_wMarket = (stock.m_type & 0x20) ? SZ_MARKET_EX : SH_MARKET_EX;
			strncpy(pRCV_REPORT->m_pReport[i].m_szLabel, stock.m_code,
					min(sizeof(pRCV_REPORT->m_pReport[i].m_szLabel),sizeof(stock.m_code)));
	
			// unknown pRCV_REPORT->m_pReport[i].m_fLastClose	= (float)(0.001*pminute->m_open);
			pRCV_REPORT->m_pReport[i].m_fOpen		= (float)(0.001*pminute->m_open);
			pRCV_REPORT->m_pReport[i].m_fHigh		= (float)(0.001*pminute->m_high);
			pRCV_REPORT->m_pReport[i].m_fLow		= (float)(0.001*pminute->m_low);
			pRCV_REPORT->m_pReport[i].m_fNewPrice	= (float)(0.001*pminute->m_details[i].m_price);
			pRCV_REPORT->m_pReport[i].m_fVolume		= (float)(0.01*pminute->m_details[i].m_volume);
			pRCV_REPORT->m_pReport[i].m_fAmount		= (float)(100.*pRCV_REPORT->m_pReport[i].m_fVolume*pRCV_REPORT->m_pReport[i].m_fNewPrice);

			pRCV_REPORT->m_pReport[i].m_fBuyPrice[0]= (float)(0.001*pminute->m_details[i].m_buy);
			if(10==i)	pRCV_REPORT->m_pReport[i].m_fBuyPrice[1]= (float)(0.001*pminute->m_buy2);
			if(10==i)	pRCV_REPORT->m_pReport[i].m_fBuyPrice[2]= (float)(0.001*pminute->m_buy3);
			if(10==i)	pRCV_REPORT->m_pReport[i].m_fBuyVolume[0]= (float)(0.01*pminute->m_buy1vol);
			if(10==i)	pRCV_REPORT->m_pReport[i].m_fBuyVolume[1]= (float)(0.01*pminute->m_buy2vol);
			if(10==i)	pRCV_REPORT->m_pReport[i].m_fBuyVolume[2]= (float)(0.01*pminute->m_buy3vol);
			pRCV_REPORT->m_pReport[i].m_fSellPrice[0]= (float)(0.001*pminute->m_details[i].m_sell);
			if(10==i)	pRCV_REPORT->m_pReport[i].m_fSellPrice[1]= (float)(0.001*pminute->m_sell2);
			if(10==i)	pRCV_REPORT->m_pReport[i].m_fSellPrice[2]= (float)(0.001*pminute->m_sell3);
			if(10==i)	pRCV_REPORT->m_pReport[i].m_fSellVolume[0]= (float)(0.01*pminute->m_sell1vol);
			if(10==i)	pRCV_REPORT->m_pReport[i].m_fSellVolume[1]= (float)(0.01*pminute->m_sell2vol);
			if(10==i)	pRCV_REPORT->m_pReport[i].m_fSellVolume[2]= (float)(0.01*pminute->m_sell3vol);
		}

		return len;
	}

	return 0;
}

int TryGetHistory(BYTE* buffer, size_t len, PRCV_DATA pRCV_DATA)
{
	if(len < sizeof(TW_ANS))
		return 0;

	TW_ANS * pans = (TW_ANS*)buffer;
	if(TW_MAGIC != pans->m_header.m_magic)
		return 0;
	if(0x09 != pans->m_tag2)
		return 0;
	TW_STOCK	stock;
	memset(&stock, 0, sizeof(stock));
	int	nCount = 0;
	BOOL bStockOK = GetSerialStock(pans->m_serial, stock, &nCount);
	if(1 == nCount)	nCount = 2;

	int ktype = ktypeDay;
	if(0x20 == pans->m_tag1)
		ktype = ktypeDay;
	else if(0x30 == (0xf0 & pans->m_tag1))
		ktype = ktypeMin5;
	else if(0x40 == (0xf0 & pans->m_tag1))
		ktype = ktypeMin15;
	else if(0x50 == (0xf0 & pans->m_tag1))
		ktype = ktypeMin30;
	else if(0x60 == (0xf0 & pans->m_tag1))
		ktype = ktypeMin60;
	else if(0x10 == (0xf0 & pans->m_tag1))
		ktype = ktypeDay;
	else if(0x80 == (0xf0 & pans->m_tag1))
		ktype = ktypeWeek;
	else if(0x90 == (0xf0 & pans->m_tag1))
		ktype = ktypeMonth;

	// get it, fill pRCV_DATA
	size_t dataoffset = 43;
	int datalen = len - dataoffset;
	if(pRCV_DATA && bStockOK && nCount > 0 && datalen >= nCount*(int)(sizeof(TW_ANS_HISTORY)+sizeof(DWORD)))
	{
		int dataprefix = datalen - nCount*(int)(sizeof(TW_ANS_HISTORY)+sizeof(DWORD));
		if(2 == nCount && datalen >= nCount*(int)(sizeof(TW_ANS_HISTORY)+sizeof(DWORD))+36)
		{
			dataprefix = datalen - nCount*(int)(sizeof(TW_ANS_HISTORY)+sizeof(DWORD)) - 36;
		}

		TW_ANS_HISTORY * phistory = (TW_ANS_HISTORY*)(buffer+dataoffset+dataprefix);

		CSPTime tLatest = CTSCache::GetInstance().GetLocalLatest();

		// minute
		memset(pRCV_DATA, 0, sizeof(RCV_DATA));
		pRCV_DATA->m_wDataType	=	FILE_HISTORY_EX;
		pRCV_DATA->m_nPacketNum	=	1 + nCount;
		pRCV_DATA->m_bDISK		=	FALSE;
		pRCV_DATA->m_pDay		=	new RCV_HISTORY_STRUCTEx[pRCV_DATA->m_nPacketNum+1];
		memset(pRCV_DATA->m_pDay, 0, sizeof(RCV_HISTORY_STRUCTEx)*(pRCV_DATA->m_nPacketNum+1));

		pRCV_DATA->m_pDay[0].m_head.m_dwHeadTag	=	EKE_HEAD_TAG;
		pRCV_DATA->m_pDay[0].m_head.m_wMarket	=	(stock.m_type & 0x20) ? SZ_MARKET_EX : SH_MARKET_EX;
		strncpy(pRCV_DATA->m_pDay[0].m_head.m_szLabel, stock.m_code,
				min(sizeof(pRCV_DATA->m_pDay[0].m_head.m_szLabel),sizeof(stock.m_code)));
		
		for(int i=0; i<nCount; i++)
		{
			CSPTime	sptime;
			if(sptime.FromStockTime(phistory[i].m_date, ktype, tLatest.GetYear()))
				pRCV_DATA->m_pDay[i+1].m_time = sptime.GetTime();
			else
				return 0;
			pRCV_DATA->m_pDay[i+1].m_fOpen = (float)(0.001 * phistory[i].m_open);
			pRCV_DATA->m_pDay[i+1].m_fHigh = (float)(0.001 * phistory[i].m_high);
			pRCV_DATA->m_pDay[i+1].m_fLow = (float)(0.001 * phistory[i].m_low);
			pRCV_DATA->m_pDay[i+1].m_fClose = (float)(0.001 * phistory[i].m_close);
			pRCV_DATA->m_pDay[i+1].m_fVolume = (float)(phistory[i].m_volume);
			pRCV_DATA->m_pDay[i+1].m_fAmount = (float)(1000. * ((DWORD*)&(phistory[nCount]))[i]);
		}

		return len;
	}

	return 0;
}

int TryGetMultisort(BYTE* buffer, size_t len, PRCV_DATA pRCV_DATA)
{
	if(len < sizeof(TW_ANS))
		return 0;

	TW_ANS * pans = (TW_ANS*)buffer;
	if(TW_MAGIC != pans->m_header.m_magic)
		return 0;
	if(0x0a != pans->m_tag1 || 0x08 != pans->m_tag2)
		return 0;

	// get it, fill pRCV_DATA
	size_t dataoffset = 41;
	int datalen = len - dataoffset;
	if(pRCV_DATA && datalen >= (int)sizeof(TW_ANS_MULTISORT))
	{
		TW_ANS_MULTISORT * pmultisort = (TW_ANS_MULTISORT*)(buffer+dataoffset);

		if(0x0006 == pmultisort->m_tag1 || datalen == sizeof(TW_ANS_MULTISORT))
		{
			memset(pRCV_DATA, 0, sizeof(RCV_DATA));
			pRCV_DATA->m_wDataType	=	FILE_MULTISORT_EX;	// no use
			pRCV_DATA->m_nPacketNum	=	1;
			pRCV_DATA->m_bDISK		=	FALSE;
			pRCV_DATA->m_pMultisort	=	new RCV_MULTISORT_STRUCTEx[1];
			memset(pRCV_DATA->m_pMultisort, 0, sizeof(RCV_MULTISORT_STRUCTEx)*1);
			memcpy(pRCV_DATA->m_pMultisort, pmultisort, sizeof(TW_ANS_MULTISORT));
			return len;
		}
	}

	return 0;
}

int TryGetDetail(BYTE* buffer, size_t len, PRCV_DATA pRCV_DATA)
{
	if(len < sizeof(TW_ANS))
		return 0;

	TW_ANS * pans = (TW_ANS*)buffer;
	if(TW_MAGIC != pans->m_header.m_magic)
		return 0;
	if(0x01 != pans->m_tag1 || 0x02 != pans->m_tag2)
		return 0;
	TW_STOCK	stock;
	memset(&stock, 0, sizeof(stock));
	BOOL bStockOK = GetSerialStock(pans->m_serial, stock);

	// get it, fill pRCV_DATA
	size_t dataoffset = 43;
	int datalen = len - dataoffset;
	if(pRCV_DATA && bStockOK && datalen >= (int)sizeof(TW_ANS_DETAIL))
	{
		TW_ANS_DETAIL * pdetail = (TW_ANS_DETAIL*)(buffer+dataoffset);
		int packetsize = datalen/(int)sizeof(TW_ANS_DETAIL);

		memset(pRCV_DATA, 0, sizeof(RCV_DATA));
		pRCV_DATA->m_wDataType	=	RCV_REPORT;	// no use
		pRCV_DATA->m_nPacketNum	=	packetsize;
		pRCV_DATA->m_bDISK		=	FALSE;
		pRCV_DATA->m_pReport	=	new RCV_REPORT_STRUCTEx[packetsize];
		memset(pRCV_DATA->m_pReport, 0, sizeof(RCV_REPORT_STRUCTEx)*packetsize);

		CSPTime tLatest = CTSCache::GetInstance().GetLocalLatest();

		for(int i=0;i <packetsize; i++)
		{
			pRCV_DATA->m_pReport[i].m_cbSize = sizeof(RCV_REPORT_STRUCTEx);
			pRCV_DATA->m_pReport[i].m_time = CSPTime::GetTradeOffsetToTime(pdetail[i].m_offset, tLatest.GetTime());

			pRCV_DATA->m_pReport[i].m_wMarket = (stock.m_type & 0x20) ? SZ_MARKET_EX : SH_MARKET_EX;
			strncpy(pRCV_DATA->m_pReport[i].m_szLabel, stock.m_code,
					min(sizeof(pRCV_DATA->m_pReport[i].m_szLabel),sizeof(stock.m_code)));

			pRCV_DATA->m_pReport[i].m_fNewPrice	= (float)(0.001*pdetail[i].m_price);
			pRCV_DATA->m_pReport[i].m_fVolume		= (float)(0.01*pdetail[i].m_volume);
			pRCV_DATA->m_pReport[i].m_fAmount		= (float)(100.*pRCV_DATA->m_pReport[i].m_fVolume*pRCV_DATA->m_pReport[i].m_fNewPrice);

			pRCV_DATA->m_pReport[i].m_fBuyPrice[0]= (float)(0.001*pdetail[i].m_buy1);
			pRCV_DATA->m_pReport[i].m_fSellPrice[0]= (float)(0.001*pdetail[i].m_sell1);
		}

		return len;
	}

	return 0;
}

int TryGetBase(BYTE* buffer, size_t len, PRCV_DATA pRCV_DATA)
{
	if(len < sizeof(TW_ANS))
		return 0;

	TW_ANS * pans = (TW_ANS*)buffer;
	if(TW_MAGIC != pans->m_header.m_magic)
		return 0;
	if(0x05 != pans->m_tag1 || 0x0b != pans->m_tag2)
		return 0;
	TW_STOCK	stock;
	memset(&stock, 0, sizeof(stock));
	BOOL bStockOK = GetSerialStock(pans->m_serial, stock);

	// get it, fill pRCV_DATA
	size_t dataoffset = 45;
	int datalen = len - dataoffset;
	if(pRCV_DATA && bStockOK && datalen > 0)
	{
		memset(pRCV_DATA, 0, sizeof(RCV_DATA));
		pRCV_DATA->m_wDataType	=	FILE_BASE_EX;
		pRCV_DATA->m_nPacketNum	=	1;
		pRCV_DATA->m_bDISK		=	FALSE;

		pRCV_DATA->m_File.m_dwLen	=	datalen;
		strncpy(pRCV_DATA->m_File.m_szFileName, stock.m_code, min(sizeof(stock.m_code),sizeof(pRCV_DATA->m_File.m_szFileName)-1));
		if(strlen(pRCV_DATA->m_File.m_szFileName)+5 < sizeof(pRCV_DATA->m_File.m_szFileName))
			strcat(pRCV_DATA->m_File.m_szFileName, ".txt");
		pRCV_DATA->m_pData		=	new BYTE[datalen+1];
		memcpy(pRCV_DATA->m_pData, buffer + dataoffset, datalen);
		((char*)pRCV_DATA->m_pData)[datalen] = 0;
		return len;
	}

	return 0;
}