PhysicalDevice/Machine/MachineryECOM/Deliver/Include/String.Format.tlh

#pragma once


#ifndef ASSERT
#include <assert.h>
#define ASSERT assert
#endif


//-----------------------------------------------------------------------------
//	字符串格式化
//		思路主要来自祈宇的文章:
//	<实现一个简单的字符串格式化方法>
//	https://www.cnblogs.com/qicosmos/p/3825612.html
//-----------------------------------------------------------------------------


#include <tuple>
#include <type_traits>
#include <string>
#include <inttypes.h>
#include <cctype>
#include <stdexcept>


#pragma warning (disable : 4996)
//warning C4996: 'strcpy': This function or variable may be unsafe. Consider using strcpy_s instead. 
// To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.


namespace ECOM
{
namespace Utility
{

static const char __MsgOfNull_ [] = "null";
static const int  __LenOfNull_ = sizeof (__MsgOfNull_) - 1;

template <typename tDeriveClass>
class __declspec(novtable) _string_format_detail
{
protected:
	char * m_BufferOrg;
	char * m_Buffer;
	int    m_NbOfChar;

protected:
	inline int  NbOfRemain () const
	{
		return m_NbOfChar - int (m_Buffer - m_BufferOrg);
	}

private:
	template <typename arg>
	int _my_sprintf (char * buf, int NbOfChar, const char * fmt, arg a)
	{
		assert (false);
		return 22;
	}

public:
	inline _string_format_detail (char * buf, int NbOfChar)	//	缓冲区指针, 缓冲区长度 (字节计数)
	{
		assert (buf);
		m_BufferOrg = m_Buffer = buf;
		m_NbOfChar = NbOfChar;
	}

protected:
	inline void CharFormatArg (char ch)
	{
		*m_Buffer = ch;
		m_Buffer ++;
	}

	//	有符号
	template <typename T>
	inline void sDigitFormatArg (T i)
	{
		_ltoa (i, m_Buffer, 10);
		m_Buffer += strlen (m_Buffer);
	}

	// 无符号
	template <typename T>
	inline void uDigitFormatArg (T i)
	{
		_ultoa (i, m_Buffer, 10);
		m_Buffer += strlen (m_Buffer);
	}

	//<	64 位偏特化
	template <>
	inline void sDigitFormatArg (__int64 i)
	{
		_i64toa (i, m_Buffer, 10);
		m_Buffer += strlen (m_Buffer);
	}

	template <>
	inline void uDigitFormatArg (unsigned __int64 i)
	{
		_ui64toa (i, m_Buffer, 10);
		m_Buffer += strlen (m_Buffer);
	}
	//>

	template <typename T>
	//	fmt: D,X, D3,X4,d3,x4, D03,X04
	//	D   - 用 10 进制, X - 用 16 进制
	//	D3  - 转换成 3 个数字, 如果不足, 填充空格
	//	D03 - 转换成 3 个数字, 如果不足, 用 0 填充
	inline void DigitFormatArg (T i, const char * fmt)
	{
		assert (fmt);
		assert (fmt [0]);

		auto chfmt = fmt [0];

		if (chfmt == 'c' || chfmt == 'C')
		{
			CharFormatArg ((char) i);
			return;
		}

		if (chfmt == 'D')  chfmt = 'd';		//	把大写的 D 改成小写的 d, 因为 sprintf 不支持大写 D
		if (chfmt == 'U')  chfmt = 'u';		//	把大写的 U 改成小写的 u, 因为 sprintf 不支持大写 U
		auto rc = (chfmt == 'd' || chfmt == 'u' || chfmt == 'X' || chfmt == 'x');
		if (! rc)	//	尝试浮点数, 万一使用者搞错了
		{
			rc = (chfmt == 'f' || chfmt == 'F');
			if (rc)
			{
				FormatArg ((double) i, fmt);
				return;
			}
		}

		assert (rc);
		if (! rc)  return;					//	既不是 d, 也不是 u, 也不是 x, 也不是 c

		char tofmt [8] = { '%', };

		//	D023, X093 - 1 个格式字母带 3 个数字, tofmt 将成为 "%023d" 或 "%093x"

		//	最多支持 3 个数字. 注意, 如果判断到 \0 也不怕
		//	d1, d3 - 1 个格式字母带 1 个数字, tofmt 将成为 "%1d" 或 "%3d"
		if (std::isdigit (fmt [1]))
		{
			int iFmtChar = 2;
			for (int Index = 1; Index <= 3; Index ++)
			{
				if (std::isdigit (fmt [Index]))
				{
					tofmt [Index] = fmt [Index];
					iFmtChar = Index + 1;
				}
				else
					break;
			}

			tofmt [iFmtChar] = chfmt;
		}
		else //	只有 1 个 d, 比如写成 {$:d}
		{
			tofmt [1] = chfmt;
			tofmt [2] = 0;
		}

		auto pT = static_cast <tDeriveClass *> (this);
		auto r = pT->_my_sprintf (m_Buffer, NbOfRemain (), tofmt, i);
		m_Buffer += r;
	}

