#include "stdafx.h"
#include "CJobDataS.h"
#include "ToolUnits.h"


namespace SERVO {
#define JOBDATAS_SIZE				(256 * 2)
#define ENABLE_JOBDATAS_RAWDATA		TRUE

	CJobDataS::CJobDataS()
	{
		m_nCassetteSequenceNo = 0;
		m_nJobSequenceNo = 0;
		m_nJobType = 0;
		m_nMaterialsType = 0;
		m_nProductType = 0;
		m_nDummyType = 0;
		m_nSkipFlag = 0;
		m_nProcessFlag = 0;
		m_nProcessResonCode = 0;
		m_nLastGlassFlag = 0;
		m_nFirstGlassFlag = 0;
		m_nQTime[3] = { 0 };
		m_nQTimeOverFlag = 0;
		m_nMasterRecipe = 0;
		m_nRecipeIds[DEVICE_COUNT] = { 0 };
		m_nMode = 0;
		m_nSlotUnitSelectFlag = 0;
		m_nSourcePortNo = 0;
		m_nSourceSlotNo = 0;
		m_nTargetPortNo = 0;
		m_nTargetSlotNo = 0;
		m_nProductJudge = 0;
		m_pRawData = nullptr;
		m_pOwner = nullptr;
		if (ENABLE_JOBDATAS_RAWDATA) {
			m_pRawData = new char[JOBDATAS_SIZE];
			serialize(m_pRawData, JOBDATAS_SIZE);
		}
	}

	CJobDataS::CJobDataS(CJobDataS&& other) noexcept
	{
		copy(&other);
		m_pRawData = other.m_pRawData;      // ͵×ÊÔ´
		other.m_pRawData = nullptr;			// ·ÀÖ¹ÊÍ·ÅÁ½´Î
	}

	CJobDataS::~CJobDataS()
	{
		if (m_pRawData != nullptr) {
			delete[] m_pRawData;
			m_pRawData = nullptr;
		}
	}

	void CJobDataS::copy(CJobDataS* pScr)
	{
		m_nCassetteSequenceNo = pScr->m_nCassetteSequenceNo;
		m_nJobSequenceNo = pScr->m_nJobSequenceNo;
		m_strLotId = pScr->m_strLotId;
		m_strProductId = pScr->m_strProductId;
		m_strOperationId = pScr->m_strOperationId;
		m_strGlass1Id = pScr->m_strGlass1Id;
		m_strGlass2Id = pScr->m_strGlass2Id;
		m_nJobType = pScr->m_nJobType;
		m_nMaterialsType = pScr->m_nMaterialsType;
		m_nProductType = pScr->m_nProductType;
		m_nDummyType = pScr->m_nDummyType;
		m_nSkipFlag = pScr->m_nSkipFlag;
		m_nProcessFlag = pScr->m_nProcessFlag;
		m_nProcessResonCode = pScr->m_nProcessResonCode;
		m_nLastGlassFlag = pScr->m_nLastGlassFlag;
		m_nFirstGlassFlag = pScr->m_nFirstGlassFlag;
		m_nQTime[0] = pScr->m_nQTime[0];
		m_nQTime[1] = pScr->m_nQTime[1];
		m_nQTime[2] = pScr->m_nQTime[2];
		m_nQTimeOverFlag = pScr->m_nQTimeOverFlag;
		m_nMasterRecipe = pScr->m_nMasterRecipe;
		memcpy(m_nRecipeIds, pScr->m_nRecipeIds, sizeof(m_nRecipeIds));
		m_strPanelMeasure = pScr->m_strPanelMeasure;
		m_nMode = pScr->m_nMode;
		m_nSlotUnitSelectFlag = pScr->m_nSlotUnitSelectFlag;
		m_nSourcePortNo = pScr->m_nSourcePortNo;
		m_nSourceSlotNo = pScr->m_nSourceSlotNo;
		m_nTargetPortNo = pScr->m_nTargetPortNo;
		m_nTargetSlotNo = pScr->m_nTargetSlotNo;
		m_nProductJudge = pScr->m_nProductJudge;
		m_pOwner = pScr->m_pOwner;
	}

