// DiosPacket.cpp : 定义 DLL 应用程序的导出函数。
//

#include "stdafx.h"
#include "crc64.h"
#include "DiosPacket.h"

template<class Type> void CopyStream(Type *pTarget,const char *pStr,size_t Size)
{
	char *pcTarget = (char *)pTarget;

	memcpy(pcTarget, pStr, Size);
}

bool SetObjectAttribute(char* pObject, size_t Size, DIOSKEYTYPE &key, bool &Flexible, bool &Object, unsigned long long &objsize)
{
	assert(0);//not finished yet

	return false;

}

bool GetKeyFlexble(unsigned char* pBuff, bool &Flexible, size_t &LengthSize, size_t &ContextSize)
{
	DIOSKEYST stKey;

	CopyStream(&stKey, (char *)pBuff, sizeof(DIOSKEYST));
	if (stKey.Flexble)
	{
		Flexible = true;
		LengthSize = 1;
		for (unsigned char i = 0; i < stKey.ValSize; i++)
		{
			LengthSize = LengthSize << 1;
		}


	}
	else
	{
		Flexible = false;
		ContextSize = 1;
		for (unsigned char i = 0; i < stKey.ValSize; i++)
		{
			ContextSize = ContextSize << 1;
		}

	}


	return true;
}

bool SetKeyFlexbleValue(unsigned char* pBuff, size_t &LengthSize, size_t &ContextSize)
{
	
	switch (LengthSize)
	{
		case 8:
		{
			//64bit
			long long Local = ContextSize;
			unsigned long long LocalLen = (unsigned long long)Local;
			memcpy(pBuff, &LocalLen, LengthSize);
		}
			break;
		case 4:
		{
			//32bit
			int Local = ContextSize;
			unsigned int LocalLen = Local;
			memcpy(pBuff, &LocalLen, LengthSize);
		}
			break;
		case 2:
		{
			//16bit
			short Local = ContextSize;
			unsigned short LocalLen = Local;
			memcpy(pBuff, &LocalLen, LengthSize);
		}
			break;
		case 1:
		{
			//8bit
			char Local = ContextSize;
			unsigned char LocalLen = Local;
			memcpy(pBuff, &LocalLen, LengthSize);
		}
			break;
		default:
			//其他都是浮云

			return false;
			break;
	}

	return true;
}

bool GetObjectAttribute(char* pObject, size_t Size, DIOSKEYTYPE &key, bool &Flexible, bool &Object, unsigned long long &objsize)
{
	assert(0);//not finished yet

	return false;
}

bool SetObjectContext(char* pObject, size_t Size, char* pContext, size_t ContextSize)
{
	assert(0);//not finished yet

	return false;

}

bool GetObjectContext(char* pData, size_t Size, DIOSKEYTYPE &key, bool &Flexible, char* &pContext, size_t &ContextSize)
{
	DIOSKEYST Key;

	//check the limit
	if (Size <= sizeof(DIOSKEYST) || pData == NULL)
	{
		return false;
	}

	size_t ObjSize = 0;

	CopyStream(&Key, pData, sizeof(DIOSKEYST));
	CopyStream(&key, pData, sizeof(DIOSKEYTYPE));
	if (Key.Flexble)
	{
		Flexible = true;
		ObjSize = 1;
		for (unsigned char i = 0; i < Key.ValSize; i++)
		{
			ObjSize = ObjSize << 1;
		}

		//check the limit
		if ((sizeof(DIOSKEYST)+ObjSize) > Size)
		{
			return false;
		}

		//get size
		switch (ObjSize)
		{
		case 8:
		{
				  //64bit
				  unsigned long long LocalLen = 0;
				  CopyStream(&LocalLen, &pData[sizeof(DIOSKEYST)], ObjSize);
				  ContextSize = (size_t)LocalLen;

		}
			break;
		case 4:
		{
				  //32bit
				  unsigned int LocalLen = 0;
				  CopyStream(&LocalLen, &pData[sizeof(DIOSKEYST)], ObjSize);
				  ContextSize = LocalLen;

		}
			break;
		case 2:
		{
				  //16bit
				  unsigned short LocalLen = 0;
				  CopyStream(&LocalLen, &pData[sizeof(DIOSKEYST)], ObjSize);
				  ContextSize = LocalLen;

		}
			break;
		case 1:
		{
				  //8bit
				  unsigned char LocalLen = 0;
				  CopyStream(&LocalLen, &pData[sizeof(DIOSKEYST)], ObjSize);
				  ContextSize = LocalLen;

		}
			break;
		default:
			//其他都是浮云

			return false;
			break;
		}

		//check data limit
		if ((sizeof(DIOSKEYST)+ObjSize + ContextSize) > Size)
		{
			return false;
		}

		//get address
		pContext = (char*)&pData[sizeof(DIOSKEYTYPE)+ObjSize];



	}
	else
	{
		Flexible = false;
		ContextSize = 1;
		for (unsigned char i = 0; i < Key.ValSize; i++)
		{
			ContextSize = ContextSize << 1;
		}

		pContext = (char*)(pData + sizeof(DIOSKEYST));

		//check data limit
		if ((sizeof(DIOSKEYTYPE)+ContextSize) > Size)
		{
			return false;
		}
	}


	return true;

}

bool CheckFirstLevelOfTheData(char* pData, size_t Size)
{
	DIOSKEYTYPE ObjectKey;
	bool Flexible;
	char *pObject;
	size_t ObjectSize;
	while (Size > 0)
	{

		if (GetObjectContext(pData, Size, ObjectKey, Flexible, pObject, ObjectSize))
		{
			//calculate jump size
			size_t jumpsize = (pObject - pData) + ObjectSize;
			if (Size > jumpsize)
			{
				pData += jumpsize;
				Size -= jumpsize;
				continue;
			}
			else if (Size == jumpsize)
			{
				//must be Size == jumpsize!!!!
				return true;
			}
			//else if (Size < jumpsize)

			return false;
		}
		else
		{
			return false;;
		}
	}

	return false;
}

//Raw packet Exption object-------------------------------------------------------------------begin

RawPacketObjectExption::RawPacketObjectExption(const char *pExp)
{
	m_ExpContext = new string;

	if(pExp)
	{
		(*m_ExpContext) = pExp;
	}
}

RawPacketObjectExption::RawPacketObjectExption(const RawPacketObjectExption &tValue)
{
	m_ExpContext = new string;

	(*m_ExpContext) = (*(tValue.m_ExpContext));

}

RawPacketObjectExption::~RawPacketObjectExption(void)
{
	delete m_ExpContext;
}

const char *RawPacketObjectExption::what()
{
	if(m_ExpContext->size() == 0)
	{
		(*m_ExpContext) = " ";
	}

	return m_ExpContext->c_str();
}

RawPacketObjectExption& RawPacketObjectExption::operator = (const RawPacketObjectExption &tValue)
{
	if (this != &tValue)
	{
		(*m_ExpContext) = (*(tValue.m_ExpContext));
	}

	return (*this);
}
//Raw packet Exption object-------------------------------------------------------------------end


//Raw packet object-------------------------------------------------------------------begin

//malloc internal
RawPacketObject::RawPacketObject(RawPacketObject *pParent)
{
	m_InternalMalloc = true;
	m_pInternalBuff = new vector<unsigned char>();

	m_BuffSize = 1024;
	m_pInternalBuff->resize(m_BuffSize);


	m_pPacketBuff = &((*m_pInternalBuff)[0]);
	m_PacketSize = 0;

	m_pParent = pParent;
	
	m_vec = new vector<RawPacketObject*>();

	m_HasKey = false;
}

