#include "stdafx.h"
#include "Serializer.h"


CSerializer::CSerializer() {
	/* code */
}


CSerializer::~CSerializer() {
	/* code */
}

int CSerializer::SerializedInt32(int& i, void* pBuffer, int size) {
	/* code */
	if (size < sizeof(int)) {
		return -1;
	}

	memcpy(pBuffer, &i, sizeof(int));
	return sizeof(int);
}

int CSerializer::SerializedInt64(__int64& i, void* pBuffer, int size) {
	/* code */
	if (size < sizeof(__int64)) {
		return -1;
	}

	memcpy(pBuffer, &i, sizeof(__int64));
	return sizeof(__int64);
}

int CSerializer::SerializedFloat(float& f, void* pBuffer, int size) {
	/* code */
	if (size < sizeof(float)) {
		return -1;
	}

	memcpy(pBuffer, &f, sizeof(float));
	return sizeof(float);
}

int CSerializer::SerializedDouble(double& d, void* pBuffer, int size) {
	/* code */
	if (size < sizeof(double)) {
		return -1;
	}

	memcpy(pBuffer, &d, sizeof(double));
	return sizeof(double);
}

int CSerializer::SerializedBuffer(void*pScrBuffer, int scrSize, void* pBuffer, int size) {
	/* code */
	if (size < scrSize) {
		return -1;
	}

	memcpy(pBuffer, pScrBuffer, scrSize);
	return scrSize;
}

int CSerializer::SerializedString(std::string& str, void* pBuffer, int size) {
	/* code */
	char* pTemp = (char*)pBuffer;
	int remainSize = size;

	int len = (int)(str.length());
	int nRet1 = SerializedInt32(len, pTemp, remainSize);
	if (nRet1 < 0) {
		return nRet1;
	}
	pTemp += nRet1;
	remainSize -= nRet1;

	int nRet2 = SerializedBuffer((void*)str.c_str(), len, pTemp, remainSize);
	if (nRet2 < 0) {
		return nRet2;
	}

	return nRet1 + nRet2;
}

int CSerializer::SerializedHobject(HalconCpp::HObject& hObject, void* pBuffer, int size) {
	/*code */
	char* pTemp = (char*)pBuffer;
	int remainSize = size;

	HalconCpp::HTuple hPoint, hSize;
	HalconCpp::HTuple hSerializedItem;
	HalconCpp::SerializeObject(hObject, &hSerializedItem);
	HalconCpp::GetSerializedItemPtr(hSerializedItem, &hPoint, &hSize);

	int len = hSize[0].I();
	int nRet1 = SerializedInt32(len, pTemp, remainSize);
	if (nRet1 < 0) {
		HalconCpp::ClearSerializedItem(hSerializedItem);
		return nRet1;
	}
	pTemp += nRet1;
	remainSize -= nRet1;

	if (remainSize < hSize[0].I()) {
		HalconCpp::ClearSerializedItem(hSerializedItem);
		return -1;
	}

	memcpy(pTemp, (void*)hPoint.L(), hSize[0].I());
	return nRet1 + hSize[0].I();
}

int CSerializer::DeserializedInt32(int& i, void* pBuffer, int size) {
	/* code */
	if (size < sizeof(int)) {
		return -1;
	}

	memcpy(&i, pBuffer, sizeof(int));
	return sizeof(int);
}

int CSerializer::DeserializedInt64(__int64& i, void* pBuffer, int size) {
	/* code */
	if (size < sizeof(__int64)) {
		return -1;
	}

	memcpy(&i, pBuffer, sizeof(__int64));
	return sizeof(__int64);
}

int CSerializer::DeserializedFloat(float& f, void* pBuffer, int size) {
	/* code */
	if (size < sizeof(float)) {
		return -1;
	}

	memcpy(&f, pBuffer, sizeof(float));
	return sizeof(float);
}

int CSerializer::DeserializedDouble(double& d, void* pBuffer, int size) {
	/* code */
	if (size < sizeof(double)) {
		return -1;
	}

	memcpy(&d, pBuffer, sizeof(double));
	return sizeof(double);
}

int CSerializer::DeserializedBuffer(void*pTarBuffer, int tarSize, void* pBuffer, int size) {
	/*code */
	if (size < tarSize) {
		return -1;
	}

	memcpy(pTarBuffer, pBuffer, tarSize);
	return tarSize;
}

int CSerializer::DeserializedString(std::string& str, void* pBuffer, int size) {
	/* code */
	char* pTemp = (char*)pBuffer;
	int remainSize = size;

	int len = 0;
	int nRet1 = DeserializedInt32(len, pTemp, remainSize);
	if (nRet1 < 0) {
		return nRet1;
	}
	pTemp += nRet1;
	remainSize -= nRet1;

	char* pszTemp = new char[len];
	int nRet2 = DeserializedBuffer(pszTemp, len, pTemp, remainSize);
	if (nRet2 < 0) {
		delete[] pszTemp;
		return nRet2;
	}
	str.clear();
	str.append(pszTemp, len);
	delete[] pszTemp;

	return nRet1 + nRet2;
}

int CSerializer::DeserializedHobject(HalconCpp::HObject& hObject, void* pBuffer, int size) {
	/* code */
	char* pTemp = (char*)pBuffer;
	int remainSize = size;

	int len = 0;
	int nRet1 = DeserializedInt32(len, pTemp, remainSize);
	if (nRet1 < 0) {
		return nRet1;
	}
	pTemp += nRet1;
	remainSize -= nRet1;


	if (remainSize < len) {
		return nRet1;
	}

	HalconCpp::HTuple hSerializedItem;
	HalconCpp::CreateSerializedItemPtr((__int64)pTemp, len, "false", &hSerializedItem);
	HalconCpp::DeserializeObject(&hObject, hSerializedItem);

	return nRet1 + len;
}