	void CJobDataS::update(CJobDataS* pScr)
	{
		// m_nCassetteSequenceNo = pScr->m_nCassetteSequenceNo;
		// m_nJobSequenceNo = pScr->m_nJobSequenceNo;
		m_strLotId = pScr->m_strLotId;
		m_strProductId = pScr->m_strProductId;
		m_strOperationId = pScr->m_strOperationId;
		// m_strGlass1Id = pScr->m_strGlass1Id;
		m_strGlass2Id = pScr->m_strGlass2Id;
		m_nJobType = pScr->m_nJobType;
		m_nMaterialsType = pScr->m_nMaterialsType;
		m_nProductType = pScr->m_nProductType;
		m_nDummyType = pScr->m_nDummyType;
		m_nSkipFlag = pScr->m_nSkipFlag;
		m_nProcessFlag = pScr->m_nProcessFlag;
		m_nProcessResonCode = pScr->m_nProcessResonCode;
		m_nLastGlassFlag = pScr->m_nLastGlassFlag;
		m_nFirstGlassFlag = pScr->m_nFirstGlassFlag;
		m_nQTime[0] = pScr->m_nQTime[0];
		m_nQTime[1] = pScr->m_nQTime[1];
		m_nQTime[2] = pScr->m_nQTime[2];
		m_nQTimeOverFlag = pScr->m_nQTimeOverFlag;
		m_nMasterRecipe = pScr->m_nMasterRecipe;
		memcpy(m_nRecipeIds, pScr->m_nRecipeIds, sizeof(m_nRecipeIds));
		m_strPanelMeasure = pScr->m_strPanelMeasure;
		m_nMode = pScr->m_nMode;
		m_nSlotUnitSelectFlag = pScr->m_nSlotUnitSelectFlag;
		m_nSourcePortNo = pScr->m_nSourcePortNo;
		m_nSourceSlotNo = pScr->m_nSourceSlotNo;
		m_nTargetPortNo = pScr->m_nTargetPortNo;
		m_nTargetSlotNo = pScr->m_nTargetSlotNo;
		m_nProductJudge = pScr->m_nProductJudge;
		m_pOwner = pScr->m_pOwner;
	}

	CJobDataB& CJobDataS::getJobDataB(CJobDataB& jobDataB)
	{
		jobDataB.setCassetteSequenceNo(this->getCassetteSequenceNo());
		jobDataB.setJobSequenceNo(this->getJobSequenceNo());
		jobDataB.setGlassId(this->getGlass1Id().c_str());

		return jobDataB;
	}

	void* CJobDataS::getOwner()
	{
		return m_pOwner;
	}

	void CJobDataS::setOwner(void* pOwner)
	{
		m_pOwner = pOwner;
	}

	int CJobDataS::getCassetteSequenceNo()
	{
		return m_nCassetteSequenceNo;
	}

	void CJobDataS::setCassetteSequenceNo(int no)
	{
		m_nCassetteSequenceNo = no;
	}

	int CJobDataS::getJobSequenceNo()
	{
		return m_nJobSequenceNo;
	}

	void CJobDataS::setJobSequenceNo(int no)
	{
		m_nJobSequenceNo = no;
	}

	std::string& CJobDataS::getLotId()
	{
		return m_strLotId;
	}

	void CJobDataS::setLotId(const char* pszId)
	{
		m_strLotId = pszId;
	}

	std::string& CJobDataS::getProductId()
	{
		return m_strProductId;
	}

	void CJobDataS::setProductId(const char* pszId)
	{
		m_strProductId = pszId;
	}

	std::string& CJobDataS::getOperationId()
	{
		return m_strOperationId;
	}

