PhysicalDevice/Machine/MachineryECOM/Trunk/DIOS.Dev.Machinery.Motion.Driver/DIOS.Dev.Machinery.Client/deliver/include/PacketAnalizer.cpp

#include "StdAfx.h"
#include <assert.h>
#include "Crc64.h"
#include "Logger.h"
#include "DiosLock.h"
#include "PacketAnalizer.h"

#define CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>


PacketAnalizer::PacketAnalizer(void)
{
}


PacketAnalizer::~PacketAnalizer(void)
{
}

DWORD PacketAnalizer::MakePacketIdx()
{
	//static volatile UINT64 g_IdxLock = 0;

	//static volatile DWORD oldTick = 1;
	//DWORD tick = 0;

	//if (Dios_ThreadLock(&g_IdxLock))
	//{
	//	tick = (DWORD)GetTickCount();
	//	while (tick == 0)
	//	{
	//		tick = (DWORD)GetTickCount();
	//	}

	//	if (tick == oldTick)
	//	{
	//		tick += 1;
	//	}

	//	oldTick = tick;

	//	Dios_ThreadUnLock(&g_IdxLock);

	//}


	//return tick;

	return Thread_GetUniqTick();
}

DWORD PacketAnalizer::GetPacketIdx(ResDataObject *pObj)
{
	DWORD ret = 0;
	try {
		int Idx = (*pObj).GetFirstOf(DIOS_PACK_IDX);
		if (Idx >= 0)
		{
			ret = (*pObj)[DIOS_PACK_IDX];
		}

	}
	catch (ResDataObjectExption &exp)
	{
		//exp.what()
		Logger *p = GetGlobalLogger();
		PRINTA_DEBUG(p, exp.what());
	}
	catch (...)
	{
		Logger *p = GetGlobalLogger();
		PRINTA_DEBUG(p, "Unknown Exp Happened\n");
	}

	return ret;
}

bool PacketAnalizer::GetDestinationMachineId(ResDataObject &packet, string &machineId)
{
	bool ret = false;
	try {
		//check destination & dispatch
		PACKET_TYPE type = PacketAnalizer::GetPacketType(&packet);

		switch (type)
		{
			//req:dev bus+proc
		case PACKET_TYPE_REQ:
			if (PacketAnalizer::GetPacketHandleMachineId(&packet, machineId, true))
			{
				return true;
			}
			break;
			//res&notify:owner bus+proc
		case PACKET_TYPE_RES:
		case PACKET_TYPE_NOTIFY:
			if (PacketAnalizer::GetPacketHandleMachineId(&packet, machineId, false))
			{
				return true;
			}

			break;
		default:
			break;
		}
	}
	catch (...)
	{
	}

	return ret;

}


bool PacketAnalizer::GetDestinationBusId(ResDataObject &packet, string &busId)
{
	bool ret = false;
	try {
		//check destination & dispatch
		PACKET_TYPE type = PacketAnalizer::GetPacketType(&packet);

		switch (type)
		{
			//req:dev bus+proc
		case PACKET_TYPE_REQ:
			if (PacketAnalizer::GetPacketHandleBusId(&packet, busId, true))
			{
				return true;
			}
			break;
			//res&notify:owner bus+proc
		case PACKET_TYPE_RES:
		case PACKET_TYPE_NOTIFY:
			if (PacketAnalizer::GetPacketHandleBusId(&packet, busId, false))
			{
				return true;
			}

			break;
		default:
			break;
		}
	}
	catch (...)
	{
	}

	return ret;

}


