Deliver/include/TmplMould.tli

//

#pragma once

#include "TmplMould.tlh"


//-----------------------------------------------------------------------------
//		TmplMould
//-----------------------------------------------------------------------------

namespace DIOS::Dev::Detail
{
	template <typename T>
	bool TmplMould <T>::CanInc () const
	{
		return m_Value < m_LimitMax;
	}

	template <typename T>
	bool TmplMould <T>::CanDec () const
	{
		return m_Value > m_LimitMin; 
	}

	template <typename T>
	bool TmplMould <T>::Verify (T value) const
	{
		return (m_LimitMin <= value && value <= m_LimitMax);
	}

	template <typename T>
	bool TmplMould <T>::Inc ()
	{
		if (m_Value >= m_LimitMax)  return false;
		m_Value += m_Accuracy;
		return true;
	}

	template <typename T>
	bool TmplMould <T>::Dec ()
	{
		if (m_Value <= m_LimitMin)  return false;
		m_Value -= m_Accuracy;
		return true;
	}

	template <typename T>
	bool TmplMould <T>::Update (T value)
	{
		if (value < m_LimitMin)  return false;
		if (value > m_LimitMax)  return false;
		if(value== m_Value)      return false;
		m_Value = value;
		return true;
	}

	template <typename T>
	bool TmplMould <T>::UpdateLimitMax(T value)
	{
		m_LimitMax = value;
		return true;
	}

	template <typename T>
	bool TmplMould <T>::UpdateLimitMin(T value)
	{
		m_LimitMin = value;
		return true;
	}

	template <typename T>
	T TmplMould <T>::Get () const { return m_Value; }

	template <typename T>
	T TmplMould <T>::GetLimitMax() const { return m_LimitMax; }

	template <typename T>
	T TmplMould <T>::GetLimitMin() const { return m_LimitMin; }

	//change by wxx for 万东:丰富基类方法(要求ar按从小到大排列) 20230803
	template <typename T>
	bool TmplMould <T>::CanToNext(T & value, const std::vector <typename T>& ar)
	{
		value = m_Value;
		int setSize = ar.size();
		for (int i = 0; i < setSize; i++)
		{
			if (ar[i] == value)
			{
				if (i < setSize - 1)
				{
					value = ar[i + 1];
					return (m_LimitMin <= value && value <= m_LimitMax);
				}
			}
			else if (ar[i] - value > FLT_MIN)
			{
				value = ar[i];
				return (m_LimitMin <= value && value <= m_LimitMax);
			}
		}
		return false;
	}

	template <typename T>
	bool TmplMould <T>::CanToPrev(T & value, const std::vector <typename T>& ar)
	{
		value = m_Value;
		int setSize = ar.size();
		for (int i = setSize - 1; i >=0; i--)
		{
			if (ar[i] == value)
			{
				if (i > 0)
				{
					value = ar[i - 1];
					return (m_LimitMin <= value && value <= m_LimitMax);
				}
			}
			else if (value - ar[i] > FLT_MIN)
			{
				value = ar[i];
				return (m_LimitMin <= value && value <= m_LimitMax);
			}
		}
		return false;
	}

	template <typename T>
	bool TmplMould <T>::CanToUpdate(T & value, const std::vector <typename T>& ar)
	{
		int setSize = ar.size();
		if (value <= ar[0])
		{
			value = ar[0];
			return (m_LimitMin <= value && value <= m_LimitMax);;
		}
		else if (value >= ar[setSize - 1])
		{
			value = ar[setSize - 1];
			return (m_LimitMin <= value && value <= m_LimitMax);
		}
		else
		{
			for (int i = 0; i < setSize - 1; i++)
			{
				if (value == ar[i])
				{
					value = ar[i];
					return (m_LimitMin <= value && value <= m_LimitMax);
				}
				else if (value == ar[i + 1])
				{
					value = ar[i + 1];
					return (m_LimitMin <= value && value <= m_LimitMax);
				}
				else if (value > ar[i] && value < ar[i + 1])
				{
					(value - ar[i]) > (ar[i + 1] - value) ? value = ar[i + 1] : value = ar[i];
					return (m_LimitMin <= value && value <= m_LimitMax);
				}
			}
		}
		return false;
	}

	template <typename T>
	bool TmplMould <T>::ToNext (const std::vector <typename T>& ar)
	{
		int setSize = ar.size();
		for (int i = 0; i < setSize; i++)
		{
			if (ar[i] == m_Value)
			{
				if (i < setSize - 1)
				{
					m_Value = ar[i + 1];
					return true;
				}
			}
			else if (ar[i] - m_Value > FLT_MIN)
			{
				m_Value = ar[i];
				return true;
			}
		}
		return false;
	}

	template <typename T>
	bool TmplMould <T>::ToPrev (const std::vector <typename T>& ar)
	{
		int setSize = ar.size();
		for (int i = setSize - 1; i >= 0; i--)
		{
			if (ar[i] == m_Value)
			{
				if (i > 0)
				{
					m_Value = ar[i - 1];
					return true;
				}
			}
			else if (m_Value - ar[i] > FLT_MIN)
			{
				m_Value = ar[i];
				return true;
			}
		}
		return false;
	}

	template <typename T>
	bool TmplMould <T>::ToUpdate (T value, const std::vector <typename T>& ar)
	{
		int setSize = ar.size();
		if (value <= ar[0])
		{
			m_Value = ar[0];
			return true;
		}
		else if(value >= ar[setSize -1])
		{ 
			m_Value = ar[setSize - 1];
			return true;
		}
		else
		{
			for (int i = 0; i < setSize - 1; i++)
			{
				if (value == ar[i])
				{
					m_Value = ar[i];
					return true;
				}
				else if (value == ar[i+1])
				{
					m_Value = ar[i+1];
					return true;
				}
				else if (value > ar[i] && value < ar[i + 1])
				{
					(value - ar[i]) > (ar[i + 1] - value) ? m_Value = ar[i + 1] : m_Value = ar[i];
					return true;
				}
			}
		}
		return false;
	}

};