	//<	64 位偏特化
	template <>
	//	fmt: D,X, D3,X4,d3,x4, D03,X04
	//	__int64 只支持 d, x, 不支持前导/后导, 因此下面的代码只用了 D 或 X
	inline void DigitFormatArg (__int64 i, const char * fmt)
	{
		assert (fmt);
		assert (fmt [0]);

		auto chfmt = fmt [0];

		if (chfmt == 'c' || chfmt == 'C')
		{
			CharFormatArg ((char) i);
			return;
		}

		if (chfmt == 'D')  chfmt = 'd';		//	把大写的 D 改成小写的 d, 因为 sprintf 不支持大写 D
		if (chfmt == 'U')  chfmt = 'u';		//	把大写的 U 改成小写的 u, 因为 sprintf 不支持大写 U
		auto rc = (chfmt == 'd' || chfmt == 'u' || chfmt == 'X' || chfmt == 'x');
		assert (rc);
		if (! rc)  return;					//	既不是 d, 也不是 u, 也不是 x, 也不是 c

		char tofmt [8] = { '%', 'I', 'I', chfmt };

		auto pT = static_cast <tDeriveClass *> (this);
		auto r = pT->_my_sprintf (m_Buffer, NbOfRemain (), tofmt, i);

		m_Buffer += r;
	}

	//	64 位偏特化
	template <>
	//	fmt: D,X, D3,X4,d3,x4, D03,X04
	//	__int64 只支持 d, x, 不支持前导/后导, 因此下面的代码只用了 D 或 X
	inline void DigitFormatArg (unsigned __int64 i, const char * fmt)
	{
		DigitFormatArg <__int64> ((__int64) i, fmt);
	}
	//>


//	字符,不带格式, 就认为是字符
	inline void FormatArg (char ch)				{ CharFormatArg (ch); }

//	字符,带格式, 就认为是整数
	inline void FormatArg (char ch, const char * fmt) { DigitFormatArg <int> (ch, fmt); }

//< 各种整数
	inline void FormatArg (int i)				{ sDigitFormatArg <int>			  (i); }
	inline void FormatArg (long i)				{ sDigitFormatArg <long>			  (i); }
	inline void FormatArg (short i)				{ sDigitFormatArg <short>		  (i); }
	inline void FormatArg (unsigned int i)		{ uDigitFormatArg <unsigned int>   (i); }
	inline void FormatArg (unsigned long i)		{ uDigitFormatArg <unsigned long>  (i); }
	inline void FormatArg (unsigned short i)	{ uDigitFormatArg <unsigned short> (i); }

	inline void FormatArg (int i           , const char * fmt) { DigitFormatArg <int>				(i, fmt); }
	inline void FormatArg (unsigned int i  , const char * fmt) { DigitFormatArg <unsigned int>		(i, fmt); }
	inline void FormatArg (long i          , const char * fmt) { DigitFormatArg <long>				(i, fmt); }
	inline void FormatArg (unsigned long i , const char * fmt) { DigitFormatArg <unsigned long>		(i, fmt); }
	inline void FormatArg (short i         , const char * fmt) { DigitFormatArg <short>				(i, fmt); }
	inline void FormatArg (unsigned short i, const char * fmt) { DigitFormatArg <unsigned short>	(i, fmt); }

//	int64
	inline void FormatArg (__int64 i)			{ sDigitFormatArg <__int64>			  (i); }
	inline void FormatArg (unsigned __int64 i)	{ uDigitFormatArg <unsigned __int64>   (i); }
//	int64, 带参数
	inline void FormatArg (__int64 i          , const char * fmt) { DigitFormatArg <__int64>			(i, fmt); }
	inline void FormatArg (unsigned __int64 i , const char * fmt) { DigitFormatArg <unsigned __int64>	(i, fmt); }
//>

//< 浮点数, 默认精度由 printf 决定
	inline void FormatArg (double i)
	{
		auto pT = static_cast <tDeriveClass *> (this);
		auto r = pT->_my_sprintf (m_Buffer, NbOfRemain (), "%f", i);
		m_Buffer += r;
	}