bool PacketAnalizer::GetDestinationProcId(ResDataObject &packet, UINT64 &procId)
{
	bool ret = false;
	try {
		//check destination & dispatch
		PACKET_TYPE type = PacketAnalizer::GetPacketType(&packet);

		switch (type)
		{
			//req:dev bus+proc
		case PACKET_TYPE_REQ:
			if (PacketAnalizer::GetPacketHandleProcId(&packet, procId, true))
			{
				return true;
			}
			break;
			//res&notify:owner bus+proc
		case PACKET_TYPE_RES:
		case PACKET_TYPE_NOTIFY:
			if (PacketAnalizer::GetPacketHandleProcId(&packet, procId, false))
			{
				return true;
			}

			break;
		default:
			break;
		}
	}
	catch (...)
	{
	}

	return ret;

}

PACKET_TYPE PacketAnalizer::GetPacketType(ResDataObject *pObj)
{
	int cmd;
	PACKET_TYPE ret = PACKET_TYPE_NONE;

	try {
		cmd = (int)(*pObj)[DIOS_PACK_TYPE];
		ret = (PACKET_TYPE)cmd;
		if(ret >= 0 && ret < PACKET_TYPE_MAX)
		{
			return ret;
		}

	}
	catch(ResDataObjectExption &exp)
	{
		//exp.what()
		Logger *p = GetGlobalLogger();
		PRINTA_DEBUG(p, exp.what());
	}
	catch(...)
	{
		Logger *p = GetGlobalLogger();
		PRINTA_DEBUG(p, "Unknown Exp Happened\n");

	}

	return PACKET_TYPE_NONE;

}

PACKET_CMD PacketAnalizer::GetPacketCmd(ResDataObject *pObj)
{
	int cmd;
	PACKET_CMD ret = PACKET_CMD_NONE;

	try {
		cmd = (int)((*pObj)[DIOS_PACK_CMD]);
		ret = (PACKET_CMD)cmd;
		if(ret >= 0 && ret < PACKET_CMD_MAX)
		{
			return ret;
		}

	}
	catch (ResDataObjectExption &exp)
	{
		//exp.what()
		Logger *p = GetGlobalLogger();
		PRINTA_DEBUG(p, exp.what());
	}
	catch (...)
	{
		Logger *p = GetGlobalLogger();
		PRINTA_DEBUG(p, "Unknown Exp Happened\n");

	}

	return PACKET_CMD_NONE;
}

ACTION_SYNC_MODE PacketAnalizer::GetPacketSyncMode(ResDataObject *pObj)
{
	ACTION_SYNC_MODE ret = ACTION_SYNC;
	try {
		ret = (ACTION_SYNC_MODE)(int)(*pObj)[DIOS_PACKET_SYNC];
	}
	catch (...)
	{
		ret = ACTION_SYNC;
	}


	return ret;
}

ResDataObject* PacketAnalizer::GetPacketKeysRes(ResDataObject *pObj)
{
	try {
		int Idx = (*pObj).GetFirstOf(DIOS_PACK_KEY);
		if (Idx >= 0)
		{
			ResDataObject &Res = (*pObj)[DIOS_PACK_KEY];
			return &Res;
		}

	}
	catch (ResDataObjectExption &exp)
	{
		//exp.what()
		Logger *p = GetGlobalLogger();
		PRINTA_DEBUG(p, exp.what());
	}
	catch (...)
	{
		Logger *p = GetGlobalLogger();
		PRINTA_DEBUG(p, "Unknown Exp Happened\n");
	}


	return NULL;
}

std::string PacketAnalizer::GetPacketKey(ResDataObject *pObj)
{
	std::string key = "";
	try {
		int Idx = (*pObj).GetFirstOf(DIOS_PACK_KEY);
		if (Idx >= 0)
		{
			key = (const char*)(*pObj)[DIOS_PACK_KEY];
		}

	}
	catch (ResDataObjectExption &exp)
	{
		//exp.what()
		Logger *p = GetGlobalLogger();
		PRINTA_DEBUG(p, exp.what());
		key = "";
	}
	catch (...)
	{
		Logger *p = GetGlobalLogger();
		PRINTA_DEBUG(p, "Unknown Exp Happened\n");
		key = "";
	}


	return key;
}