	void CJobDataS::setOperationId(const char* pszId)
	{
		m_strOperationId = pszId;
	}

	std::string& CJobDataS::getGlass1Id()
	{
		return m_strGlass1Id;
	}

	void CJobDataS::setGlass1Id(const char* pszId)
	{
		m_strGlass1Id = pszId;
	}

	std::string& CJobDataS::getGlass2Id()
	{
		return m_strGlass2Id;
	}

	void CJobDataS::setGlass2Id(const char* pszId)
	{
		m_strGlass2Id = pszId;
	}

	int CJobDataS::getJobType()
	{
		return m_nJobType;
	}

	void CJobDataS::setJobType(int type)
	{
		m_nJobType = type;
	}

	int CJobDataS::getMaterialsType()
	{
		return m_nMaterialsType;
	}

	void CJobDataS::setMaterialsType(int type)
	{
		m_nMaterialsType = type;
	}

	int CJobDataS::getProductType()
	{
		return m_nProductType;
	}

	void CJobDataS::setProductType(int type)
	{
		m_nProductType = type;
	}

	int CJobDataS::getDummyType()
	{
		return m_nDummyType;
	}

	void CJobDataS::setDummyType(int type)
	{
		m_nDummyType = type;
	}

	int CJobDataS::getSkipFlag()
	{
		return m_nSkipFlag;
	}

	void CJobDataS::setSkipFlag(int flag)
	{
		m_nSkipFlag = flag;
	}

	int CJobDataS::getProcessFlag()
	{
		return m_nProcessFlag;
	}

	void CJobDataS::setProcessFlag(int flag)
	{
		m_nProcessFlag = flag;
	}

	int CJobDataS::getProcessResonCode()
	{
		return m_nProcessResonCode;
	}

	void CJobDataS::setProcessResonCode(int code)
	{
		m_nProcessResonCode = code;
	}

	int CJobDataS::getLastGlassFlag()
	{
		return m_nLastGlassFlag;
	}

	void CJobDataS::setLastGlassFlag(int flag)
	{
		m_nLastGlassFlag = flag;
	}

	int CJobDataS::getFirstGlassFlag()
	{
		return m_nFirstGlassFlag;
	}

	void CJobDataS::setFirstGlassFlag(int flag)
	{
		m_nFirstGlassFlag = flag;
	}

	int CJobDataS::getQTime(int index)
	{
		if (0 <= index && index <= 2) {
			return m_nQTime[index];
		}

		return 0;
	}

	void CJobDataS::setQTime(int index, int time)
	{
		if (0 <= index && index <= 2) {
			m_nQTime[index] = time;
		}
	}

	int CJobDataS::getQTimeOverFlag()
	{
		return m_nQTimeOverFlag;
	}

	void CJobDataS::setQTimeOverFlag(int flag)
	{
		m_nQTimeOverFlag = flag;
	}

	int CJobDataS::getMasterRecipe()
	{
		return m_nMasterRecipe;
	}

	void CJobDataS::setMasterRecipe(int recipe)
	{
		m_nMasterRecipe = recipe;
	}

	short CJobDataS::getDeviceRecipeId(int nDeviceIndex) const
	{
		if (nDeviceIndex < 0 || nDeviceIndex >= DEVICE_COUNT) {
			return 0;
		}

		return m_nRecipeIds[nDeviceIndex];
	}

	void CJobDataS::setDeviceRecipeId(int nDeviceIndex, short nRecipeId)
	{
		if (nDeviceIndex < 0 || nDeviceIndex >= DEVICE_COUNT) {
			return;
		}

		m_nRecipeIds[nDeviceIndex] = nRecipeId;
	}

	const short* CJobDataS::getRecipeIds() const
	{ 
		return m_nRecipeIds;
	}

