PhysicalDevice/Deliver/Include/CCOS.Dev.MouldDefine.hpp

#pragma once
#include <string>
using namespace std;
#include "TmplMould.tlh"
#include "TmplMould.tli"
#include "ResDataObject.h"

namespace DIOS::Dev::Detail
{
	namespace ValKey
	{
		static const char* UNIT = "Unit";
		static const char* UPPERLIMIT = "Upperlimit";
		static const char* LOWERLIMIT = "Lowerlimit";
		static const char* WARNUPPERLIMIT = "WARNUpperlimit";
		static const char* WARNLOWERLIMIT = "WARNLowerlimit";
		static const char* INITIALVALUE = "Initialvalue";
		static const char* ACCURACY = "Accuracy";
		static const char* LIST = "LIST";
	}

//-----------------------------------------------------------------------------
//		IntMould
//-----------------------------------------------------------------------------
	class IntMould : public TmplMould <int>
	{
		using super = TmplMould <int>;

	public:
		IntMould(const char* strkey, int initialvalue, int min, int max, int accuracy)
			:super(initialvalue, min, max, accuracy)
		{
			Key = strkey;
			m_Value = initialvalue;
		}
		~IntMould() {}
		std::string GetDescription()
		{
			ResDataObject temp, result;
			temp.add(ValKey::UPPERLIMIT, m_LimitMax);
			temp.add(ValKey::LOWERLIMIT, m_LimitMin);
			temp.add(ValKey::ACCURACY, m_Accuracy);
			result.add(Key.c_str(), temp);
			return result.encode();
		}
		std::string GetAttribute()
		{
			ResDataObject temp;
			temp.add(Key.c_str(), (int)m_Value);
			return temp.encode();
		}
		//
		std::string JSGet()
		{
			return std::to_string(m_Value);
		}
		std::string GetKey()
		{
			return Key;
		}
	protected:
		std::string Key;
	};

	//-----------------------------------------------------------------------------
	//		FloatMould
	//-----------------------------------------------------------------------------
	class FloatMould : public TmplMould <float>
	{
		using super = TmplMould <float>;

	public:
		FloatMould(const char* strkey, float initialvalue, float min, float max, float accuracy)
			:super(initialvalue, min, max, accuracy)
		{
			Key = strkey;
			m_Value = initialvalue;
		}

		~FloatMould() {}

		std::string GetDescription()
		{
			ResDataObject temp, result;
			temp.add(ValKey::UPPERLIMIT, m_LimitMax);
			temp.add(ValKey::LOWERLIMIT, m_LimitMin);
			temp.add(ValKey::ACCURACY, m_Accuracy);
			result.add(Key.c_str(), temp);
			return result.encode();
		}
		std::string GetAttribute()
		{
			ResDataObject temp;
			temp.add(Key.c_str(), (int)m_Value);
			return temp.encode();
		}
		std::string JSGet()
		{
			return std::to_string(m_Value);
		}
		std::string GetKey()
		{
			return Key;
		}
	protected:
		std::string Key;
	};

	//-----------------------------------------------------------------------------
	//		IntMould
	//-----------------------------------------------------------------------------
	class IntMouldWithWarn : public TmplMouldWithWarn <int>
	{
		using super = TmplMouldWithWarn <int>;

	public:
		IntMouldWithWarn(const char* strkey, int initialvalue, int min, int WarnMin, int WarnMax, int CalibWarnMin, int CalibWarnMax, int max, int accuracy)
			:super(initialvalue, min, WarnMin, WarnMax, CalibWarnMin, CalibWarnMax, max, accuracy)
		{
			Key = strkey;
			m_Value = initialvalue;
		}
		~IntMouldWithWarn() {}
		std::string GetDescription()
		{
			ResDataObject temp, result;
			temp.add(ValKey::UPPERLIMIT, m_LimitMax);
			temp.add(ValKey::LOWERLIMIT, m_LimitMin);
			temp.add(ValKey::WARNUPPERLIMIT, m_WarningMax);
			temp.add(ValKey::WARNLOWERLIMIT, m_WarningMin);
			temp.add(ValKey::ACCURACY, m_Accuracy);
			result.add(Key.c_str(), temp);
			return result.encode();
		}
		std::string GetAttribute()
		{
			ResDataObject temp;
			temp.add(Key.c_str(), (int)m_Value);
			return temp.encode();
		}
		//
		std::string JSGet()
		{
			return std::to_string(m_Value);
		}
		std::string GetKey()
		{
			return Key;
		}
	protected:
		std::string Key;
	};

	//-----------------------------------------------------------------------------
	//		FloatMould
	//-----------------------------------------------------------------------------
	class FloatMouldWithWarn : public TmplMouldWithWarn <float>
	{
		using super = TmplMouldWithWarn <float>;

	public:
		FloatMouldWithWarn(const char* strkey, float initialvalue, float min, float WarnMin, float WarnMax, float CalibWarnMin, float CalibWarnMax, float max, float accuracy)
			:super(initialvalue, min, WarnMin, WarnMax, CalibWarnMin, CalibWarnMax, max, accuracy)
		{
			Key = strkey;
			m_Value = initialvalue;
		}

		~FloatMouldWithWarn() {}

		std::string GetDescription()
		{
			ResDataObject temp, result;
			temp.add(ValKey::UPPERLIMIT, m_LimitMax);
			temp.add(ValKey::LOWERLIMIT, m_LimitMin);
			temp.add(ValKey::WARNUPPERLIMIT, m_WarningMax);
			temp.add(ValKey::WARNLOWERLIMIT, m_WarningMin);
			temp.add(ValKey::ACCURACY, m_Accuracy);
			result.add(Key.c_str(), temp);
			return result.encode();
		}
		std::string GetAttribute()
		{
			ResDataObject temp;
			temp.add(Key.c_str(), (int)m_Value);
			return temp.encode();
		}
		std::string JSGet()
		{
			return std::to_string(m_Value);
		}
		std::string GetKey()
		{
			return Key;
		}
	protected:
		std::string Key;
	};
}
// ---------------------------------------------------------------------------- -
//		StringMould
//-----------------------------------------------------------------------------
class StringMould
{
public:
	StringMould(const char* strkey, std::string initialvalue)
	{
		Key = strkey;
		m_Value = initialvalue;
	}
	~StringMould() {}
	std::string GetDescription()
	{
		ResDataObject result;
		result.add(Key.c_str(), "");
		return result.encode();
	}
	std::string GetAttribute()
	{
		ResDataObject temp;
		temp.add(Key.c_str(), m_Value.c_str());
		return temp.encode();
	}
	//
	std::string JSGet()
	{
		return m_Value;
	}
	std::string GetKey()
	{
		return Key;
	}

	bool Update(std::string value)
	{
		if (m_Value != value)
		{
			m_Value = value;
			return true;
		}
		else
		{
			return false;
		}
	}
protected:
	std::string Key;
	std::string m_Value;
};