bool PacketAnalizer::GetPacketHandleExistance(ResDataObject *pPacket)
{
	bool ret = false;
	try {
		if ((*pPacket).GetFirstOf(DIOS_PACK_HANDLE) >= 0)
		{
			ret = true;
		}
	}
	catch (...)
	{
		ret = false;
	}

	return ret;

}


bool PacketAnalizer::GetPacketHandle(ResDataObject *pPacket,ResDataObject &Handle)
{
	bool ret = true;
	try {
		(Handle) = (*pPacket)[DIOS_PACK_HANDLE];
	}
	catch(...)
	{
		ret = false;
	}

	return ret;
}

bool PacketAnalizer::GetPacketHandleBusId(ResDataObject *pPacket, string &BusId, bool dev)
{
	bool ret = true;
	try {
		if (dev)
		{
			BusId = (const char *)(*pPacket)[DIOS_PACK_HANDLE][DIOS_PACK_HANDLE_DEVID][DIOS_PACK_TARGET_BUSID];
		}
		else
		{
			BusId = (const char *)(*pPacket)[DIOS_PACK_HANDLE][DIOS_PACK_HANDLE_OWNERID][DIOS_PACK_TARGET_BUSID];
		}

	}
	catch (...)
	{
		BusId = "";
		ret = false;
	}

	return ret;

}

bool PacketAnalizer::GetPacketHandleMachineId(ResDataObject *pPacket, string &MachineId, bool dev)
{
	bool ret = true;
	try {
		if (dev)
		{
			MachineId = (const char *)(*pPacket)[DIOS_PACK_HANDLE][DIOS_PACK_HANDLE_DEVID][DIOS_PACK_TARGET_MACHINEID];
		}
		else
		{
			MachineId = (const char *)(*pPacket)[DIOS_PACK_HANDLE][DIOS_PACK_HANDLE_OWNERID][DIOS_PACK_TARGET_MACHINEID];
		}

	}
	catch (...)
	{
		MachineId = "";
		ret = false;
	}

	return ret;

}

bool PacketAnalizer::GetPacketHandleProcId(ResDataObject *pPacket, UINT64 &ProcId, bool dev)
{
	bool ret = true;
	try {
		if (dev)
		{
			ProcId = (UINT64)(*pPacket)[DIOS_PACK_HANDLE][DIOS_PACK_HANDLE_DEVID][DIOS_PACK_TARGET_PROCID];
		}
		else
		{
			ProcId = (UINT64)(*pPacket)[DIOS_PACK_HANDLE][DIOS_PACK_HANDLE_OWNERID][DIOS_PACK_TARGET_PROCID];
		}

	}
	catch (...)
	{
		ProcId = 0;
		ret = false;
	}

	return ret;
}

bool PacketAnalizer::GetPacketHandleCrc(ResDataObject *pPacket, UINT64 &Crc)
{
	bool ret = true;
	try {
		Crc = (UINT64)(*pPacket)[DIOS_PACK_HANDLE][DIOS_PACKET_HANDLE_KEY];
	}
	catch (...)
	{
		Crc = 0;
		ret = false;
	}

	return ret;

}

bool PacketAnalizer::GetPacketHandleAddr(ResDataObject *pPacket, UINT64 &Addr, bool dev)
{
	bool ret = true;
	try {
		if (dev)
		{
			Addr = (UINT64)(*pPacket)[DIOS_PACK_HANDLE][DIOS_PACK_HANDLE_DEVID][DIOS_PACK_TARGET_ADDR];
		}
		else
		{
			Addr = (UINT64)(*pPacket)[DIOS_PACK_HANDLE][DIOS_PACK_HANDLE_OWNERID][DIOS_PACK_TARGET_ADDR];
		}

	}
	catch (...)
	{
		Addr = 0;
		ret = false;
	}

	return ret;

}

