OTS/OTSCPP/OTSRptCalculate/Model/MsrParams.cpp

// MsrParams.cpp : implementation file
//

#include "stdafx.h"
#include "OTSData.h"
#include "MsrParams.h"

namespace OTSMODEL {

	// CMsrParams


	// constructor
	CMsrParams::CMsrParams()
	{
		// initialization
		Init();
	}

	// copy constructor
	CMsrParams::CMsrParams(const CMsrParams& a_oSource)
	{
		// can't copy itself
		if (&a_oSource == this)
		{
			return;
		}

		// copy data over
		Duplicate(a_oSource);
	}

	// copy constructor
	CMsrParams::CMsrParams(CMsrParams* a_poSource)
	{
		// input check
		ASSERT(a_poSource);
		if (!a_poSource)
		{
			return;
		}

		// can't copy itself
		if (a_poSource == this)
		{
			return;
		}

		// copy data over
		Duplicate(*a_poSource);
	}

	// =operator	
	CMsrParams& CMsrParams::operator=(const CMsrParams& a_oSource)
	{
		// cleanup
		Cleanup();

		// copy the class data over
		Duplicate(a_oSource);

		// return class
		return *this;
	}

	// ==operator
	BOOL CMsrParams::operator==(const CMsrParams& a_oSource)
	{
		// members
		return m_strName.Compare(a_oSource.m_strName) == 0 && 
			//*(m_poPartSTDData.get()) == *(a_oSource.m_poPartSTDData.get()) &&
			*(m_poImageScanParam.get()) == *(a_oSource.m_poImageScanParam.get()) &&
			*(m_poImageProcessParam.get()) == *(a_oSource.m_poImageProcessParam.get()) &&
			*(m_poXRayParam.get()) == *(a_oSource.m_poXRayParam.get());
	}

	// destructor
	CMsrParams::~CMsrParams()
	{
		// cleanup
		Cleanup();
	}

	// CMsrParams member functions
	// public

	// serialization
	

	void CMsrParams::Serialize(bool isStoring, tinyxml2::XMLDocument * classDoc, tinyxml2::XMLElement * rootNode)
	{
		xmls::xString xstrName;
		xmls::xInt xSteelTech;
		xmls::Slo slo;

		//this->Register("Name", &xstrName);
		slo.Register("SteelTech", &xSteelTech);
		slo.Register("ImageScanParam", m_poImageScanParam.get());
		slo.Register("ImageProcessParam", m_poImageProcessParam.get());
		slo.Register("XRayParam", m_poXRayParam.get());

		if (isStoring)
		{
			xstrName = m_strName;
			xSteelTech = (int)m_SteelTech;

			slo.Serialize(true, classDoc, rootNode);
		}
		else
		{
			slo.Serialize(false, classDoc, rootNode);

			m_strName = xstrName.value().c_str();
			m_SteelTech = (STEEL_TECHNOLOGY)xSteelTech.value();
		}
	}



	// image scan parameter
	void CMsrParams::SetImageScanParam(COTSImageScanParamPtr a_poImageScanParam)
	{
		// make sure that image scan parameter always valid 
		ASSERT(a_poImageScanParam);
		if(!a_poImageScanParam)
		{ 
			return;
		}
		m_poImageScanParam = COTSImageScanParamPtr(new COTSImageScanParam(a_poImageScanParam.get()));
	}

	// image process parameter
	void CMsrParams::SetImageProcessParam(COTSImageProcessParamPtr a_poImageProcessParam)
	{
		// make sure that image process parameter always valid 
		ASSERT(a_poImageProcessParam);
		if(!a_poImageProcessParam)
		{ 
			return;
		}
		
		m_poImageProcessParam = COTSImageProcessParamPtr(new COTSImageProcessParam( a_poImageProcessParam.get()));
		
	}

	// x-ray parameter 
	void CMsrParams::SetXRayParam(COTSXRayParamPtr a_poXRayParam)
	{
		// make sure that x-ray parameter always valid 
		ASSERT(a_poXRayParam);
		if(!a_poXRayParam)
		{ 
			return;
		}
		
		m_poXRayParam = COTSXRayParamPtr(new COTSXRayParam( a_poXRayParam.get()));
		
	}

	// protected

	// cleanup 
	void CMsrParams::Cleanup()
	{
		// need to do nothing at the moment
	}

	// initialization
	void CMsrParams::Init()
	{
		// initialization
		m_strName = _T("MsrParam");
		m_SteelTech = STEEL_TECHNOLOGY::GeneralProcessMode;
		m_poImageScanParam = COTSImageScanParamPtr(new COTSImageScanParam());
		m_poImageProcessParam = COTSImageProcessParamPtr(new COTSImageProcessParam());
		m_poXRayParam = COTSXRayParamPtr(new COTSXRayParam());
	}

	// duplication 
	void CMsrParams::Duplicate(const CMsrParams& a_oSource)
	{
		// initialization
		Init();

		// copy data over
		m_strName = a_oSource.m_strName;
		m_SteelTech = a_oSource.m_SteelTech;
		m_poImageScanParam = a_oSource.m_poImageScanParam;
		m_poImageProcessParam = a_oSource.m_poImageProcessParam;
		m_poXRayParam = a_oSource.m_poXRayParam;
	}

}