shppresponsestream.cpp

本源码为移动公司话费查询中间件TUXEDO使用的实例

/*******************************************
* file name:   SHPPResponseStream.h
* date:        2002.7.25
* 用途：       定义自助话打印协议SHPP写应答包格式
* 作者：       林游海
*******************************************/

#include "SHPPResponseStream.h"

CSHPPResponseStream::CSHPPResponseStream(CSHPPSocket* pSocket)
{
	m_pchStartPut = new char[PACKETBUFFER];
	memset(m_pchStartPut,'0',knPacketSize);

	m_pPrintField = new struct PrintFieldStruct[FIELDCOUNT];
	memset(m_pPrintField,0,(sizeof(struct PrintFieldStruct)*FIELDCOUNT));
	m_nFieldCount = 0;
	m_nFieldVal = 0;
	m_nRowSize = 0;
	memset(m_chPrintString,' ',2*PRINTMAXLEN);

	m_chPrintString[2*PRINTMAXLEN] = 0;

	m_pchCurrentPut = m_pchStartPut+knPacketSize;
	memset(m_pchCurrentPut,' ',2*PRINTMAXLEN);

	m_unBytesWritten = 0;    // 内存块已写了长度

	m_pSocket = pSocket;

	m_bWriteHead = false;
	m_nSeq = 0;
}

CSHPPResponseStream::~CSHPPResponseStream()
{
	delete [] m_pPrintField;
	delete [] m_pchStartPut;
}

void CSHPPResponseStream::PutServerType(UInt16 nServerType)
{
	SetField(m_pchStartPut + knType,nServerType,knTypeOffset);
}

void CSHPPResponseStream::PutResult(UInt16 nResult)
{
	SetField(m_pchStartPut + knResult,nResult,knResultOffset);
}

//增加一个参数
KN_Error CSHPPResponseStream::PutParameter(char* pPara,int nLen,Bool16 bRow)
{
	KN_Error knError = KN_OK;

	//包体太大，分包传
//	if((m_pchCurrentPut - m_pchStartPut + nLen + s_unEOLLen +1) > PACKETBUFFER)
	if((m_unBytesWritten + nLen + s_unEOLLen +1) > (PACKETBUFFER - knPacketSize))
	{
		WriteSHPPHead(0);
		knError = this->Flush();
		if(knError != KN_OK)
			return knError;
	}

	//包结果，发送包
	if(pPara == NULL)
	{
//		memcpy(m_pchCurrentPut,s_pchEOL,s_unEOLLen);
//		m_pchCurrentPut += 2;
//		m_unBytesWritten += 2;
//		WriteSHPPHead();
//		return this->Flush();
		return KN_OK;
	}

	memcpy(m_pchCurrentPut,pPara,nLen);
	m_pchCurrentPut += nLen;
	m_unBytesWritten += nLen;

	if(bRow)
	{
		memcpy(m_pchCurrentPut,s_pchEOL,s_unEOLLen);
		m_pchCurrentPut += 2;
		m_unBytesWritten += 2;
	}
	else 
	{
		m_pchCurrentPut[0] = '\t';
		m_pchCurrentPut += 1;
		m_unBytesWritten += 1;
	}

	return KN_OK;
}

KN_Error CSHPPResponseStream::PutParameter(char* pPara,Bool16 bRow)
{
	return PutParameter(pPara,strlen(pPara),bRow);
}

KN_Error CSHPPResponseStream::Flush()
{
	try{
		int nSend;
		WriteSHPPHead();

		nSend = m_pSocket->Write(this->m_pchStartPut,m_unBytesWritten + knPacketSize,sfTimeout);


		if(m_pchStartPut[knM] == '1')
		{
//			m_pSocket->SetReadBuf();
			m_pSocket->Cleanup();
			m_nSeq = 0;
		}
	}
#ifdef _DEBUG
	catch(CErrorMessage *e){

		char text[200];
		e->GetErrorMessage(text);

		m_pSocket->Cleanup();
		delete e;
		return KN_SocketError;
	}
#else
	catch(KN_Error error){
		m_pchStartPut[86] = 0;
		printf("flush error = %s\n",m_pchStartPut);
		m_pSocket->Cleanup();
		this->Reset();
		return error;
	}
#endif
	Reset();
	return KN_OK;
}

void CSHPPResponseStream::SetField(char* pHead,UInt32 nInParam,UInt16 nSize)
{
	char chType[10];
	UInt16 nLen,i;
	nLen = sprintf(chType,"%d",nInParam);

	if(nLen > nSize)
		return ;

	nLen = nSize - nLen;

	for(i = 0;i < nSize;i++)
	{
		if(i < nLen)
			pHead[i] = '0';
		else
			pHead[i] = chType[i - nLen];
	}

}