	void CJobDataS::setRecipeIds(const short* pIds, int nCount)
	{
		int nCopyCount = nCount > DEVICE_COUNT ? DEVICE_COUNT : nCount;
		for (int i = 0; i < nCopyCount; ++i) {
			m_nRecipeIds[i] = pIds[i];
		}

		// Èç¹û nCount < DEVICE_COUNT£¬¿ÉÒÔÑ¡Ôñ²¹Áã
		for (int i = nCopyCount; i < DEVICE_COUNT; ++i) {
			m_nRecipeIds[i] = 0;
		}
	}

	std::string& CJobDataS::getPanelMeasure()
	{
		return m_strPanelMeasure;
	}

	void CJobDataS::setPanelMeasure(const char* pszMeasure)
	{
		m_strPanelMeasure = pszMeasure;
	}

	int CJobDataS::getMode()
	{
		return m_nMode;
	}

	void CJobDataS::setMode(int mode)
	{
		m_nMode = mode;
	}

	int CJobDataS::getSlotUnitSelectFlag()
	{
		return m_nSlotUnitSelectFlag;
	}

	void CJobDataS::setSlotUnitSelectFlag(int flag)
	{
		m_nSlotUnitSelectFlag = flag;
	}

	int CJobDataS::getSourcePortNo()
	{
		return m_nSourcePortNo;
	}

	void CJobDataS::setSourcePortNo(int no)
	{
		m_nSourcePortNo = no;
	}

	int CJobDataS::getSourceSlotNo()
	{
		return m_nSourceSlotNo;
	}

	void CJobDataS::setSourceSlotNo(int no)
	{
		m_nSourceSlotNo = no;
	}

	int CJobDataS::getTargetPortNo()
	{
		return m_nTargetPortNo;
	}

	void CJobDataS::setTargetPortNo(int no)
	{
		m_nTargetPortNo = no;
	}

	int CJobDataS::getTargetSlotNo()
	{
		return m_nTargetSlotNo;
	}

	void CJobDataS::setTargetSlotNo(int no)
	{
		m_nTargetSlotNo = no;
	}

	short CJobDataS::getProductJudge() const
	{
		return m_nProductJudge;
	}

	void CJobDataS::setProductJudge(short nProductJudge)
	{
		m_nProductJudge = nProductJudge;
	}

