#pragma once
#include "stdafx.h"
#include "PartSizeItem.h"
#include "DoubleRange.h"
namespace OTSMODEL {
	using namespace OTSDATA;
	const double __declspec(dllexport) PART_LAST_NUMBER = (std::numeric_limits<int>::max)();

	// CPartSizeItem


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

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

		// copy data over
		Duplicate(a_oSource);
	}

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

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

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

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

		// return class
		return *this;
	}

	// ==operator
	BOOL CPartSizeItem::operator==(const CPartSizeItem& a_oSource)
	{
		// members
		return m_strName.Compare(a_oSource.m_strName) == 0 &&
			*(m_poSizeLevel.get()) == *(a_oSource.m_poSizeLevel.get());
	}

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

	// CPartSizeItem member functions

	// public

	// serialization
	
	void CPartSizeItem::Serialize(bool isStoring, tinyxml2::XMLDocument * classDoc, tinyxml2::XMLElement * rootNode)
	{
		xmls::xString xstrName;
		xmls::Slo slo;
		slo.Register("Name", &xstrName);

		if (isStoring)
		{
			xstrName = m_strName;

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

			m_strName = xstrName.value().c_str();
		}
	}

	/*// serialization
	void CPartSizeItem::Serialize(double start,double end)
	{
		
		if (end != PART_LAST_NUMBER)
		{
			m_strName = start + "-" + end;
		}
		else {
			m_strName = start + "-";
		}
		


		// member object
		m_poSizeLevel->Serialize(start, end);

		// base object serialization 
		CObject::Serialize(ar);
	}
	*/


	void CPartSizeItem::BuildList(double start, double end)
	{

		if (end != PART_LAST_NUMBER)
		{
			CString cstr_start = _T ("");
			CString cstr_end = _T("");
			if ((start - (int)start) == 0)
			{
				//小数位为零
				cstr_start.Format(_T("%.0f"), start);
			}
			else
			{
				cstr_start.Format(_T("%0.1lf"), start);
			}
			if ((end - (int)end) == 0)
			{
				//小数位为零
				cstr_end.Format(_T("%.0f"), end);
			}
			else
			{
				cstr_end.Format(_T("%0.1lf"), end);
			}

			m_strName = cstr_start + _T(" ~ ") + cstr_end;
			
		}
		else 
		{
			if ((start - (int)start) == 0)
			{
				//小数位为零
				m_strName.Format(_T("%.0f ~ Max"), start);
			}
			else
			{
				m_strName.Format(_T("%0.1lf ~ Max"), start);
			}
		}

		CDoubleRangePtr poSizeLevel = CDoubleRangePtr(new CDoubleRange());
		poSizeLevel->SetEnd(end);
		poSizeLevel->SetStart(start);
		SetSizeLevel(poSizeLevel);
		// member object
		//m_poSizeLevel->Serialize(start, end);

		// base object serialization 
		//CObject::Serialize(ar);
	}
	// element ranges list
	void CPartSizeItem::SetSizeLevel(CDoubleRangePtr a_poSizeLevel)
	{
		ASSERT(a_poSizeLevel);
		if (!a_poSizeLevel)
		{
			return;
		}

		m_poSizeLevel = CDoubleRangePtr(new CDoubleRange(*a_poSizeLevel.get()));
	}

	// protected

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

	// initialization
	void CPartSizeItem::Init()
	{
		// initialization
		m_strName = _T("");
		m_poSizeLevel = CDoubleRangePtr(new CDoubleRange());
	}

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

		// copy data over
		m_strName = a_oSource.m_strName;	
		m_poSizeLevel = CDoubleRangePtr(new CDoubleRange(a_oSource.m_poSizeLevel.get()));		
	}

}