bool PacketAnalizer::MakePacketContextExistance(ResDataObject *pPacket)
{
	bool ret = false;
	try {
		if ((*pPacket).GetFirstOf(DIOS_PACK_CONTEXT) >= 0)
		{
			ret = true;
		}
		else
		{
			(*pPacket).add(DIOS_PACK_CONTEXT, "");
			ret = true;
		}


	}
	catch (...)
	{
		ret = false;
	}

	return ret;

}

bool PacketAnalizer::GetPacketRoute(ResDataObject *pPacket, DIOS_PACKET_ROUTE &Route)
{
	bool ret = true;
	Route = DIOS_PACKET_ROUTE_ANY;//ȱʡÉèÖÃÒ»¸öÏÈ
	try {
		(Route) = (DIOS_PACKET_ROUTE)((int)(*pPacket)[DIOS_PACK_HANDLE][DIOS_PACK_HANDLE_ROUTE]);
	}
	catch (...)
	{
		ret = false;
	}

	return ret;
}


bool PacketAnalizer::GetPacketContext(ResDataObject *pPacket,ResDataObject &Context)
{
	bool ret = true;
	try {
		int Idx = (*pPacket).GetFirstOf(DIOS_PACK_CONTEXT);
		if (Idx >= 0)
		{
			(Context) = (*pPacket)[Idx];
		}

	}
	catch(...)
	{
		ret = false;
	}

	return ret;
}

bool PacketAnalizer::GetPacketRetCode(ResDataObject *pPacket,RET_STATUS &retcode)
{
	bool ret = true;
	try {
		(retcode) = (RET_STATUS)((int)((*pPacket)[DIOS_PACK_RETURN][DIOS_PACK_CODE]));
	}
	catch(...)
	{
		retcode = RET_FAILED;
		ret = false;
	}

	return ret;

}

bool PacketAnalizer::GetPacketMsgInfo(ResDataObject *pPacket,string &Info)
{
	bool ret = true;
	try {
		int Idx = (*pPacket)[DIOS_PACK_RETURN].GetFirstOf(DIOS_PACK_MSG);
		if (Idx >= 0)
		{
			(Info) = ((const char*)((*pPacket)[DIOS_PACK_RETURN][Idx]));
		}

	}
	catch(...)
	{
		ret = false;
	}

	return ret;

}


void  PacketAnalizer::MakeRetCode(RET_STATUS retcode,ResDataObject *pObj,const char *pMsg)
{
	ResDataObject RetObj,SubObj;
	SubObj.add(DIOS_PACK_CODE,(int)retcode);
	if(pMsg)
	{
		SubObj.add(DIOS_PACK_MSG,pMsg);
	}

	pObj->update(DIOS_PACK_RETURN,SubObj);

}

bool  PacketAnalizer::CloneResponse(ResDataObject &Obj,ResDataObject *pReq)
{
	Obj.clear();
	//Idx
	DWORD Idx = PacketAnalizer::GetPacketIdx(pReq);
	if (Idx)
	{
		Obj.add(DIOS_PACK_IDX, Idx);
		Obj.add(DIOS_PACK_TYPE, (int)PACKET_TYPE_RES);
		PACKET_CMD cmd = PacketAnalizer::GetPacketCmd(pReq);
		if (cmd != PACKET_CMD_NONE)
		{
			Obj.add(DIOS_PACK_CMD, (int)cmd);
			Obj.add(DIOS_PACK_HANDLE, (*pReq)[DIOS_PACK_HANDLE]);
			string keystr = PacketAnalizer::GetPacketKey(pReq);
			Obj.add(DIOS_PACK_KEY, keystr.c_str());
			Obj.add(DIOS_PACK_CONTEXT, "");

			return true;
		}

	}

	return false;
}