	int CJobDataS::serialize(char* pszBuffer, int nBufferSize)
	{
		if (nBufferSize < 256 * 2) return -1;

		int index = 0;
		memcpy(&pszBuffer[index], &m_nCassetteSequenceNo, sizeof(short));
		index += sizeof(short);

		memcpy(&pszBuffer[index], &m_nJobSequenceNo, sizeof(short));
		index += sizeof(short);

		int strLen = min(40, (int)m_strLotId.size());
		memcpy(&pszBuffer[index], m_strLotId.c_str(), strLen);
		index += 40;

		strLen = min(20, (int)m_strProductId.size());
		memcpy(&pszBuffer[index], m_strProductId.c_str(), strLen);
		index += 20;

		strLen = min(20, (int)m_strOperationId.size());
		memcpy(&pszBuffer[index], m_strOperationId.c_str(), strLen);
		index += 20;

		strLen = min(20, (int)m_strGlass1Id.size());
		memcpy(&pszBuffer[index], m_strGlass1Id.c_str(), strLen);
		index += 20;

		strLen = min(20, (int)m_strGlass2Id.size());
		memcpy(&pszBuffer[index], m_strGlass2Id.c_str(), strLen);
		index += 20;

		memcpy(&pszBuffer[index], &m_nJobType, sizeof(short));
		index += sizeof(short);

		memcpy(&pszBuffer[index], &m_nMaterialsType, sizeof(short));
		index += sizeof(short);

		memcpy(&pszBuffer[index], &m_nProductType, sizeof(short));
		index += sizeof(short);

		memcpy(&pszBuffer[index], &m_nDummyType, sizeof(short));
		index += sizeof(short);

		memcpy(&pszBuffer[index], &m_nSkipFlag, sizeof(int));
		index += sizeof(int);
		
		memcpy(&pszBuffer[index], &m_nProcessFlag, sizeof(int));
		index += sizeof(int);

		memcpy(&pszBuffer[index], &m_nProcessResonCode, sizeof(short));
		index += sizeof(short);

		memcpy(&pszBuffer[index], &m_nLastGlassFlag, sizeof(short));
		index += sizeof(short);

		memcpy(&pszBuffer[index], &m_nFirstGlassFlag, sizeof(short));
		index += sizeof(short);

		memcpy(&pszBuffer[index], &m_nQTime[0], sizeof(short));
		index += sizeof(short);

		memcpy(&pszBuffer[index], &m_nQTime[1], sizeof(short));
		index += sizeof(short);

		memcpy(&pszBuffer[index], &m_nQTime[2], sizeof(short));
		index += sizeof(short);

		memcpy(&pszBuffer[index], &m_nQTimeOverFlag, sizeof(short));
		index += sizeof(short);

		memcpy(&pszBuffer[index], &m_nMasterRecipe, sizeof(short));
		index += sizeof(short);

		for (int i = 0; i < DEVICE_COUNT; i++) {
			memcpy(&pszBuffer[index], &m_nRecipeIds[i], sizeof(short));
			index += sizeof(short);
		}

		strLen = min(80, (int)m_strPanelMeasure.size());
		memcpy(&pszBuffer[index], m_strPanelMeasure.c_str(), strLen);
		index += 80;

		memcpy(&pszBuffer[index], &m_nMode, sizeof(short));
		index += sizeof(short);

		memcpy(&pszBuffer[index], &m_nSlotUnitSelectFlag, sizeof(short));
		index += sizeof(short);

		memcpy(&pszBuffer[index], &m_nSourcePortNo, sizeof(short));
		index += sizeof(short);

		memcpy(&pszBuffer[index], &m_nSourceSlotNo, sizeof(short));
		index += sizeof(short);

		memcpy(&pszBuffer[index], &m_nTargetPortNo, sizeof(short));
		index += sizeof(short);

		memcpy(&pszBuffer[index], &m_nTargetSlotNo, sizeof(short));
		index += sizeof(short);

		memcpy(&pszBuffer[index], &m_nProductJudge, sizeof(short));
		index += sizeof(short);

		return 256 * 2;
	}