	//	fmt: F3, 精确到小数点后面3位
	//	fmt: F, 默认精度由 printf 决定
	//	fmt : f}    --> tofmt : %f
	//	fmt : f3}   --> tofmt : %.3f
	//	fmt : f23}  --> tofmt : %.23f
	inline void FormatArg (double i, const char * fmt)
	{
		assert (fmt);
		assert (fmt [0]);

		char tofmt [8] = { '%', '.', };

		auto chfmt = fmt [0];

		//	最多支持 3 个数字. 注意, 如果判断到 \0 也不怕
		//	f1, f3 - 1 个格式字母带 1 个数字, tofmt 将成为 "%.1f" 或 "%.3f"
		if (std::isdigit (fmt [1]))
		{
			int iFmtChar = 2;
			for (int Index = 1; Index <= 3; Index ++)
			{
				if (std::isdigit (fmt [Index]))
				{
					tofmt [Index+1] = fmt [Index];
					iFmtChar = Index + 2;
				}
				else
					break;
			}

			tofmt [iFmtChar] = chfmt;
		}
		else //	只有 1 个 f, 比如写成 {$:f}
		{
			tofmt [1] = chfmt;
			tofmt [2] = 0;
		}

		auto pT = static_cast <tDeriveClass *> (this);
		auto r = pT->_my_sprintf (m_Buffer, NbOfRemain (), tofmt, i);
		m_Buffer += r;
	}
//>

//	字符串, 无格式
	inline void FormatArg (const char * p)
	{
		if (p == nullptr)
		{
			memcpy (m_Buffer, __MsgOfNull_, __LenOfNull_);
			m_Buffer += __LenOfNull_;
			return;
		}

		int len = (int) strlen (p);
		memcpy (m_Buffer, p, len);
		m_Buffer += len;
	}

//<	字符串, 带格式, 格式:
//	6  : 最长 6 个字符, 右对齐, 左边填空
//	+6 : 最长 6 个字符, 右对齐, 左边填空
//	-6 : 最长 6 个字符, 左对齐, 右边填空
	inline void FormatArg (const char * p, const char * fmt)
	{
		if (p == nullptr)
		{
			memcpy (m_Buffer, __MsgOfNull_, __LenOfNull_);
			m_Buffer += __LenOfNull_;
			return;
		}

		int len = (int) strlen (p);

		_StringFormatArg (p, len, fmt);
	}

	inline void _StringFormatArg (const char * p, int len, const char * fmt)
	{
		if (p == nullptr)
		{
			memcpy (m_Buffer, __MsgOfNull_, __LenOfNull_);
			m_Buffer += __LenOfNull_;
			return;
		}

		if (fmt [0] == '-')		//	左对齐
		{
			fmt ++;
			auto i = atoi (fmt);
			if (i > len)
			{
				memcpy (m_Buffer, p, len);
				m_Buffer += len;
				memset (m_Buffer, ' ', i - len);
				m_Buffer += i - len;
			}
			else
			{
				memcpy (m_Buffer, p, len);
				m_Buffer += len;
			}
		}
		else					//	右对齐
		{
			if (fmt [0] == '+')  fmt ++;

			auto i = atoi (fmt);
			if (i > len)
			{
				memset (m_Buffer, ' ', i - len);
				m_Buffer += i - len;
				memcpy (m_Buffer, p, len);
				m_Buffer += len;
			}
			else
			{
				memcpy (m_Buffer, p, len);
				m_Buffer += len;
			}
		}
	}
//>

//	bool
	void FormatArg (bool b)
	{
		if (b)
		{
			*m_Buffer = 't';  m_Buffer ++;
			*m_Buffer = 'r';  m_Buffer ++;
			*m_Buffer = 'u';  m_Buffer ++;
			*m_Buffer = 'e';  m_Buffer ++;
		}
		else
		{
			*m_Buffer = 'f';  m_Buffer ++;
			*m_Buffer = 'a';  m_Buffer ++;
			*m_Buffer = 'l';  m_Buffer ++;
			*m_Buffer = 's';  m_Buffer ++;
			*m_Buffer = 'e';  m_Buffer ++;
		}
	}

//	任意指针类型
	template <typename UNP>
	inline void FormatArg (const UNP * ptr)
	{
		auto pT = static_cast <tDeriveClass *> (this);
		auto r = pT->_my_sprintf (m_Buffer, NbOfRemain (), "%p", ptr);
		m_Buffer += r;
	}

//	任意指针类型, 带格式 -- 转化成整数来格式化
	template <typename UNP>
	inline void FormatArg (const UNP * ptr, const char * fmt)
	{
		DigitFormatArg <uintptr_t> ((uintptr_t) ptr, fmt);
	}

//	偏特化 - 字符串指针
	template <> inline void FormatArg (const char * p)
	{
		if (p == nullptr)
		{
			memcpy (m_Buffer, __MsgOfNull_, __LenOfNull_);
			m_Buffer += __LenOfNull_;
			return;
		}

		int len = (int) strlen (p);
		memcpy (m_Buffer, p, len);
		m_Buffer += len;
	}

//	偏特化 - 字符串指针
	template <> inline void FormatArg (const char * p, const char *)
	{
		if (p == nullptr)
		{
			memcpy (m_Buffer, __MsgOfNull_, __LenOfNull_);
			m_Buffer += __LenOfNull_;
			return;
		}

		int len = (int) strlen (p);
		memcpy (m_Buffer, p, len);
		m_Buffer += len;
	}


#ifdef DSTRING_API
	inline void FormatArg (const DString & s)
	{
		memcpy (m_Buffer, s.constBuffer (), s.GetLength ());
		m_Buffer += s.GetLength ();
	}