//using outside memory
RawPacketObject::RawPacketObject(RawPacketObject *pParent,unsigned char *p, size_t packetsize, size_t buffsize)
{
	DIOSKEYTYPE Key;
	bool Flexible;
	char *pObject;
	size_t ObjectSize = 0;
	

	m_InternalMalloc = false;
//	m_pInternalBuff = NULL;

	m_pPacketBuff = p;
	m_BuffSize = buffsize;
	m_PacketSize = packetsize;

	m_pParent = pParent;

	m_vec = new vector<RawPacketObject*>();

	size_t TempSize = m_PacketSize;
	unsigned char * pTem = m_pPacketBuff;
	DIOSKEYST stKey;

	
	bool MultipleObjectExist = false;
	//判断多对象并排存在? MultipleObjectExist = true : false
	if (GetObjectContext((char *)pTem, TempSize, Key, Flexible, pObject, ObjectSize) == false)
	{
		m_pValue = NULL;
		m_HasKey = false;

		return;
	}

	m_pValue = (unsigned char *)pObject;
	
	m_HasKey = true;
	
	size_t jumpsize = ((unsigned char *)pObject - m_pPacketBuff) + ObjectSize;
	if (m_PacketSize > jumpsize)
	{
		MultipleObjectExist = true;
		m_HasKey = false;
	}
	
	if (MultipleObjectExist)
	{
		while(TempSize > 0)
		{
			GetObjectContext((char *)pTem, TempSize, Key, Flexible, pObject, ObjectSize);
			jumpsize = ((unsigned char *)pObject - pTem) + ObjectSize;

			RawPacketObject * subRPO = new RawPacketObject(this, (unsigned char *)pTem, jumpsize, jumpsize);
			(*m_vec).push_back(subRPO);
			
			pTem += jumpsize;
			TempSize -= jumpsize;
		}
	}
	else
	{
		CopyStream(&stKey, (char*)pTem, sizeof(DIOSKEYST));
		
		if (stKey.ObjFlag)
		{
			pTem = m_pValue;
			TempSize = ObjectSize;
			//loop context
			while(TempSize > 0)
			{
				GetObjectContext((char *)pTem, TempSize, Key, Flexible, pObject, ObjectSize);
				jumpsize = ((unsigned char *)pObject - pTem) + ObjectSize;
				
				RawPacketObject * subRPO = new RawPacketObject(this, pTem, jumpsize, jumpsize);
				(*m_vec).push_back(subRPO);
				
				pTem += jumpsize;
				TempSize -= jumpsize;
			}
		}
	}

}

RawPacketObject::~RawPacketObject()
{
	delet();
}

bool RawPacketObject::ReloadObject()
{
	DIOSKEYTYPE Key;
	bool Flexible;
	char *pObject;
	size_t ObjectSize = 0;
	

	m_vec = new vector<RawPacketObject*>();

	size_t TempSize = m_PacketSize;
	unsigned char * pTem = m_pPacketBuff;
	DIOSKEYST stKey;

	bool MultipleObjectExist = false;
	//判断多对象并排存在? MultipleObjectExist = true : false
	if (GetObjectContext((char *)pTem, TempSize, Key, Flexible, pObject, ObjectSize) == false)
	{
		m_pValue = NULL;
		m_HasKey = false;

		return false;
	}

	m_pValue = (unsigned char *)pObject;
	
	m_HasKey = true;
	
	size_t jumpsize = ((unsigned char *)pObject - m_pPacketBuff) + ObjectSize;
	if (m_PacketSize > jumpsize)
	{
		MultipleObjectExist = true;
		m_HasKey = false;
	}
	
	if (MultipleObjectExist)
	{
		while(TempSize > 0)
		{
			GetObjectContext((char *)pTem, TempSize, Key, Flexible, pObject, ObjectSize);
			jumpsize = ((unsigned char *)pObject - pTem) + ObjectSize;

			RawPacketObject * subRPO = new RawPacketObject(this, (unsigned char *)pTem, jumpsize, jumpsize);
			(*m_vec).push_back(subRPO);
			
			pTem += jumpsize;
			TempSize -= jumpsize;
		}
	}
	else
	{
		CopyStream(&stKey, (char*)pTem, sizeof(DIOSKEYST));
		
		if (stKey.ObjFlag)
		{
			pTem = m_pValue;
			TempSize = ObjectSize;
			//loop context
			while(TempSize > 0)
			{
				GetObjectContext((char *)pTem, TempSize, Key, Flexible, pObject, ObjectSize);
				jumpsize = ((unsigned char *)pObject - pTem) + ObjectSize;
				
				RawPacketObject * subRPO = new RawPacketObject(this, pTem, jumpsize, jumpsize);
				(*m_vec).push_back(subRPO);
				
				pTem += jumpsize;
				TempSize -= jumpsize;
			}
		}
	}

	return true;
}

void RawPacketObject::Reload(RawPacketObject *pParent, unsigned char *p, size_t packetsize, size_t buffsize)//重新构造对象树
{
	if(m_InternalMalloc)
	{
		Clear();
		
		m_pPacketBuff = p;
		m_BuffSize = buffsize;
		m_PacketSize = packetsize;
		m_pParent = pParent;

		ReloadObject();		
		
	}
	else
	{
		delet();
		
		m_pPacketBuff = p;
		m_BuffSize = buffsize;
		m_PacketSize = packetsize;
		m_pParent = pParent;
		
		ReloadObject();		
	}
}


//由底层对象call parent对象
void RawPacketObject::AddPacketSize(size_t addsize)
{
	m_PacketSize += addsize;
	
	if (m_pParent)
	{
		m_pParent->AddPacketSize(addsize);
	}
}

BOOL RawPacketObject::HasKey()
{
	return m_HasKey;
}

size_t RawPacketObject::sizeOfRaw()//raw数据的真实长度
{
	return m_PacketSize;
}

size_t RawPacketObject::sizeOfObject()//raw数据的真实长度
{
	return (*m_vec).size();
}

size_t RawPacketObject::sizeOfBuff()
{
	return m_BuffSize;
}

void RawPacketObject::Clear()
{
	m_pPacketBuff = NULL;
	m_BuffSize = 0;
	m_PacketSize = 0;

	if(m_vec != NULL)
	{
		for(size_t i = 0; i < (*m_vec).size(); i++)
		{
			delete (*m_vec)[i];
		}
		(*m_vec).clear();
		delete m_vec;
		m_vec = NULL;
	}

}

void RawPacketObject::delet()
{
	if (m_InternalMalloc)
	{
		if(m_pInternalBuff != NULL)
		{
			delete m_pInternalBuff;
			m_pInternalBuff = NULL;
		}
	}

	m_pPacketBuff = NULL;
	m_BuffSize = 0;
	m_PacketSize = 0;

	if(m_vec != NULL)
	{
		for(size_t i = 0; i < (*m_vec).size(); i++)
		{
			delete (*m_vec)[i];
		}
		(*m_vec).clear();
		delete m_vec;
		m_vec = NULL;
	}

}

void RawPacketObject::SetKey(DIOSKEYTYPE key)
{
	bool Flexible;
	size_t LengthSize = 0;
	size_t ContextSize = 0;
	
	if(m_PacketSize + sizeof(key) > m_BuffSize)
	{
		if(m_InternalMalloc)
		{
			ReloadInternalMalloc(sizeof(key));			
		}
		else
		{
			throw RawPacketObjectExption("Key size overflow ");
			return;
		}
	}

	memcpy(m_pPacketBuff,&key,sizeof(key));

	m_HasKey = true;
	
	GetKeyFlexble(m_pPacketBuff,Flexible,LengthSize,ContextSize);

	if(Flexible)
	{
		if(m_PacketSize + sizeof(key) + LengthSize > m_BuffSize)
		{
			if(m_InternalMalloc)
			{
				ReloadInternalMalloc(LengthSize);			
			}
			else
			{
				throw RawPacketObjectExption("Length size overflow ");
				return;
			}
		}
		memset(&(m_pPacketBuff[sizeof(key)]),0,m_BuffSize-sizeof(key));
		m_pValue = m_pPacketBuff + sizeof(key) + LengthSize;
	}
	else
	{
		if(m_PacketSize + ContextSize > m_BuffSize)
		{
			if(m_InternalMalloc)
			{
				ReloadInternalMalloc(ContextSize);			
			}
			else
			{
				throw RawPacketObjectExption("Value size overflow ");
				return;
			}
		}
		memset(&(m_pPacketBuff[sizeof(key)]),0,m_BuffSize-sizeof(key));
		m_pValue = m_pPacketBuff + sizeof(key);
	}
	AddPacketSize(m_pValue-m_pPacketBuff);
}