bool  PacketAnalizer::UpdateOpenRequest(ResDataObject &Req, ResDataObject &MachineId, ResDataObject &busId, UINT64 ProcId, UINT64 Addr)
{
	try {
		Req[DIOS_PACK_HANDLE][DIOS_PACK_HANDLE_DEVID][DIOS_PACK_TARGET_ADDR] = Addr;
		Req[DIOS_PACK_HANDLE][DIOS_PACK_HANDLE_DEVID][DIOS_PACK_TARGET_PROCID] = ProcId;
		Req[DIOS_PACK_HANDLE][DIOS_PACK_HANDLE_DEVID][DIOS_PACK_TARGET_BUSID] = busId;
		Req[DIOS_PACK_HANDLE][DIOS_PACK_HANDLE_DEVID][DIOS_PACK_TARGET_MACHINEID] = MachineId;
		string the_crc = "";
		the_crc += Req[DIOS_PACK_HANDLE][DIOS_PACK_HANDLE_OWNERID].encode();
		the_crc += (const char *)Req[DIOS_PACK_HANDLE][DIOS_PACK_HANDLE_DEVID].encode();

		std::stringstream strm;
		std::string tickstr;
		unsigned int Tick = PacketAnalizer::MakePacketIdx();
		strm << Tick;
		strm >> tickstr;
		the_crc += tickstr;

		UINT64 crc = GetCrc64(the_crc.c_str(), (DWORD)the_crc.size());
		Req[DIOS_PACK_HANDLE][DIOS_PACKET_HANDLE_KEY] = crc;

		return true;

	}
	catch (...)
	{

	}

	return false;
}

bool PacketAnalizer::UpdateDeviceNotifyResponse(ResDataObject &Notify, ResDataObject &MachineId, ResDataObject &busId, UINT64 ProcId, UINT64 Addr)
{
	try {
		DiosDevFileHandle handle;
		handle.GetTarget(false)[DIOS_PACK_TARGET_MACHINEID] = (const char*)MachineId;
		handle.GetTarget(false)[DIOS_PACK_TARGET_BUSID] = (const char*)busId;
		handle.GetTarget(false)[DIOS_PACK_TARGET_PROCID] = ProcId;
		handle.GetTarget(false)[DIOS_PACK_TARGET_ADDR] = Addr;

		ResDataObject handleObj;
		handle.GetResDataObject(handleObj);
		Notify.update(DIOS_PACK_HANDLE, handleObj);

		return true;

	}
	catch (...)
	{

	}

	return false;

}

bool PacketAnalizer::UpdatePacketContext(ResDataObject &packet, ResDataObject &Context)
{
	try {
		packet[DIOS_PACK_CONTEXT] = Context;
		return true;

	}
	catch (...)
	{

	}

	return false;
}

bool  PacketAnalizer::MakeOpenResponse(ResDataObject &Req,ResDataObject &Res,ResDataObject &DevResource)
{
	PacketAnalizer::CloneResponse(Res, &Req);
	try {

		Res.update(DIOS_PACK_CONTEXT,DevResource);
		PacketAnalizer::MakeRetCode(RET_SUCCEED, &Res);

		return true;
	}
	catch (...)
	{

	}



	return false;
}



void  PacketAnalizer::MakeNotifyP2P(ResDataObject &Obj, PACKET_CMD cmd,ResDataObject *pReq, const char *pKey, const char *pContext)
{
	Obj.clear();
	Obj.update(DIOS_PACK_IDX, PacketAnalizer::MakePacketIdx());
	Obj.update(DIOS_PACK_TYPE, (int)PACKET_TYPE_NOTIFY);
	Obj.update(DIOS_PACK_CMD, (int)cmd);
	Obj.update(DIOS_PACK_HANDLE, (*pReq)[DIOS_PACK_HANDLE]);
	Obj.update(DIOS_PACK_KEY, pKey);
	Obj.update(DIOS_PACK_CONTEXT, pContext);
}


bool PacketAnalizer::UpdatePacketRoute(ResDataObject &Obj, DIOS_PACKET_ROUTE Route)
{
	Obj[DIOS_PACK_HANDLE][DIOS_PACK_HANDLE_ROUTE] = (int)Route;
	return true;
}


