#pragma once

class CStringRawItem_Sharp
{
public:
	CStringRawItem_Sharp()
	{
		m_pstrName		= NULL;
		m_nNameLen		= 0;
		m_bIsEnd		= FALSE;
	}
	~CStringRawItem_Sharp()
	{
		if (m_pstrName)
			delete [] m_pstrName;
		m_pstrName = NULL;
		m_nNameLen = 0;
	}
	void ResetString()
	{
		if (!m_pstrName || m_nNameLen < 1)
			return;

		for (int i = 0; i < m_nNameLen-1; i++)
			m_pstrName[i] = 0x20;
		m_pstrName[m_nNameLen-1] = NULL;
	}
	BOOL SetLength(int nLen)
	{
		m_nNameLen = nLen + 1;
		if (m_pstrName)
			delete [] m_pstrName;
		m_pstrName = new char[m_nNameLen];

		ResetString();

		return TRUE;
	}
	int				GetLength()
	{
		if (!m_pstrName)
			return -1;

		return m_nNameLen-1;
	}
	BOOL			SetName(char* strName)
	{
		SetLength((int)strlen(strName));

		if (!m_pstrName)
			return FALSE;

		for (int i = 0; i < (int)strlen(strName); i++)
		{
			if(strName[i] == 0x20)		//" "
				m_pstrName[i] = 0x5f;	//"_"
			else
				m_pstrName[i] = strName[i];
		}

		return TRUE;
	}
	char*			GetName()
	{
		return m_pstrName;
	}
	BOOL			WriteToFileName(FILE *fp)
	{
		if (!fp || !m_pstrName)
			return FALSE;

		fprintf(fp, "%s", m_pstrName);

		return TRUE;
	}
protected:
	char*			m_pstrName;
	int				m_nNameLen;
	BOOL			m_bIsEnd;
};

class CStringRawData_Sharp
{
public:
	CStringRawData_Sharp()
	{
		m_pstrData		= NULL;
		m_nDataLen		= 0;
	}
	~CStringRawData_Sharp()
	{
		if (m_pstrData)
			delete [] m_pstrData;
		m_pstrData = NULL;
		m_nDataLen = 0;
	}
	CStringRawData_Sharp(const CStringRawData_Sharp& rhs)
	{
		m_pstrData		= NULL;
		m_nDataLen		= 0;

		if (this != &rhs && rhs.m_nDataLen > 0)
		{
			SetLength(rhs.m_nDataLen - 1);
			strcpy_s(m_pstrData,rhs.m_nDataLen, rhs.m_pstrData);
		}
	}
	CStringRawData_Sharp& operator=(const CStringRawData_Sharp& rhs)
	{
		if (this != &rhs)
		{
			SetLength(rhs.m_nDataLen - 1);
			strcpy_s(m_pstrData,rhs.m_nDataLen, rhs.m_pstrData);
		}
		return *this;
	}
	void ResetString()
	{
		if (!m_pstrData || m_nDataLen < 1)
			return;

		for (int i = 0; i < m_nDataLen - 1; i++)
			m_pstrData[i] = 0x20;
		m_pstrData[m_nDataLen - 1] = NULL;
	}
	BOOL SetLength(int nLen)
	{
		m_nDataLen = nLen + 1;
		if (m_pstrData)
			delete [] m_pstrData;
		m_pstrData = new char[m_nDataLen];

		ResetString();

		return TRUE;
	}
	BOOL SetData(char* strData)
	{
		SetLength((int)strlen(strData));

		if (!m_pstrData)
			return FALSE;

		for (int i = 0; i < (int)strlen(strData); i++)
		{
			if(strData[i] == 0x20)		//" "
				m_pstrData[i] = 0x5f;	//"_"
			else
				m_pstrData[i] = strData[i];
		}

		return TRUE;
	}
	BOOL SetData(int nData)
	{
		char str[14] = {0, };
		sprintf_s(str, "%d", nData);

		SetLength((int)strlen(str));

		if (!m_pstrData)
			return FALSE;

		for (int i = 0; i < (int)strlen(str); i++)
			m_pstrData[i] = str[i];

		return TRUE;
	}

	// [2017/07/28 16:02:27 by jylee] related Dight ¼³Á¤
	BOOL SetData(double dData, int nDecimal=0, int nDigit = 0)
	{
		char str[14] = {0, };

		char strTemp[10] = {0, };

		if( nDecimal == 0 && nDigit == 0 )
		{
			nDecimal = 2;
			nDigit = 3;
		}
		sprintf_s( strTemp, "%%%d.%df", nDecimal, nDigit );
		sprintf_s(str, strTemp, dData);
		///sprintf_s(str, "%2.3f", dData);

		SetLength((int)strlen(str));

		if (!m_pstrData)
			return FALSE;

		for (int i = 0; i < (int)strlen(str); i++)
			m_pstrData[i] = str[i];

		return TRUE;
	}

	char* GetData()
	{
		return m_pstrData;
	}
	int GetLength()
	{
		return m_nDataLen - 1;
	}
	BOOL WriteToFileData(FILE *fp)
	{
		if (!fp || !m_pstrData || m_nDataLen == 0)
			return FALSE;

		fprintf_s(fp, "%s", m_pstrData);

		return TRUE;
	}
	BOOL WriteToFileData(CFile &fp)
	{
		if (!m_pstrData || m_nDataLen == 0)
			return FALSE;

		fp.Write(m_pstrData, m_nDataLen-1);

		return TRUE;
	}
protected:
	char*	m_pstrData;
	int		m_nDataLen;
};


#include <vector>

using namespace std;

typedef std::vector<CStringRawData_Sharp*>						VectorStringSharpRawData;
typedef std::vector<CStringRawData_Sharp*>::iterator			VectorStringSharpRawDataIt;
typedef std::vector<CStringRawData_Sharp*>::const_iterator		constVectorStringSharpRawDataIt;

class CSharpRawData
{
public:
	CSharpRawData()
	{
		m_nLineIdx = 0;
		m_nDataIdx = 0;
	}
	virtual ~CSharpRawData()
	{
		m_vecData.clear();
	}

	int							m_nLineIdx;
	int							m_nDataIdx;
	VectorStringSharpRawData	m_vecData;
};

typedef std::vector<CSharpRawData*>							VectorSharpRaw;
typedef std::vector<CSharpRawData*>::iterator				VectorSharpRawIt;
typedef std::vector<CSharpRawData*>::const_iterator			constVectorSharpRawIt;

class CVectorSharpRaw : public VectorSharpRaw
{
public:
	CVectorSharpRaw(){}
	virtual ~CVectorSharpRaw()
	{
		Delete();
	}

	void Delete()
	{
		VectorSharpRawIt it;
		CSharpRawData *pNode;
		for (it = begin(); it!=end(); it++)
		{
			pNode = (*it);
			delete pNode;
		}
		clear();
	}
};