	inline void FormatArg (const DString & s, const char * fmt)
	{
		_StringFormatArg (s.constBuffer (), s.GetLength (), fmt);
	}
#endif

	inline void FormatArg (const std::string & s)
	{
		memcpy (m_Buffer, s.data (), s.size ());
		m_Buffer += s.size ();
	}

	inline void FormatArg (const std::string & s, const char * fmt)
	{
		_StringFormatArg (s.data (), (int) s.size (), fmt);
	}


#ifdef WSTRING_API
//#if 1

	inline void FormatArg (const wchar_t * p)
	{
		if (p == nullptr)
		{
			memcpy (m_Buffer, __MsgOfNull_, __LenOfNull_);
			m_Buffer += __LenOfNull_;
			return;
	}

		auto dp = WString (p).ToDString ();
		FormatArg (dp);
	}

	inline void FormatArg (const wchar_t * p, const char * fmt)
	{
		if (p == nullptr)
		{
			memcpy (m_Buffer, __MsgOfNull_, __LenOfNull_);
			m_Buffer += __LenOfNull_;
			return;
		}

		auto dp = WString (p).ToDString ();
		FormatArg (dp, fmt);
	}

	inline void FormatArg (const WString & s)
	{
		auto dp = s.ToDString ();
		FormatArg (dp);
	}

	inline void FormatArg (const WString & s, const char * fmt)
	{
		auto dp = s.ToDString ();
		FormatArg (dp, fmt);
	}

	inline void FormatArg (const std::wstring & s)
	{
		auto dp = WString (s.c_str ()).ToDString ();
		FormatArg (dp);
	}

	inline void FormatArg (const std::wstring & s, const char * fmt)
	{
		auto dp = WString (s.c_str ()).ToDString ();
		FormatArg (dp, fmt);
	}

#endif


	template <size_t k, typename Tuple>
	typename std::enable_if <(k == std::tuple_size<Tuple>::value)>::type
	inline GetArgByIndex (size_t, Tuple &)
	{
//	忽略那些误写的位置参数, 比如忽略下面的 {99}
//	eLog::Log ("{99}, {0}", 123456
#ifdef _DEBUG
//				throw std::invalid_argument ("arg index out of range");
#endif
	}

	template <size_t k = 0, typename Tuple>
	typename std::enable_if <(k < std::tuple_size<Tuple>::value)>::type
	inline GetArgByIndex (size_t index, Tuple & tp)
	{
		if (k == index)
		{
			FormatArg (std::get<k> (tp));
		}
		else
		{
			GetArgByIndex <k + 1> (index, tp);
		}
	}


	template <size_t k, typename Tuple>
	typename std::enable_if <(k == std::tuple_size<Tuple>::value)>::type
	inline GetArgByIndex (size_t, Tuple &, const char * fmt)
	{
#ifdef _DEBUG
//				throw std::invalid_argument ("arg index out of range");
#endif
	}

	template <size_t k = 0, typename Tuple>
	typename std::enable_if <(k < std::tuple_size<Tuple>::value)>::type
	inline GetArgByIndex (size_t index, Tuple & tp, const char * fmt)
	{
		if (k == index)
		{
			FormatArg (std::get <k> (tp), fmt);
		}
		else
		{
			GetArgByIndex <k + 1> (index, tp, fmt);
		}
	}

	static inline const char * FirstDollar (const char *& p)
	{
		while (*p != '}' && *p != '\0')
		{
			if ('$' == (*p))
				return p;
			p ++;
		}

		return nullptr;
	}