	int CJobDataS::unserialize(const char* pszBuffer, int nBufferSize)
	{
		if (nBufferSize < JOBDATAS_SIZE) return -1;

		int index = 0;
		memcpy(&m_nCassetteSequenceNo, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		memcpy(&m_nJobSequenceNo, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		CToolUnits::convertString(&pszBuffer[index], 40, m_strLotId);
		index += 40;

		CToolUnits::convertString(&pszBuffer[index], 20, m_strProductId);
		index += 20;

		CToolUnits::convertString(&pszBuffer[index], 20, m_strOperationId);
		index += 20;

		CToolUnits::convertString(&pszBuffer[index], 20, m_strGlass1Id);
		index += 20;

		CToolUnits::convertString(&pszBuffer[index], 20, m_strGlass2Id);
		index += 20;

		memcpy(&m_nJobType, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		memcpy(&m_nMaterialsType, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		memcpy(&m_nProductType, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		memcpy(&m_nDummyType, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		memcpy(&m_nSkipFlag, &pszBuffer[index], sizeof(int));
		index += sizeof(int);

		memcpy(&m_nProcessFlag, &pszBuffer[index], sizeof(int));
		index += sizeof(int);

		memcpy(&m_nProcessResonCode, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		memcpy(&m_nLastGlassFlag, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		memcpy(&m_nFirstGlassFlag, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		memcpy(&m_nQTime[0], &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		memcpy(&m_nQTime[1], &pszBuffer[index], sizeof(short));
		index += sizeof(int);

		memcpy(&m_nQTime[2], &pszBuffer[index], sizeof(int));
		index += sizeof(short);

		memcpy(&m_nQTimeOverFlag, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		memcpy(&m_nMasterRecipe, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		for (int i = 0; i < DEVICE_COUNT; i++) {
			memcpy(&m_nRecipeIds[i], &pszBuffer[index], sizeof(short));
			index += sizeof(short);
		}

		CToolUnits::convertString(&pszBuffer[index], 80, m_strPanelMeasure);
		index += 80;

		memcpy(&m_nMode, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		memcpy(&m_nSlotUnitSelectFlag, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		memcpy(&m_nSourcePortNo, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		memcpy(&m_nSourceSlotNo, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		memcpy(&m_nTargetPortNo, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		memcpy(&m_nTargetSlotNo, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		memcpy(&m_nProductJudge, &pszBuffer[index], sizeof(short));
		index += sizeof(short);

		// »º´æԭʼÊý¾Ý
		if (m_pRawData != nullptr) {
			memcpy(m_pRawData, pszBuffer, JOBDATAS_SIZE);
		}

		return JOBDATAS_SIZE;
	}

	void CJobDataS::getAttributeVector(CAttributeVector& attrubutes, int beginWeight)
	{
		unsigned int weight = beginWeight;
		std::string strTemp;

		attrubutes.addAttribute(new CAttribute("CassetteSequenceNo",
			std::to_string(getCassetteSequenceNo()).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("JobSequenceNo",
			std::to_string(getJobSequenceNo()).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("LotId",
			getLotId().c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("ProductId",
			getProductId().c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("OperationId",
			getOperationId().c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("Glass1Id",
			getGlass1Id().c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("Glass2Id",
			getGlass2Id().c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("JobType",
			std::to_string(getJobType()).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("MaterialsType",
			std::to_string(getMaterialsType()).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("ProductType",
			std::to_string(getProductType()).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("DummyType",
			std::to_string(getDummyType()).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("SkipFlag",
			std::to_string(getSkipFlag()).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("ProcessFlag",
			std::to_string(getProcessFlag()).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("ProcessResonCode",
			std::to_string(getProcessResonCode()).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("LastGlassFlag",
			std::to_string(getLastGlassFlag()).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("FirstGlassFlag",
			std::to_string(getFirstGlassFlag()).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("QTime1",
			std::to_string(getQTime(0)).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("QTime2",
			std::to_string(getQTime(1)).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("QTime3",
			std::to_string(getQTime(2)).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("QTimeOverFlag",
			std::to_string(getQTimeOverFlag()).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("MasterRecipe",
			std::to_string(getMasterRecipe()).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("Recipe ID(EFEM)",
			std::to_string(getDeviceRecipeId(0)).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("Recipe ID(BONDER1)",
			std::to_string(getDeviceRecipeId(1)).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("Recipe ID(BONDER2)",
			std::to_string(getDeviceRecipeId(2)).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("Recipe ID(Bake Cooling)",
			std::to_string(getDeviceRecipeId(3)).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("Recipe ID(Vacuum Bake)",
			std::to_string(getDeviceRecipeId(4)).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("Recipe ID(Measurement)",
			std::to_string(getDeviceRecipeId(5)).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("PanelMeasure",
			getPanelMeasure().c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("SlotUnitSelectFlag",
			std::to_string(getSlotUnitSelectFlag()).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("SourcePortNo",
			std::to_string(getSourcePortNo()).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("SourceSlotNo",
			std::to_string(getSourceSlotNo()).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("TargetPortNo",
			std::to_string(getTargetPortNo()).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("TargetSlotNo",
			std::to_string(getTargetSlotNo()).c_str(), "", weight++));

		attrubutes.addAttribute(new CAttribute("ProductJudge",
			std::to_string(getProductJudge()).c_str(), "", weight++));
	}
}