DIOSKEYTYPE RawPacketObject::GetKey()
{
	DIOSKEYTYPE key;

	memcpy(&key,m_pPacketBuff,sizeof(DIOSKEYTYPE));

	return key;
}

bool RawPacketObject::SetKeyLengthValue(size_t addSize)
{
	bool Flexible;
	size_t LengthSize = 0;
	size_t ContextSize = 0;
	unsigned char* pTempBuff;

	if(m_HasKey)//update Length zore value
	{
		GetKeyFlexble(m_pPacketBuff,Flexible,LengthSize,ContextSize);
		if(Flexible)
		{
			size_t LengthZoreValue = 0;
			pTempBuff = m_pPacketBuff + sizeof(DIOSKEYTYPE);	
			memcpy(&LengthZoreValue,pTempBuff,LengthSize);
			size_t TempSize = addSize + LengthZoreValue;
			SetKeyFlexbleValue(pTempBuff,LengthSize,TempSize);
			
		}
		//else
		//{
		//	DIOSKEYST Key;
		//	memcpy(&Key, m_pPacketBuff, sizeof(DIOSKEYST));

		//	if(Key.ValSize++ > 3)
		//	{
		//		throw RawPacketObjectExption("Length size overflow ");
		//		return false;			
		//	}
		//	else
		//	{
		//		memcpy(m_pPacketBuff, &Key, sizeof(DIOSKEYST)); 			
		//	}
		//	
		//}
	}
	
	return true;
}

void RawPacketObject::ReloadInternalMalloc(size_t sizeofadd)
{
	m_BuffSize += sizeofadd;

	m_pInternalBuff->resize(m_BuffSize);

	return;
}

bool RawPacketObject::add(DIOSKEYTYPE Key, bool tValue)
{
	return add_Template(Key, tValue);
}

bool RawPacketObject::add(DIOSKEYTYPE Key, char tValue)
{
	return add_Template(Key, tValue);
}

bool RawPacketObject::add(DIOSKEYTYPE Key, unsigned char tValue)
{
	return add_Template(Key, tValue);
}

bool RawPacketObject::add(DIOSKEYTYPE Key, short tValue)
{
	return add_Template(Key, tValue);
}

bool RawPacketObject::add(DIOSKEYTYPE Key, unsigned short tValue)
{
	return add_Template(Key, tValue);
}

bool RawPacketObject::add(DIOSKEYTYPE Key, int tValue)
{
	return add_Template(Key, tValue);
}

bool RawPacketObject::add(DIOSKEYTYPE Key, unsigned int tValue)
{
	return add_Template(Key, tValue);
}

bool RawPacketObject::add(DIOSKEYTYPE Key, long tValue)
{
	return add_Template(Key, tValue);
}

bool RawPacketObject::add(DIOSKEYTYPE Key, unsigned long tValue)
{
	return add_Template(Key, tValue);
}

bool RawPacketObject::add(DIOSKEYTYPE Key, long long tValue)
{
	return add_Template(Key, tValue);
}

bool RawPacketObject::add(DIOSKEYTYPE Key, unsigned long long tValue)
{
	return add_Template(Key, tValue);
}

bool RawPacketObject::add(DIOSKEYTYPE Key, float tValue)
{
	return add_Template(Key, tValue);
}

bool RawPacketObject::add(DIOSKEYTYPE Key, double tValue)
{
	return add_Template(Key, tValue);
}

bool RawPacketObject::add(DIOSKEYTYPE Key, const char* pValue,size_t size)
{
	unsigned char *pTempBuff;
	size_t addSize = 0;
	bool Flexible;
	size_t LengthSize = 0;
	size_t ContextSize = 0;

	if(m_PacketSize + sizeof(Key) + size > sizeOfBuff())
	{
		if(m_InternalMalloc)
		{
			ReloadInternalMalloc(sizeof(Key)+size);		
		}
		else
		{
			throw RawPacketObjectExption("add size overflow ");
			return false;
		}
	}

	if(m_HasKey)
	{
		GetKeyFlexble(m_pPacketBuff,Flexible,LengthSize,ContextSize);
		if(!Flexible)
		{
			throw RawPacketObjectExption("fixed length can not use add function!");
			return false;
		}
	}

	
	pTempBuff = &(m_pPacketBuff[m_PacketSize]); 	
	memcpy(pTempBuff,&Key,sizeof(Key));
	
	GetKeyFlexble(pTempBuff,Flexible,LengthSize,ContextSize);

	if(Flexible)
	{
		addSize = sizeof(Key) + LengthSize + size;

		if(m_PacketSize + addSize > sizeOfBuff())
		{
			if(m_InternalMalloc)
			{
				ReloadInternalMalloc(LengthSize); 	
			}
			else
			{
				throw RawPacketObjectExption("Length size overflow ");
				return false;
			}
		}
		
		pTempBuff += sizeof(Key);	
		SetKeyFlexbleValue(pTempBuff,LengthSize,size);
	
		pTempBuff += LengthSize;		
		memcpy(pTempBuff,pValue,size);
	}
	else
	{
		addSize = sizeof(Key) + ContextSize;

		pTempBuff += sizeof(Key);	
		memcpy(pTempBuff,pValue,ContextSize);		
	}
	
	if(!SetKeyLengthValue(addSize))
	{
		throw RawPacketObjectExption("update Length zore value error!");
		return false;
	}
	
	RawPacketObject * subRPO = new RawPacketObject(this, (unsigned char *)&(m_pPacketBuff[m_PacketSize]), addSize, addSize);
	(*m_vec).push_back(subRPO);

	AddPacketSize(addSize);
	
	return true;
	
}

bool RawPacketObject::add(RawPacketObject &dataobj)
{
	if(&dataobj == this)
	{
		return false;
	}

	bool Flexible;
	size_t LengthSize = 0;
	size_t ContextSize = 0;
	if(m_HasKey)
	{
		GetKeyFlexble(m_pPacketBuff,Flexible,LengthSize,ContextSize);
		if(!Flexible)
		{
			throw RawPacketObjectExption("fixed length can not use add function!");
			return false;
		}
	}
	
	if(m_PacketSize + dataobj.sizeOfRaw() > sizeOfBuff())
	{
		if(m_InternalMalloc)
		{
			ReloadInternalMalloc(dataobj.sizeOfRaw());
		}
		else
		{
			throw RawPacketObjectExption("add size overflow ");
			return false;
		}
	}
	
	if(m_HasKey)
	{
		if(!SetKeyLengthValue(dataobj.sizeOfRaw()))
		{
			throw RawPacketObjectExption("update Length zore value error!");
			return false;
		}
	}
	
	memcpy(&(m_pPacketBuff[m_PacketSize]),dataobj.m_pPacketBuff,dataobj.sizeOfRaw());
	
	unsigned char * p = &(m_pPacketBuff[m_PacketSize]);
	size_t packetsize = dataobj.sizeOfRaw();
	size_t buffsize = dataobj.sizeOfRaw();

	RawPacketObject * addobj = new RawPacketObject(this, p, packetsize, buffsize);
	(*m_vec).push_back(addobj);
	
	AddPacketSize(packetsize);
	
	return true;
}

