OTS/OTS_GB/OTSInterface/ElementClr.cpp

#include "stdafx.h"
#include "ElementClr.h"
#include "otsdataconst.h"


namespace OTSINTERFACE {

	CElementClr::CElementClr()
	{		
		m_LpElement = new CElementPtr(new CElement());
	}
	CElementClr::CElementClr(long a_nAtomNum)						// constructor
	{
		
		ASSERT(a_nAtomNum);
		if (!a_nAtomNum)
		{
		LogErrorTrace(__FILE__, __LINE__, _T("CElementClr: Generate CElementClr pointer failed."));
		return;
		}

		m_LpElement = new CElementPtr(new CElement(a_nAtomNum));
	}
	CElementClr::CElementClr(CString a_strName)					// constructor
	{															// initialization		
		ASSERT(a_strName);
		if (!a_strName)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CElementClr: Generate CElementClr pointer failed."));
			return;
		}

		m_LpElement = new CElementPtr(new CElement(a_strName));

	}

	
	CElementClr::CElementClr(CElementPtr a_pElement)							// copy constructor
	{
		
		ASSERT(a_pElement);
		if (!a_pElement)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CElementClr: Generate CElementClr pointer failed."));
			return;
		}

	
			m_LpElement = new CElementPtr(a_pElement);
	
	}
	
	CElementClr::CElementClr(CElement* a_pSource)							// copy constructor
	{
		ASSERT(a_pSource);
		if (!a_pSource)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("CElementClr: Generate CElementClr pointer failed."));
			return;
		}

		m_LpElement = new CElementPtr(new CElement(a_pSource));
	}
	CElementClr::~CElementClr()
	{
		if (m_LpElement != nullptr)
		{
			delete m_LpElement;
			m_LpElement = nullptr;
		}
	}

	CElementClr::!CElementClr()
	{
		if (m_LpElement != nullptr)
		{
			delete m_LpElement;
			m_LpElement = nullptr;
		}
	}

	CElementPtr CElementClr::GetElementPtr()
	{		
		return *m_LpElement;
	}

	
	// valid element
	bool CElementClr::IsValid()
	{
		CElementPtr pElement = GetElementPtr();
		ASSERT(pElement);
		if (!pElement)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("IsValid:can't genertate pointer."));
			return false;
		}

		bool bRet = pElement->IsValid();

		return bRet;
	}

	int CElementClr::GetAtomNum()
	{
		int nAtomNum = -1;

		if (m_LpElement != nullptr)
		{
			nAtomNum = m_LpElement->get()->GetAtomNum();
		}

		return nAtomNum;
	}

	// atomic number
	bool CElementClr::SetAtomNum(int a_nAtomNum)
	{

		CElementPtr pElement = GetElementPtr();
		ASSERT(pElement);
		if (!pElement)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetAtomNum:can't genertate pointer."));
			return false;
		}

		pElement->SetAtomNum(a_nAtomNum);
		
		return true;
	}

	double CElementClr::GetPercentage()
	{
		double nPercentage = -1;

		if (m_LpElement != nullptr)
		{
			nPercentage =m_LpElement->get()->GetPercentage();
		}

		return nPercentage;
	}

	// percentage
	bool CElementClr::SetPercentage(double a_dPercentage)
	{
		CElementPtr pElement = GetElementPtr();
		ASSERT(pElement);
		if (!pElement)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("SetPercentage:can't genertate pointer."));
			return false;
		}

		pElement->SetPercentage(a_dPercentage);

	
		return true;
	}

	// name
	String^ CElementClr::GetName()
	{

		CElementPtr pElement = GetElementPtr();
		ASSERT(pElement);
		if (!pElement)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetName:can't genertate pointer."));
			return nullptr;
		}

		CString sName = pElement->GetName();
		
		String^ sNameClr = gcnew String(sName);

		return sNameClr;
	}
	String^ CElementClr::GetName(long a_nAtomNum)
	{

		CString sName = CElement::GetName(a_nAtomNum);
	
		String^ sNameClr = gcnew String(sName);

		return sNameClr;
	}

	// atomic weight
	double CElementClr::GetAtomWeight()
	{

		CElementPtr pElement = GetElementPtr();
		ASSERT(pElement);
		if (!pElement)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetAtomWeight:can't genertate pointer."));
			return -1;
		}

		double fWeight = pElement->GetAtomWeight();
		
		return fWeight;
	}
	double CElementClr::GetAtomWeight(long a_nAtomNum)
	{
		double fWeight = CElement::GetAtomWeight(a_nAtomNum);

		return fWeight;
	}

	// energy values
	double CElementClr::GetEnergyValueK()
	{

		CElementPtr pElement = GetElementPtr();
		ASSERT(pElement);
		if (!pElement)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetEnergyValueK:can't genertate pointer."));
			return -1;
		}

		double fEnergyValueK = pElement->GetEnergyValueK();

		return fEnergyValueK;
	}
	double CElementClr::GetEnergyValueK(long a_nAtomNum)
	{
		double fEnergyValueK = CElement::GetEnergyValueK(a_nAtomNum);

		return fEnergyValueK;
	}
	double CElementClr::GetEnergyValueL()
	{

		CElementPtr pElement = GetElementPtr();
		ASSERT(pElement);
		if (!pElement)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetEnergyValueL:can't genertate pointer."));
			return -1;
		}

		double fEnergyValueL = pElement->GetEnergyValueL();



		return fEnergyValueL;
	}
	double CElementClr::GetEnergyValueL(long a_nAtomNum)
	{

		double fEnergyValueL = CElement::GetEnergyValueL(a_nAtomNum);

		return fEnergyValueL;
	}
	double CElementClr::GetEnergyValueM()
	{
		CElementPtr pElement = GetElementPtr();
		ASSERT(pElement);
		if (!pElement)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetEnergyValueM:can't genertate pointer."));
			return -1;
		}

		double fEnergyValueM = pElement->GetEnergyValueL();


		return fEnergyValueM;
	}
	double CElementClr::GetEnergyValueM(long a_nAtomNum)
	{
		double fEnergyValueM = CElement::GetEnergyValueL(a_nAtomNum);

		return fEnergyValueM;
	}
	bool CElementClr::GetEnergyValues(System::Collections::Generic::List<double>% a_listEnergy)
	{
	
		CElementPtr pElement = GetElementPtr();
		ASSERT(pElement);
		if (!pElement)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetEnergyValues:can't genertate pointer."));
			return false;
		}

		std::vector<double> listEngery =  pElement->GetEnergyValues();
		
		for (auto dEnger : listEngery)
		{
			a_listEnergy.Add(dEnger);
		}

		return true;
	}
	bool CElementClr::GetEnergyValues(long a_nAtomNum,System::Collections::Generic::List<double> a_listEngergy)
	{

		CElementPtr pElement = GetElementPtr();
		ASSERT(pElement);
		if (!pElement)
		{
			LogErrorTrace(__FILE__, __LINE__, _T("GetEnergyValues:can't genertate pointer."));
			return false;
		}

		std::vector<double> listEngery = CElement::GetEnergyValues(a_nAtomNum);

		for (auto dEnger : listEngery)
		{
			a_listEngergy.Add(dEnger);
		}

		return true;
	}

	// atomic number validation
	bool CElementClr::IsValidAtomNum(long a_nAtomNum)
	{

		bool bRet = CElement::IsValidAtomNum(a_nAtomNum);

		return bRet;
	}	
}