bool PacketAnalizer::UpdateNotifyHandle(ResDataObject &Obj, DiosDevFileHandle &handle)
{
	ResDataObject handleObj;
	handle.GetResDataObject(handleObj);
	Obj.update(DIOS_PACK_HANDLE, handleObj);
	//Obj.update(DIOS_PACK_HANDLE, handle.GetVal());

	return true;
}

void  PacketAnalizer::MakeNotify(ResDataObject &Obj,PACKET_CMD cmd,const char *pKey,const char *pContext)
{
	Obj.clear();
	Obj.update(DIOS_PACK_IDX, PacketAnalizer::MakePacketIdx());
	Obj.update(DIOS_PACK_TYPE, (int)PACKET_TYPE_NOTIFY);
	Obj.update(DIOS_PACK_CMD, (int)cmd);
	Obj.update(DIOS_PACK_KEY, pKey);
	Obj.update(DIOS_PACK_CONTEXT, pContext);
}

void  PacketAnalizer::MakeNotify(ResDataObject &Obj, PACKET_CMD cmd, ResDataObject &Key, const ResDataObject &Context)
{
	Obj.clear();
	Obj.add(DIOS_PACK_IDX, PacketAnalizer::MakePacketIdx());
	Obj.add(DIOS_PACK_TYPE, (int)PACKET_TYPE_NOTIFY);
	Obj.add(DIOS_PACK_CMD, (int)cmd);
	Obj.add(DIOS_PACK_KEY, Key);
	Obj.add(DIOS_PACK_CONTEXT, (ResDataObject&)Context);
}


void  PacketAnalizer::MakeNotify(ResDataObject &Obj, PACKET_CMD cmd, const char *pKey, const ResDataObject &Context)
{
	Obj.clear();
	Obj.add(DIOS_PACK_IDX, PacketAnalizer::MakePacketIdx());
	Obj.add(DIOS_PACK_TYPE, (int)PACKET_TYPE_NOTIFY);
	Obj.add(DIOS_PACK_CMD, (int)cmd);
	Obj.add(DIOS_PACK_KEY, pKey);
	Obj.add(DIOS_PACK_CONTEXT, (ResDataObject&)Context);
}


DWORD  PacketAnalizer::MakeActionRequest(ResDataObject &Obj, DiosDevFileHandle &handle, const char *pActionName, ResDataObject &ReqParams, ACTION_SYNC_MODE mode)
{
	DWORD tick = PacketAnalizer::MakePacketIdx();
	Obj.clear();
	Obj.add(DIOS_PACK_IDX, tick);
	Obj.add(DIOS_PACK_TYPE,(int)PACKET_TYPE_REQ);
	Obj.add(DIOS_PACK_CMD,(int)PACKET_CMD_EXE);
	Obj.add(DIOS_PACKET_SYNC, (int)mode);

	ResDataObject handleObj;
	handle.GetResDataObject(handleObj);
	Obj.add(DIOS_PACK_HANDLE, handleObj);

	Obj.add(DIOS_PACK_KEY,pActionName);
	Obj.add(DIOS_PACK_CONTEXT,ReqParams);

	return tick;
}

DWORD PacketAnalizer::MakeOpenRequest(ResDataObject &Obj, DiosDevFileHandle &handle, const char *pFilePath)
{
	//ResDataObject TargetObj;
	DWORD tick = PacketAnalizer::MakePacketIdx();
	Obj.clear();
	Obj.add(DIOS_PACK_IDX, tick);
	Obj.add(DIOS_PACK_TYPE,(int)PACKET_TYPE_REQ);
	Obj.add(DIOS_PACK_CMD,(int)PACKET_CMD_OPEN);

	//printf("handle:%s\n", handle.GetVal());
	//TargetObj.add(handle.m_Dev.m_MachineID.GetKey(), handle.m_Dev.m_MachineID.GetVal());

	ResDataObject handleObj;
	handle.GetResDataObject(handleObj);
	Obj.add(DIOS_PACK_HANDLE, handleObj);

	Obj.add(DIOS_PACK_KEY,pFilePath);


	return tick;

}