RawPacketObject& RawPacketObject::operator = (const RawPacketObject &tValue)
{
	if(&tValue == this)
	{
		return (*this);
	}

	if(m_BuffSize < tValue.m_PacketSize)
	{
		if(m_InternalMalloc)
		{	
			ReloadInternalMalloc(tValue.m_PacketSize - m_BuffSize);
		}
		else
		{
			throw RawPacketObjectExption("new obj's BuffSize too long!");
		}
	}
	
	unsigned char * p = (unsigned char *)tValue.m_pPacketBuff;
	size_t size = tValue.m_PacketSize;
	memcpy(m_pPacketBuff,p,size);
	
	RawPacketObject * pParent = tValue.m_pParent;

	Reload(pParent, m_pPacketBuff, tValue.m_PacketSize, tValue.m_BuffSize);
	
	return (*this);
}	

RawPacketObject& RawPacketObject::operator = (const bool tValue)
{
	char temp,*pF ;

	assert(sizeof(bool) == sizeof(char));
	
	pF = (char*)&tValue;
	temp = (*pF);
	
	SignedAssignmentProcess(temp);

	return (*this);
}

RawPacketObject& RawPacketObject::operator = (const char tValue)
{
	char temp,*pF ;
	
	pF = (char*)&tValue;
	temp = (*pF);
	
	SignedAssignmentProcess(temp);

	return (*this);
}

RawPacketObject& RawPacketObject::operator = (const unsigned char tValue)
{
	unsigned char temp,*pF ;
	
	pF = (unsigned char*)&tValue;
	temp = (*pF);
	
	UnSignedAssignmentProcess(temp);

	return (*this);
}

RawPacketObject& RawPacketObject::operator = (const short tValue)
{
	short temp,*pF ;
	
	pF = (short*)&tValue;
	temp = (*pF);
	
	SignedAssignmentProcess(temp);

	return (*this);
}

RawPacketObject& RawPacketObject::operator = (const unsigned short tValue)
{
	unsigned short temp,*pF ;
	pF = (unsigned short*)&tValue;
	temp = (*pF);
	
	UnSignedAssignmentProcess(temp);

	return (*this);
}

RawPacketObject& RawPacketObject::operator = (const int tValue)
{
	int temp,*pF ;
	
	pF = (int*)&tValue;
	temp = (*pF);
	
	SignedAssignmentProcess(temp);

	return (*this);
}

RawPacketObject& RawPacketObject::operator = (const unsigned int tValue)
{
	unsigned int temp,*pF ;
	pF = (unsigned int*)&tValue;
	temp = (*pF);
	
	UnSignedAssignmentProcess(temp);

	return (*this);
}

RawPacketObject& RawPacketObject::operator = (const long tValue)
{
	long temp,*pF ;
	
	pF = (long*)&tValue;
	temp = (*pF);
	
	SignedAssignmentProcess(temp);

	return (*this);
}

RawPacketObject& RawPacketObject::operator = (const unsigned long tValue)
{
	unsigned long temp,*pF ;
	pF = (unsigned long*)&tValue;
	temp = (*pF);
	
	UnSignedAssignmentProcess(temp);

	return (*this);
}

RawPacketObject& RawPacketObject::operator = (const long long tValue)
{
	long long temp,*pF ;
	
	pF = (long long*)&tValue;
	temp = (*pF);
	
	SignedAssignmentProcess(temp);

	return (*this);
}

RawPacketObject& RawPacketObject::operator = (const unsigned long long tValue)
{
	unsigned long long temp,*pF ;
	pF = (unsigned long long*)&tValue;
	temp = (*pF);
	
	UnSignedAssignmentProcess(temp);

	return (*this);
}

RawPacketObject& RawPacketObject::operator = (const float tValue)
{
	float temp,*pF ;
	
	pF = (float*)&tValue;
	temp = (*pF);
	
	SignedAssignmentProcess(temp);

	return (*this);
}

RawPacketObject& RawPacketObject::operator = (const double tValue)
{
	double temp,*pF ;
	
	pF = (double*)&tValue;
	temp = (*pF);
	
	SignedAssignmentProcess(temp);

	return (*this);
}