void CSHPPResponseStream::Reset(UInt32 inNumBytesToLeave)
{ 
	if(m_unBytesWritten == inNumBytesToLeave)
		return ;
	m_pchCurrentPut = m_pchStartPut + knPacketSize + inNumBytesToLeave;
	m_unBytesWritten = inNumBytesToLeave;
	m_bWriteHead = false;
	PutResult(0);
//	memset(m_pchStartPut,'0',knPacketSize);
}

void CSHPPResponseStream::WriteSHPPHead(UInt16 nM)
{
	if(!m_bWriteHead)
	{
		m_pchStartPut[0] = '1';
		m_pchStartPut[1] = '0';

		strcpy(m_pchCurrentPut,s_pchEOL);
		m_pchCurrentPut += s_unEOLLen;
		m_unBytesWritten += s_unEOLLen;//m_pchCurrentPut - m_pchStartPut - knPacketSize;

		SetField(m_pchStartPut + knLength,m_unBytesWritten,knLengthOffset);
		SetField(m_pchStartPut + knSeq,m_nSeq,knSeqOffset);

		m_pchStartPut[knM] = (char)(nM + '0');
//		if(m_pchStartPut[knM] == '1')

		m_nSeq++;
		m_bWriteHead = true;
	}
}

////////////处理打印字段////////////////

int CSHPPResponseStream::AddPrintField(int nMaxSize,char nStyle)
{
	int nPos;
	if(m_nFieldCount > 0)
	{
		nPos = m_pPrintField[m_nFieldCount-1].nPos + nMaxSize;
	}
	else
		nPos = nMaxSize;

	m_nRowSize += nMaxSize;
	m_pPrintField[m_nFieldCount].nPos = nPos;
	m_pPrintField[m_nFieldCount].nStyle = nStyle;

	m_nFieldCount++;
	return 0;
}

void CSHPPResponseStream::ResetField()
{
	m_nFieldCount = 0;
	m_nFieldVal   = 0;
	m_nRowSize    = 0;
}

void CSHPPResponseStream::AddFieldVal(char *pchVal,int nSize)
{
	int nPos;
	char *p;

	assert(nSize >= 0 && m_nRowSize > 0 && pchVal);

	if(nSize > 0)
	{
		p = m_chPrintString;
		if(m_nFieldVal == 0)
			nPos = 0;
		else
			nPos = m_pPrintField[m_nFieldVal-1].nPos;

		p += nPos;

		nPos = m_pPrintField[m_nFieldVal].nPos - nPos ;

		if(nPos < nSize)
		{
			int n;
			if(m_nFieldVal == 0)
				n = m_nRowSize;
			else
				n = m_nRowSize - m_pPrintField[m_nFieldVal-1].nPos;
			if(nSize > n)
				nSize = n;
			memcpy(m_chPrintString,pchVal,nSize);
			this->PutParameter(m_chPrintString,m_nRowSize);
			memset(m_chPrintString,' ',m_nRowSize);
		}
		else{

			nPos -= nSize;
			if(m_pPrintField[m_nFieldCount].nStyle == LPLCENTER)
			{
				p += nPos /2;
			}
			else if(m_pPrintField[m_nFieldVal].nStyle == LPLRIGHT)
			{
				p += nPos;
			}
			memcpy(p,pchVal,nSize);
		}
	}

	m_nFieldVal++;
	if(m_nFieldVal == m_nFieldCount)
	{
		this->PutParameter(m_chPrintString,m_nRowSize);
		memset(m_chPrintString,' ',m_nRowSize);
		m_nFieldVal = 0 ;
	}
}

void CSHPPResponseStream::PrintLine(char* pLine,char nStyle)
{
	int nPos = 0;
	char *pHead;

	if(nStyle == LPLLEFT)
	{
		this->PutParameter(pLine);
		return ;
	}

	if(m_nRowSize == 0)
		nPos = PRINTMAXLEN;
	else
		nPos = m_nRowSize;
	memset(m_chPrintString,' ',m_nRowSize);

	if(nStyle == LPLCENTER)
	{
		pHead = m_chPrintString + (nPos - strlen(pLine))/2;
	}
	else if(nStyle == LPLRIGHT)
	{
		pHead = m_chPrintString + (nPos - strlen(pLine));
	}
	strcpy(pHead,pLine);
	this->PutParameter(m_chPrintString);
	memset(m_chPrintString,' ',nPos);

}

void CSHPPResponseStream::PutSeparator()
{
	static char s_chSeparator[] = 
	{"------------------------------------------------"};
	this->PutParameter(s_chSeparator);

}

///////////////////////////////////////////////////