bool PacketAnalizer::MakeResponseByReq(ResDataObject &Response, ResDataObject &Req,RET_STATUS ret,const char* pInfo)
{
	PacketAnalizer::CloneResponse(Response, &Req);
	PacketAnalizer::MakeRetCode(ret, &Response, pInfo);

	return true;
}

bool PacketAnalizer::MakeCloseNotifyByRes(ResDataObject &Response, ResDataObject &Req)
{
	DWORD tick = PacketAnalizer::MakePacketIdx();
	Req.clear();
	Req.add(DIOS_PACK_IDX, tick);
	Req.add(DIOS_PACK_TYPE, (int)PACKET_TYPE_NOTIFY);
	Req.add(DIOS_PACK_CMD, (int)PACKET_CMD_CLOSE);

	Req.add(DIOS_PACK_HANDLE, Response[DIOS_PACK_HANDLE]);




	return true;

}


bool PacketAnalizer::MakeCloseRequestByRes(ResDataObject &Response, ResDataObject &Req)
{
	DWORD tick = PacketAnalizer::MakePacketIdx();
	Req.clear();
	Req.add(DIOS_PACK_IDX, tick);
	Req.add(DIOS_PACK_TYPE, (int)PACKET_TYPE_REQ);
	Req.add(DIOS_PACK_CMD, (int)PACKET_CMD_CLOSE);

	Req.add(DIOS_PACK_HANDLE, Response[DIOS_PACK_HANDLE]);




	return true;

}


bool PacketAnalizer::MakeCloseRequest(ResDataObject &Obj, DiosDevFileHandle &handle, PACKET_TYPE Type)
{
	DWORD tick = PacketAnalizer::MakePacketIdx();
	Obj.clear();
	Obj.add(DIOS_PACK_IDX, tick);
	Obj.add(DIOS_PACK_TYPE, (int)Type);
	Obj.add(DIOS_PACK_CMD,(int)PACKET_CMD_CLOSE);
	ResDataObject handleObj;
	handle.GetResDataObject(handleObj);
	Obj.add(DIOS_PACK_HANDLE, handleObj);

	


	return true;

}

bool PacketAnalizer::MakeCloseResponse(ResDataObject &Req, ResDataObject &Res)
{
	PacketAnalizer::CloneResponse(Res, &Req);

	PacketAnalizer::MakeRetCode(RET_SUCCEED, &Res);

	return true;

}


bool  PacketAnalizer::GetParam(ResDataObject *pReq, unsigned int ParamIdx, ResDataObject &value)
{
	bool ret = true;

	string parami;

	std::stringstream strm;

	try {
		//make p0
		strm << "P";
		strm << ParamIdx;
		strm >> parami;

		value = (*pReq)[DIOS_PACK_CONTEXT][parami.c_str()];

	}
	catch (...)
	{
		ret = false;
	}

	return ret;

};


bool  PacketAnalizer::AddParam(ResDataObject *pRes, unsigned int ParamIdx, ResDataObject &value)
{
	bool ret = true;

	string parami;

	std::stringstream strm;

	try {
		//make p0
		strm << "P";
		strm << ParamIdx;
		strm >> parami;

		ret = (*pRes)[DIOS_PACK_CONTEXT].add(parami.c_str(), value);

	}
	catch (...)
	{
		ret = false;
	}

	return ret;

}

bool  PacketAnalizer::UpdateParam(ResDataObject *pRes, unsigned int ParamIdx, ResDataObject &value)
{
	bool ret = true;

	string parami;

	std::stringstream strm;

	try {
		//make p0
		strm << "P";
		strm << ParamIdx;
		strm >> parami;

		ret = (*pRes)[DIOS_PACK_CONTEXT].update(parami.c_str(), value);

	}
	catch (...)
	{
		ret = false;
	}

	return ret;

}