bool RawPacketObject::operator== (const RawPacketObject& ar) const
{
	if(m_PacketSize != ar.m_PacketSize)
	{
		return false;
	}

	if (0 == memcmp(m_pPacketBuff, ar.m_pPacketBuff, m_PacketSize))
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool RawPacketObject::update(const char* pValue, size_t size)
{
	bool Flexible;
	size_t LengthSize = 0;
	size_t ContextSize = 0;

	if(m_HasKey)
	{
		GetKeyFlexble(m_pPacketBuff,Flexible,LengthSize,ContextSize);

		if(Flexible)
		{
			if(sizeof(DIOSKEYTYPE)+LengthSize+size > sizeOfBuff())
			{	
				throw RawPacketObjectExption("update size overflow ");
				return false;
			}

			memcpy(m_pValue,pValue,size);
			
			//set the length value
			SetKeyFlexbleValue(&(m_pPacketBuff[sizeof(DIOSKEYTYPE)]), LengthSize, size);
			m_PacketSize = sizeof(DIOSKEYTYPE)+LengthSize+size;
		}
		else
		{
			if(sizeof(DIOSKEYTYPE)+size > sizeOfBuff())
			{	
				throw RawPacketObjectExption("update size overflow ");
				return false;
			}

			memcpy(m_pValue,pValue,ContextSize);
			
			m_PacketSize = sizeof(DIOSKEYTYPE)+size;
		}
	}
	else
	{
		throw RawPacketObjectExption("Do not have key, can not update value");
		return false;
	}
	
	return true;
}

RawPacketObject &RawPacketObject::operator [](size_t idx)
{
	if(sizeOfObject() <= idx)
	{
		throw RawPacketObjectExption("overflow of Idx Of []");
		return (*this);
	}
	return *((*m_vec)[idx]);
}

RawPacketObject &RawPacketObject::operator [](int idx)
{
	if(idx < 0)
	{
		throw RawPacketObjectExption("using minus idx to operate []");
		return (*this);
	}
	return *((*m_vec)[idx]);
}

RawPacketObject &RawPacketObject::operator [](DIOSKEYTYPE Key)
{

	if(Key == NULL)
	{
		throw RawPacketObjectExption("the operator [\"\"] param is NULL");
		return (*this);
	}
	DIOSKEYTYPE keyname;

	for(size_t i = 0;i < (*m_vec).size();i++)
	{
		memcpy(&keyname, (((*m_vec)[i])->m_pPacketBuff), sizeof(DIOSKEYTYPE));
		if(keyname == Key)
		{
			return  *((*m_vec)[i]);
		}
	}

	//none matches...
	string expcontent = "none matches the operator param";
	throw RawPacketObjectExption(expcontent.c_str());

	return (*this);

};

bool RawPacketObject::IsObject()
{
	if((*m_vec).size() == 0)
	{
		return false;
	}

	return true;
}

RawPacketObject::operator bool()
{
	if(IsObject())
	{
		throw RawPacketObjectExption("try to convert a object");
	}

	bool ret1;

	if (m_HasKey)
	{
		bool Flexible;
		size_t LengthSize = 0;
		size_t ContextSize = 0;

		GetKeyFlexble(m_pPacketBuff, Flexible, LengthSize, ContextSize);
		if (Flexible)
		{
			throw RawPacketObjectExption("Flexible length can not use = function!");
			return false;
		}
		else
		{
			switch (ContextSize)
			{
			case 8:
			{
					  //64bit
					  unsigned long long LocalLen;
					  memcpy(&LocalLen, m_pValue, sizeof(unsigned long long));
					  if (LocalLen > 0)
					  {
						  ret1 = true;
					  }
					  else
					  {
						  ret1 = false;
					  }

					  break;
			}
			case 4:
			{
					  //32bit
					  unsigned int LocalLen;
					  memcpy(&LocalLen, m_pValue, sizeof(unsigned int));
					  if (LocalLen > 0)
					  {
						  ret1 = true;
					  }
					  else
					  {
						  ret1 = false;
					  }

					  break;
			}
			case 2:
			{
					  //16bit
					  unsigned short LocalLen;
					  memcpy(&LocalLen, m_pValue, sizeof(unsigned short));
					  if (LocalLen > 0)
					  {
						  ret1 = true;
					  }
					  else
					  {
						  ret1 = false;
					  }

					  break;
			}
			case 1:
			{
					  //8bit
					  unsigned char LocalLen;
					  memcpy(&LocalLen, m_pValue, sizeof(unsigned char));
					  if (LocalLen > 0)
					  {
						  ret1 = true;
					  }
					  else
					  {
						  ret1 = false;
					  }

					  break;
			}
			default:
				throw RawPacketObjectExption("ContextSize error!");
				break;
			}
		}
	}
	else
	{
		throw RawPacketObjectExption("Do not have key, can not get value");
	}

	return ret1;
}

RawPacketObject::operator char()
{
	if(IsObject())
	{
		throw RawPacketObjectExption("try to convert a object");
	}
	
	char ret1;
	
	ReadSignedValueByType(ret1);

	return ret1;
}

RawPacketObject::operator unsigned char()
{
	if(IsObject())
	{
		throw RawPacketObjectExption("try to convert a object");
	}
	
	unsigned char ret1;
	
	ReadUnSignedValueByType(ret1);

	return ret1;
}

RawPacketObject::operator short()
{
	if(IsObject())
	{
		throw RawPacketObjectExption("try to convert a object");
	}
	
	short ret1;
	
	ReadSignedValueByType(ret1);

	return ret1;
}

RawPacketObject::operator unsigned short()
{
	if(IsObject())
	{
		throw RawPacketObjectExption("try to convert a object");
	}
	
	unsigned short ret1;
	
	ReadUnSignedValueByType(ret1);

	return ret1;
}

RawPacketObject::operator int()
{
	if(IsObject())
	{
		throw RawPacketObjectExption("try to convert a object");
	}
	
	int ret1;
	
	ReadSignedValueByType(ret1);

	return ret1;
}

RawPacketObject::operator unsigned int()
{
	if(IsObject())
	{
		throw RawPacketObjectExption("try to convert a object");
	}
	
	unsigned int ret1;
	
	ReadUnSignedValueByType(ret1);

	return ret1;
}

RawPacketObject::operator long()
{
	if(IsObject())
	{
		throw RawPacketObjectExption("try to convert a object");
	}
	
	long ret1;
	
	ReadSignedValueByType(ret1);

	return ret1;
}

RawPacketObject::operator unsigned long()
{
	if(IsObject())
	{
		throw RawPacketObjectExption("try to convert a object");
	}
	
	unsigned long ret1;
	
	ReadUnSignedValueByType(ret1);

	return ret1;
}


RawPacketObject::operator long long()
{
	if(IsObject())
	{
		throw RawPacketObjectExption("try to convert a object");
	}
		
	long long ret1;
	
	ReadSignedValueByType(ret1);

	return ret1;
}

RawPacketObject::operator unsigned long long()
{
	if(IsObject())
	{
		throw RawPacketObjectExption("try to convert a object");
	}
	
	unsigned long long ret1;
	
	ReadUnSignedValueByType(ret1);

	return ret1;
}

RawPacketObject::operator float()
{
	if (IsObject())
	{
		throw RawPacketObjectExption("try to convert a object");
	}
			
	float ret1;
	
	ReadSignedValueByType(ret1);

	return ret1;
}

RawPacketObject::operator double()
{
	if(IsObject())
	{
		throw RawPacketObjectExption("try to convert a object");
	}

	double ret1;
	
	ReadSignedValueByType(ret1);

	return ret1;
}

RawPacketObject::operator const char*()
{
	return (char*)m_pValue;
};



//Raw packet object-------------------------------------------------------------------end

//Dios Packet
DiosPacket::DiosPacket()
{
	m_bReady = false;

	m_LenzoneSize = 4;
	m_CrcEffective = false;
	m_Direction = 0;//req
	m_FreezeLenzone = 1;//01:freeze

	m_pDataObj = NULL;


}

DiosPacket::DiosPacket(char* pData, size_t Length) : SCFPacket(pData, Length)
{
	m_pDataObj = NULL;
	UpdateLastEnv();
}

DiosPacket::~DiosPacket()
{
	if (m_pDataObj)
	{
		delete m_pDataObj;
	}
}

bool DiosPacket::UpdateLastEnv()
{
	bool res = true;
	unsigned int Lenzonesize = 0;
	if (GetLenZoneSize(Lenzonesize) == false)
	{
		res = false;
	}

	bool Effective = false;
	if (res == true && GetDataCrcEffectiveFlag(Effective) == false)
	{
		res = false;
	}

	unsigned int Direction = 0;
	if (res == true && GetTargetDirection(Direction) == false)
	{
		res = false;
	}

	unsigned int FreezeLenzone = 0;
	if (res == true && GetFreezeLenZoneFlag(FreezeLenzone) == false)
	{
		res = false;
	}

	if (res)
	{
		m_bReady = true;

		m_CrcEffective = Effective;
		m_Direction = Direction;
		m_LenzoneSize = Lenzonesize;
		m_FreezeLenzone = FreezeLenzone;
	}
	else
	{
		m_bReady = false;
	}

	return res;
}

bool DiosPacket::GetPhyDevIdx(PHYIDXTYPE &PhyDevIdx)
{
	bool ret = false;
	//if (m_bReady)
	{
		PhyDevIdx = m_PacketBuff[DP_PHYIDX_OFFSET];
		ret = true;
	}

	return ret;
}

bool DiosPacket::SetPhyDevIdx(PHYIDXTYPE PhyDevIdx)
{
	bool ret = false;
	if (m_bReady == false)
	{
		m_PacketBuff[DP_PHYIDX_OFFSET] = PhyDevIdx;
		ret = true;
	}

	return ret;
}

//LogicIdx(1Byte)
bool DiosPacket::GetLogicDevIdx(LOGICIDXTYPE &LogicDevIdx)
{
	bool ret = false;
	//if (m_bReady)
	{
		LogicDevIdx = m_PacketBuff[DP_LOGICIDX_OFFSET];
		ret = true;
	}

	return ret;

}

bool DiosPacket::SetLogicDevIdx(LOGICIDXTYPE LogicDevIdx)
{
	bool ret = false;
	if (m_bReady == false)
	{
		m_PacketBuff[DP_LOGICIDX_OFFSET] = LogicDevIdx;
		ret = true;
	}

	return ret;

}

bool DiosPacket::GetDataCrcEffectiveFlag(bool &Effective)
{
	bool ret = false;
	//if (m_bReady)
	{
		DIOSPACKETFLAG Dst = { 0 };
		CopyStream(&Dst, &m_PacketBuff[DP_FLAG_OFFSET], 1);

		Effective = Dst.CrcEffective;

		ret = true;
	}

	return ret;

}

bool DiosPacket::SetDataCrcEffectiveFlag(bool Effective)
{
	bool ret = false;

	if (m_bReady == false)
	{
		DIOSPACKETFLAG Dst = { 0 };
		CopyStream(&Dst, &m_PacketBuff[DP_FLAG_OFFSET], 1);

		Dst.CrcEffective = Effective;
		CopyStream(&m_PacketBuff[DP_FLAG_OFFSET], (const char*)&Dst, 1);

		ret = true;
	}

	return ret;


}


//targetdirection:2bit (00:REQ,01:RES,10:NOTIFY)
bool DiosPacket::GetTargetDirection(unsigned int &Direction)
{
	bool ret = false;
	//if (m_bReady)
	{
		DIOSPACKETFLAG Dst = { 0 };
		CopyStream(&Dst, &m_PacketBuff[DP_FLAG_OFFSET], 1);

		Direction = Dst.PackDirection;

		ret = true;
	}

	return ret;


}

bool DiosPacket::SetTargetDirection(unsigned int Direction)
{
	bool ret = false;
	if (Direction > 2)
	{
		return ret;
	}

	if (m_bReady == false)
	{
		DIOSPACKETFLAG Dst = { 0 };
		CopyStream(&Dst, &m_PacketBuff[DP_FLAG_OFFSET], 1);

		Dst.PackDirection = Direction;
		CopyStream(&m_PacketBuff[DP_FLAG_OFFSET], (const char*)&Dst, 1);

		ret = true;
	}

	return ret;

}

//dataLenArea Flag:2bit (01 means dataLen Area is not flexible)
bool DiosPacket::GetFreezeLenZoneFlag(unsigned int &FreezeFlag)
{
	bool ret = false;
	//if (m_bReady)
	{
		DIOSPACKETFLAG Dst = { 0 };
		CopyStream(&Dst, &m_PacketBuff[DP_FLAG_OFFSET], 1);

		FreezeFlag = Dst.FreezeOfLenZone;

		ret = true;
	}

	return ret;
}

bool DiosPacket::SetFreezeLenZoneFlag(unsigned int FreezeFlag)
{
	bool ret = false;

	if (m_bReady == false)
	{
		DIOSPACKETFLAG Dst = { 0 };
		CopyStream(&Dst, &m_PacketBuff[DP_FLAG_OFFSET], 1);

		Dst.FreezeOfLenZone = FreezeFlag;
		CopyStream(&m_PacketBuff[DP_FLAG_OFFSET], (const char*)&Dst, 1);

		ret = true;
	}

	return ret;
}

//LenzoneSize returns how many bytes that the zone used
//dataLenAreaSize:3bit (DataLenArea's size depends on this value. )
bool DiosPacket::GetLenZoneSize(unsigned int &LenzoneSize)
{
	bool ret = false;
	//if (m_bReady)
	{
		DIOSPACKETFLAG Dst = { 0 };
		CopyStream(&Dst, &m_PacketBuff[DP_FLAG_OFFSET], 1);

		// 111b
		if (Dst.SizeOfLenZon == 7)
		{
			LenzoneSize = 0;//no Lenzone
		}
		else
		{
			LenzoneSize = 1;
			for (unsigned int i = 0; i < Dst.SizeOfLenZon; i++)
			{
				LenzoneSize = LenzoneSize << 1;
			}
		}

		ret = true;
	}

	return ret;
}

//LenzoneSize sets the bytes that the zone needed
//it must be one of those values.0,1,2,4,8,16,32,64
//not support 16,32,64 for now.until we have the cpu support
bool DiosPacket::SetLenZoneSize(unsigned int LenzoneSize)
{
	bool ret = false;

	if (LenzoneSize > 64)
	{
		return ret;
	}

	if (m_bReady == false)
	{
		DIOSPACKETFLAG Dst = { 0 };
		CopyStream(&Dst, &m_PacketBuff[DP_FLAG_OFFSET], 1);

		switch (LenzoneSize)
		{
		case 0:
			Dst.SizeOfLenZon = 7;
			break;
		case 1:
			Dst.SizeOfLenZon = 0;
			break;
		case 2:
			Dst.SizeOfLenZon = 1;
			break;
		case 4:
			Dst.SizeOfLenZon = 2;
			break;
		case 8:
			Dst.SizeOfLenZon = 3;
			break;
		//case 16:
		//	Dst.SizeOfLenZon = 4;
		//	break;
		//case 32:
		//	Dst.SizeOfLenZon = 5;
		//	break;
		//case 64:
		//	Dst.SizeOfLenZon = 6;
		//	break;
		default:
			return false;
			break;
		}

		CopyStream(&m_PacketBuff[DP_FLAG_OFFSET], (const char*)&Dst, 1);
		m_LenzoneSize = LenzoneSize;
		ret = true;
	}

	return ret;
}

//command(1Byte)
bool DiosPacket::GetCommand(DIOSCMDTYPE &Cmd)
{
	bool ret = false;
	//if (m_bReady)
	{
		Cmd = m_PacketBuff[DP_CMD_OFFSET];
		ret = true;
	}

	return ret;

}

bool DiosPacket::SetCommand(DIOSCMDTYPE Cmd)
{
	bool ret = false;
	if (m_bReady == false)
	{
		m_PacketBuff[DP_CMD_OFFSET] = Cmd;
		ret = true;
	}

	return ret;

}

bool DiosPacket::GetRetcode(char &Ret)
{
	bool ret = false;
	//if (m_bReady)
	{
		Ret = m_PacketBuff[DP_RET_OFFSET];
		ret = true;
	}

	return ret;

}

bool DiosPacket::SetRetcode(char Ret)
{
	bool ret = false;
	if (m_bReady == false)
	{
		m_PacketBuff[DP_RET_OFFSET] = Ret;
		ret = true;
	}

	return ret;

}


//DataLenArea(the size of DataLenArea is determined by DataLenAreaSize.The DataLenArea's size is 2^n(n = .111b means no DataLenArea))
bool DiosPacket::GetDataLen(unsigned long long &Len)
{
	bool ret = false;
	//if (m_bReady)
	{
		unsigned int LenzoneSize = 0;
		if (GetLenZoneSize(LenzoneSize))
		{
			switch (LenzoneSize)
			{
			case 8:
			{
					  //64bit
					  CopyStream(&Len, &m_PacketBuff[DP_PARAMLEN_OFFSET], sizeof(Len));
					  ret = true;

			}
				break;
			case 4:
			{
					  //32bit
					  unsigned int LocalLen = 0;
					  CopyStream(&LocalLen, &m_PacketBuff[DP_PARAMLEN_OFFSET], sizeof(LocalLen));
					  Len = LocalLen;
					  ret = true;
			}
				break;
			case 2:
			{
					  //16bit
					  unsigned short LocalLen = 0;
					  CopyStream(&LocalLen, &m_PacketBuff[DP_PARAMLEN_OFFSET], sizeof(LocalLen));
					  Len = LocalLen;
					  ret = true;
			}
				break;
			case 1:
			{
					  //8bit
					  unsigned char LocalLen = 0;
					  CopyStream(&LocalLen, &m_PacketBuff[DP_PARAMLEN_OFFSET], sizeof(LocalLen));
					  Len = LocalLen;
					  ret = true;

			}
				break;
			default:
				//零和大于8字节的一律无视
				break;
			}
		}
	}

	return ret;

}

bool DiosPacket::SetDataLen(unsigned long long Len)
{
	bool ret = false;
	if (m_bReady == false)
	{
		unsigned int LenzoneSize = 0;
		if (GetLenZoneSize(LenzoneSize))
		{
			switch (LenzoneSize)
			{
			case 8:
			{
					  //64bit
					  CopyStream(&m_PacketBuff[DP_PARAMLEN_OFFSET], (const char*)&Len, sizeof(Len));
					  ret = true;

			}
				break;
			case 4:
			{
					  //32bit
					  unsigned int LocalLen = (unsigned int)Len;
					  CopyStream(&m_PacketBuff[DP_PARAMLEN_OFFSET], (const char*)&LocalLen, sizeof(LocalLen));
					  ret = true;

			}
				break;
			case 2:
			{
					  //16bit
					  unsigned short LocalLen = (unsigned short)Len;
					  CopyStream(&m_PacketBuff[DP_PARAMLEN_OFFSET], (const char*)&LocalLen, sizeof(LocalLen));
					  ret = true;

			}
				break;
			case 1:
			{
					  //8bit
					  unsigned char LocalLen = (unsigned char)Len;
					  CopyStream(&m_PacketBuff[DP_PARAMLEN_OFFSET], (const char*)&LocalLen, sizeof(LocalLen));
					  ret = true;

			}
				break;
			default:
				//零和大于8字节的一律无视
				break;
			}
		}
	}

	return ret;
}

//Head's Crc16
bool DiosPacket::GetHeadsCrc(unsigned short &headCrc16)
{
	bool ret = false;
	//if (m_bReady)
	{
		unsigned int LenzoneSize = 0;
		if (GetLenZoneSize(LenzoneSize))
		{
			CopyStream(&headCrc16, &m_PacketBuff[DP_PARAMLEN_OFFSET + LenzoneSize], sizeof(headCrc16));
			ret = true;
		}
	}

	return ret;
}

bool DiosPacket::SetHeadsCrc(unsigned short headCrc16)
{
	bool ret = false;
	if (m_bReady == false)
	{
		unsigned int LenzoneSize = 0;
		if (GetLenZoneSize(LenzoneSize))
		{
			CopyStream(&m_PacketBuff[DP_PARAMLEN_OFFSET + LenzoneSize], (const char*)& headCrc16, sizeof(headCrc16));
			ret = true;
		}
	}

	return ret;

}

//dataArea
char* DiosPacket::GetData()
{
	unsigned int LenzoneSize = 0;
	if (GetLenZoneSize(LenzoneSize))
	{
		size_t HeadSize = GetHeadSize();
		return &m_PacketBuff[HeadSize];
	}

	return NULL;
}

size_t DiosPacket::GetHeadSize()
{
	size_t Size = 0;
	unsigned int LenzoneSize = 0;
	if (GetLenZoneSize(LenzoneSize))
	{
		Size = DP_PARAMLEN_OFFSET + LenzoneSize + DP_CRC16_SIZE;
	}
	
	return Size;
}

//update LenArea too...
bool DiosPacket::SetData(const char *pData, size_t dataLen)
{
	size_t HeadSize = GetHeadSize();
	if (HeadSize > 0)
	{
		unsigned long long PacketSize = (HeadSize + dataLen + DP_CRC16_SIZE);
		//check the packet buffer
		if (GetBuffLen() < PacketSize)
		{
			//bufflen not enough
			if (SetBuffLen(PacketSize) == false)
			{
				//mem allocation failed
				return false;
			}
		}

		//copy data
		memcpy(&m_PacketBuff[HeadSize], pData, dataLen);

		//update lenzone
		PacketSize = (unsigned long long)dataLen;
		return SetDataLen(PacketSize);

	}

	return false;

}

//update LenArea too...
bool DiosPacket::AddData(const char *pData, size_t dataLen)
{
	size_t HeadSize = GetHeadSize();
	if (HeadSize > 0)
	{
		//exist lenzone
		unsigned long long DataSize = 0;
		if (GetDataLen(DataSize))
		{
			//
			unsigned long long PacketSize = (HeadSize + DataSize + dataLen + DP_CRC16_SIZE);
			//check the packet buffer
			if (GetBuffLen() < PacketSize)
			{
				//bufflen not enough
				if (SetBuffLen(PacketSize) == false)
				{
					//mem allocation failed
					return false;
				}
			}

			//copy data
			unsigned long long CopyPosition = HeadSize + DataSize;
			memcpy(&m_PacketBuff[CopyPosition], pData, dataLen);

			DataSize += dataLen;
			//update lenzone
			return SetDataLen(DataSize);


		}
	}

	return false;
}


//dataArea Crc16
bool DiosPacket::GetDataCrc(unsigned short &dataCrc16)
{
	bool ret = false;
	size_t HeadSize = GetHeadSize();
	if (HeadSize > 0)
	{
		unsigned long long DataSize = 0;
		if (GetDataLen(DataSize))
		{
			unsigned long long CrcPosition = HeadSize + DataSize;
			CopyStream((const char*)&dataCrc16, &m_PacketBuff[CrcPosition], sizeof(dataCrc16));

			ret = true;
		}
	}

	return ret;
}

bool DiosPacket::SetDataCrc(unsigned short dataCrc16)
{
	bool ret = false;
	size_t HeadSize = GetHeadSize();
	if (HeadSize > 0)
	{
		unsigned long long DataSize = 0;
		if (GetDataLen(DataSize))
		{
			unsigned long long CrcPosition = HeadSize + DataSize;
			CopyStream(&m_PacketBuff[CrcPosition], (const char*)&dataCrc16, sizeof(dataCrc16));

			ret = true;
		}
	}

	return ret;

}


//prepare

//init packet 
bool DiosPacket::InitPacket()
{
	m_bReady = false;

	//head
	m_PacketBuff[DP_HEAD_OFFSET] = (char)DP_HEAD;
	//Ver
	m_PacketBuff[DP_VER_OFFSET] = (char)0x01;
	//target phy&logic
	char Idx = 0;
	if (SetPhyDevIdx(Idx) == false)
	{
		return false;
	}
	
	if (SetLogicDevIdx(Idx) == false)
	{
		return false;
	}

	//update flags
	if (SetDataCrcEffectiveFlag(m_CrcEffective) == false)
	{
		return false;
	}

	if (SetTargetDirection(m_Direction) == false)
	{
		return false;
	}

	if (SetFreezeLenZoneFlag(m_FreezeLenzone) == false)
	{
		return false;
	}

	if (SetLenZoneSize(m_LenzoneSize) == false)
	{
		return false;
	}

	if (SetRetcode(0) == false)
	{
		return false;
	}

	unsigned long long DataLen = 0;
	SetDataLen(DataLen);


	return true;
}

unsigned long long DiosPacket::GetDiosPacketSize()
{
	unsigned long long TotalPacketSize = 0;
	size_t HeadSize = GetHeadSize();
	if (HeadSize > 0)
	{
		unsigned int LenzoneSize = 0;
		GetLenZoneSize(LenzoneSize);
		if (LenzoneSize == 0)
		{
			return HeadSize;
		}

		unsigned long long DataLen = 0;
		if (GetDataLen(DataLen) == false)
		{
			return 0;
		}

		unsigned long long TotalPacketSize = HeadSize + DataLen;
		if (DataLen > 0)
		{
			TotalPacketSize += DP_CRC16_SIZE;
		}

		if (HeadSize == 0 || TotalPacketSize > GetBuffLen())
		{
			return 0;
		}
		return TotalPacketSize;
	}

	return 0;


}

//1.check head,datasize,2.make crc,3.check the first level of data area
bool DiosPacket::ReadyPacket()
{
	//simple check
	//head
	if (m_PacketBuff[DP_HEAD_OFFSET] != (char)DP_HEAD)
	{
		return false;
	}

	//direction
	unsigned int Direction = 3;
	if (GetTargetDirection(Direction) == false || Direction > 2)
	{
		return false;
	}

	unsigned int LenzonSize = 0;
	if (GetLenZoneSize(LenzonSize) == false || LenzonSize > 8)
	{
		return false;
	}

	unsigned long long DataLen = 0;
	if (GetDataLen(DataLen) == false)
	{
		return false;
	}

	//check bufflen & packetlen
	size_t HeadSize = GetHeadSize();
	size_t TotalPacketSize = GetDiosPacketSize();

	if (HeadSize == 0 || TotalPacketSize == 0)
	{
		return false;
	}

	//make head's crc
	unsigned short crc16 = CRC16((unsigned char *)&m_PacketBuff[DP_HEAD_OFFSET], HeadSize - DP_CRC16_SIZE);
	if (SetHeadsCrc(crc16) == false)
	{
		return false;
	}

	//check first level of data
	if (DataLen > 0)
	{
		if (CheckFirstLevelOfTheData(&m_PacketBuff[HeadSize], DataLen) == false)
		{
			return false;
		}
	}
	

	//make data's crc
	if (DataLen > 0)
	{
		crc16 = CRC16((unsigned char*)&m_PacketBuff[HeadSize], DataLen);
		if (SetDataCrc(crc16) == false)
		{
			return false;
		}
	}

	if (UpdateLastEnv() == false)
	{
		return false;
	}

	SetPacketLen(TotalPacketSize);


	return true;

}

bool DiosPacket::GetParam(DWORD Idx, char *&pAddress, size_t &ParamSize)
{
	DIOSKEYTYPE ObjectKey;
	bool Flexible;
	char *pObject = NULL;
	size_t ObjectSize;

	unsigned long long DataLen = 0;
	size_t HeadSize = GetHeadSize();
	if (GetDataLen(DataLen) == false || DataLen == 0)
	{
		return false;
	}

	size_t Size = DataLen;
	char *pData = &m_PacketBuff[HeadSize];

	for (DWORD i = 0; i <= Idx;i++)
	{

		if (GetObjectContext(pData, Size, ObjectKey, Flexible, pObject, ObjectSize))
		{
			//calculate jump size
			size_t jumpsize = (pObject - pData) + ObjectSize;
			if (Size > jumpsize)
			{
				pData += jumpsize;
				Size -= jumpsize;
				continue;
			}
			else if (Size == jumpsize)
			{
				//must be Size == jumpsize!!!!
				//return true;
				continue;
			}
			return false;
		}
		else
		{
			return false;;
		}
	}

	pAddress = pObject;
	ParamSize = ObjectSize;

	return true;
}

RawPacketObject* DiosPacket::GetDataObject()
{
	UINT64 DataLen = 0;
	GetDataLen(DataLen);
	unsigned char *p = (unsigned char *)GetData();
	size_t BuffSize = GetBuffLen() - GetHeadSize();

	if (m_pDataObj == NULL)
	{
		m_pDataObj = new RawPacketObject(NULL, p, DataLen, BuffSize);
	}
	else
	{
		m_pDataObj->Reload(NULL, p, DataLen, BuffSize);
	}
	
	return m_pDataObj;
}



DIOSPACKET_C_API PVOID MallocDiosPacket()
{
	DiosPacket *p = new DiosPacket();

	return (PVOID)p;

}

DIOSPACKET_C_API void ReleaseDiosPacket(PVOID pObj)
{
	DiosPacket *p = (DiosPacket*)pObj;
	delete p;

}

DIOSPACKET_C_API PACKET_RET DiosPacketParser(const char * pRecData, DWORD nLength, DWORD & PacketLength)
{
	//head
	DWORD i = 0;
	for (; i < nLength; i++)
	{
		if (pRecData[i] != (char)DP_HEAD)
		{
			continue;
		}
		else
		{
			break;
		}
	}

	if (i > 0)
	{
		PacketLength = i;
		return PACKET_USELESS;
	}



	//ver
	if (nLength < 2)
	{
		return PACKET_NOPACKET;
	}

	if (pRecData[DP_VER_OFFSET] != (char)0x01)
	{
		PacketLength = DP_VER_OFFSET + 1;
		return PACKET_USELESS;
	}

	//read packet to cmd part
	if (nLength < DP_CMD_OFFSET + 1)
	{
		return PACKET_NOPACKET;
	}

	//get flag-----------------------------
	DIOSPACKETFLAG df;

	CopyStream((const char*)&df, &pRecData[DP_FLAG_OFFSET], sizeof(DIOSPACKETFLAG));

	//check direction
	if (df.PackDirection > 2)
	{
		PacketLength = DP_FLAG_OFFSET + 1;
		return PACKET_USELESS;
	}

	//get len zonesize
	unsigned int LenzoneSize;
	if (df.SizeOfLenZon == 7)
	{
		LenzoneSize = 0;//no Lenzone
	}
	else
	{
		LenzoneSize = 1;
		for (unsigned int i = 0; i < df.SizeOfLenZon; i++)
		{
			LenzoneSize = LenzoneSize << 1;
		}
	}
	//crc effective
	bool CrcEffective = df.CrcEffective;

	//freeze lenzone
	unsigned int FreezeLenzone = df.FreezeOfLenZone;

	//cmd--------------------------
	unsigned int Cmd = pRecData[DP_CMD_OFFSET];

	//get DataLen------------------

	//check 
	if (nLength < DP_PARAMLEN_OFFSET + LenzoneSize)
	{
		return PACKET_NOPACKET;
	}


	unsigned long long DataLen = 0;
	if (LenzoneSize > 0)
	{
		switch (LenzoneSize)
		{
		case 8:
		{
				  //64bit
				  CopyStream(&DataLen, &pRecData[DP_PARAMLEN_OFFSET], sizeof(DataLen));

		}
			break;
		case 4:
		{
				  //32bit
				  unsigned int LocalLen = 0;
				  CopyStream(&LocalLen, &pRecData[DP_PARAMLEN_OFFSET], sizeof(LocalLen));
				  DataLen = LocalLen;

		}
			break;
		case 2:
		{
				  //16bit
				  unsigned short LocalLen = 0;
				  CopyStream(&LocalLen, &pRecData[DP_PARAMLEN_OFFSET], sizeof(LocalLen));
				  DataLen = LocalLen;

		}
			break;
		case 1:
		{
				  //8bit
				  unsigned char LocalLen = 0;
				  CopyStream(&LocalLen, &pRecData[DP_PARAMLEN_OFFSET], sizeof(LocalLen));
				  DataLen = LocalLen;

		}
		default:
		{
				   //其他都是浮云
				   PacketLength = (DP_PARAMLEN_OFFSET + LenzoneSize);
				   return PACKET_USELESS;

		}
			break;
		}

	}


	//get Crc & check
	if (nLength < DP_PARAMLEN_OFFSET + LenzoneSize + DP_CRC16_SIZE)
	{
		return PACKET_NOPACKET;
	}
	//check the Head crc
	unsigned short HeadCalcCrc = CRC16((unsigned char*)&pRecData[DP_HEAD_OFFSET], DP_PARAMLEN_OFFSET + LenzoneSize);

	unsigned short HeadPacketCrc = 0;
	CopyStream(&HeadPacketCrc, &pRecData[DP_PARAMLEN_OFFSET + LenzoneSize], DP_CRC16_SIZE);

	unsigned long long dataOffset = DP_PARAMLEN_OFFSET + LenzoneSize + DP_CRC16_SIZE;

	if (HeadCalcCrc != HeadPacketCrc)
	{
		PacketLength = dataOffset;
		return PACKET_USELESS;
	}

	//head's crc check is done
	if (LenzoneSize == 0 || DataLen == 0)
	{
		//done here
		PacketLength = dataOffset;

		//for test
#ifdef _DEBUG
		//printf("\n\nGot Dios Packet---------------------Dir:%d\n\n", df.PackDirection);
#endif
		return PACKET_ISPACKET;
	}

	//get data & check
	if (nLength < dataOffset + DataLen)
	{
		return PACKET_NOPACKET;
	}


	if (CheckFirstLevelOfTheData((char*)&pRecData[dataOffset], DataLen) == false)
	{
		PacketLength = dataOffset + DataLen;
		return PACKET_USELESS;

	}

	//get crc
	if (nLength < dataOffset + DataLen + DP_CRC16_SIZE)
	{
		return PACKET_NOPACKET;
	}

	
	if (CrcEffective)
	{
		unsigned short DataCalcCrc = CRC16((unsigned char *)&pRecData[dataOffset], DataLen);
		unsigned short DataPacketCrc;
		CopyStream(&DataPacketCrc, &pRecData[dataOffset + DataLen], DP_CRC16_SIZE);

		if (DataCalcCrc != DataPacketCrc)
		{
			PacketLength = dataOffset + DataLen + DP_CRC16_SIZE;
			return PACKET_USELESS;
		}
	}

	PacketLength = dataOffset + DataLen + DP_CRC16_SIZE;


	//for test
#ifdef _DEBUG
	//printf("\n\nGot Dios Packet---------------------Dir:%d.packet Len:%d\n\n", df.PackDirection, PacketLength);
#endif

	return PACKET_ISPACKET;
}