#include "stdafx.h"
#include "PartSizeClass.h"
#include "otsdataconst.h"
namespace OTSMODEL {

	// CPartSizeClass
	using namespace OTSDATA;

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

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

		// copy data over
		Duplicate(a_oSource);
	}

	// copy constructor
	CPartSizeClass::CPartSizeClass(CPartSizeClass* 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	
	CPartSizeClass& CPartSizeClass::operator=(const CPartSizeClass& a_oSource)
	{
		// cleanup
		Cleanup();

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

		// return class
		return *this;
	}

	// ==operator
	BOOL CPartSizeClass::operator==(const CPartSizeClass& a_oSource)
	{
		// class data list
		int nSize = (int)m_listSizeClass.size();
		if (nSize != (int)a_oSource.m_listSizeClass.size())
		{
			return FALSE;
		}
		for (int i = 0; i < nSize; ++i)
		{
			if (abs(m_listSizeClass[i] - a_oSource.m_listSizeClass[i]) > MIN_DOUBLE_VALUE)
			{
				return FALSE;
			}
		}

		// members
		return m_strName.Compare(a_oSource.m_strName) == 0;
	}

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

	// CPartSizeClass member functions

	// public

	// serialization

	void CPartSizeClass::Serialize(bool isStoring, tinyxml2::XMLDocument * classDoc, tinyxml2::XMLElement * rootNode)
	{
		xmls::xString xstrName;
		xmls::xString  xSizeStr;
		xmls::Slo slo;
		slo.Register("Name", &xstrName);
		slo.Register("SizeClass", &xSizeStr);
		if (isStoring)
		{
			xstrName = m_strName;
			CString sizeStr;
			CString ss;
			for (unsigned int i = 0; i < m_listSizeClass.size(); i++)
			{
				ss.Format ("%.4lf",m_listSizeClass[i]);
				if (i < m_listSizeClass.size())
				{
					sizeStr += ss + ",";
				}
				else
				{
					sizeStr += ss;
				}
				
			}
			xSizeStr = sizeStr;
			slo.Serialize(true, classDoc, rootNode);
		}
		else
		{
			slo.Serialize(false, classDoc, rootNode);

			m_strName = xstrName.value().c_str();
			std::vector <std::string> strvector;
			xmls::SplitString(xSizeStr.value(), strvector, ",");
			m_listSizeClass.clear();
			for (unsigned int i = 0; i < strvector.size(); i++)
			{
				m_listSizeClass.push_back(atof(strvector[i].c_str()));
			}
		}
	}

	// validation
	BOOL CPartSizeClass::IsValid()
	{
		// name can't be an empty string
		m_strName.Trim();
		if (m_strName.IsEmpty())
		{
			return FALSE;
		}

		// class data list can't be empty
		if (m_listSizeClass.empty())
		{
			return FALSE;
		}

		// ok, return TRUE
		return TRUE;
	}

	// protected

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

	// initialization
	void CPartSizeClass::Init()
	{
		// initialization
		m_strName = _T("");
		m_listSizeClass.clear();
	}

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

		// copy data over
		m_strName = a_oSource.m_strName;
		m_listSizeClass = a_oSource.m_listSizeClass;
	}
}