	static inline const char * FirstDigit (const char *& p)
	{
		while (*p != '}' && *p != '\0')
		{
			if (std::isdigit (*p))
				return p;
			p ++;
		}

		return nullptr;
	}

	static inline const char * LastDigit (const char *& p)
	{
		while (*p != '}' && *p != '\0')
		{
			if (! std::isdigit (*p))
				return p - 1;
			p ++;
		}

		return p - 1;
	}

	static inline const char * FindColon (const char *& p)
	{
		while (*p != '}' && *p != '\0')
		{
			if (*p == ':')
				return p;
			p++;
		}

		return nullptr;
	}

	static inline const char * FindRightBrace (const char *& p)
	{
		while (*p != '\0')
		{
			if (*p == '}')
				return p;
			p++;
		}

		return nullptr;
	}

	static inline int GetIndex (const char *& p, const char *& fmt, int prevIndex)
	{
		auto bp = p;	//	备份一下, 因为后面跟的可能是 $, 也可能是数字

		auto pDollar = FirstDollar (p);
		if (pDollar)
		{
			auto pc = FindColon (p);
			auto _  = FindRightBrace (p);
			if (pc)
				fmt = pc + 1;
			return prevIndex + 1;
		}

		p = bp;
		auto pd = FirstDigit     (p);
		auto pl = LastDigit      (p);
		auto pc = FindColon      (p);
		auto _  = FindRightBrace (p);

		if (pd == nullptr)  return -1;

		auto ii = pl + 1 - pd;
		assert (ii <= 2);
		if (ii <= 0)  return -1;

		char temp [3] = {};
		temp [0] = *pd; pd ++;
		temp [1] = *pd;
		auto index = std::atoi (temp);

		if (pc)
			fmt = pc + 1;

		return index;
	}

public:
//	返回: 格式化后的字符串长度
	template <typename... Args>
	inline int  Format (const char * fmt, Args... args)
	{
		assert (fmt);
		if (fmt == nullptr)
		{
			m_Buffer [0] = 0;
			return 0;
		}

//		最好在上层判断, 以避免在这里重复计算 strlen
		if (sizeof...(args) == 0)
		{
			strcpy (m_Buffer, fmt);
			int  len = (int) strlen (m_Buffer);
			return len;
		}

		m_Buffer = m_BufferOrg;
		auto tp = std::tuple <Args...> (args...);

		const char * p = fmt;
		const char * original = p;
		int  len   = (int) strlen (fmt) + 1;
		int  last  = 0;
		int  Index = -1;
		while (true)
		{
			if (*p == '{')
			{
				//copy content befor {
				last = int (p - original);
				if (last)
				{
					memcpy (m_Buffer, original, last);
					m_Buffer += last;
				}

				//format args
				const char * tmp = nullptr;
				Index = GetIndex (p, tmp, Index);
				if (Index >= 0)
				{
					if (tmp)
						GetArgByIndex <0> (Index, tp, tmp);
					else
						GetArgByIndex <0> (Index, tp);
				}

				//skip }
				original = p + 1;
			}
			else
			if (*p == '\0')
			{
				last = int (p - original);
				if (last == 0)
					*m_Buffer = 0;
				else
				{
					memcpy (m_Buffer, original, last + 1);	//	+1 的目的是, 包括尾部的 \0
					m_Buffer += last;
				}
				break;
			}

			p++;
		}

		auto delta = m_Buffer - m_BufferOrg;

#ifdef _DEBUG
		len = (int) strlen (m_BufferOrg);
		assert ((delta - len) == 0);
#endif

		return (int) delta;
//		return buf_org;
	}

};



class StringFormat : public _string_format_detail <StringFormat>
{
public:
	inline StringFormat (char * buf, int NbOfChar) : _string_format_detail (buf, NbOfChar) { }

public:
	template <typename arg>
	inline int _my_sprintf (char * buf, int NbOfChar, const char * fmt, arg a)
	{
		return sprintf_s (buf, NbOfChar, fmt, a);
	}
};



}

}



//-----------------------------------------------------------------------------
//		设计说明 (2021-06-18):
//  1. 为什么只能支持 3 个数字 (即 最大只能是 {$:d999} 或 {$:f999})
//     1) 预留的 Buffer 一般大小是 8192, 见 DString::_XFormat 及 TLSLog
//     2) 最终会调用 _vsprintf_s_l (buffer, len, ...)
//     3) 当 buffer 不足时, 上述函数会调用 无效参数错误处理函数, 
//     4) 无效参数错误处理函数 : 在 Debug 模式时, 弹出断言错误. 在 Release 模式时, 直接终止程序.
//
//-----------------------------------------------------------------------------