std::string ttyHandler::getTime()
{
std::chrono::high_resolution_clock::time_point p = std::chrono::high_resolution_clock::now();
std::chrono::milliseconds ms = std::chrono::duration_cast<std::chrono::milliseconds>(p.time_since_epoch());
std::chrono::seconds s = std::chrono::duration_cast<std::chrono::seconds>(ms);
std::time_t t = s.count();
std::tm * pTimeinfo;
std::size_t fractional_seconds = ms.count() % 1000;
pTimeinfo = std::localtime(&t);
char buffer[80];
// configure timeformat here
std::strftime(buffer, 80, "%d.%m.%y %T", pTimeinfo);
std::string strRet(buffer);
std::size_t found = strRet.find('\0')-1;
if(found != std::string::npos)
{
strRet = strRet.substr(0, found) + ".";
std::stringstream ss;
ss << std::setfill('0') << std::setw(3) << fractional_seconds;
strRet += ss.str();
}
return strRet;
}
std::string sunjwbase::striconv(const std::string& input,
const std::string& to_code,
const std::string& from_code)
{
char* inptr = new char[input.size() + 1];
size_t inleft = input.size();
size_t outleft = inleft * 4 + 1; // should be large enough
char* outptr = new char[outleft];
bzero(outptr, outleft);
strcpy(inptr, input.c_str());
iconv_t cd; // conversion descriptor
if ((cd = iconv_open(to_code.c_str(), from_code.c_str())) == (iconv_t) (-1))
{
iconv_close(cd); // failed clean
return input;
}
char* in = inptr;
char* out = outptr;
outleft = iconv(cd, &in, &inleft, &out, &outleft);
iconv_close(cd);
std::string strRet(outptr);
delete[] inptr;
delete[] outptr;
return strRet;
}
BOOL CTrMonItem::GetShownValue( VECSHOWNSTRING& vValOut) const
{
CString strRet(TEXT(""));
for (size_t i = 0; i < m_vData.size() ; i++)
{
if (i == TRCOLTYPE_TYPE)
{
strRet = GetShownStrValue((ENUM_TEMPCOL_TYPE)i);
if (strRet.IsEmpty())
{
ASSERT(FALSE);
return FALSE;
}
}
else
{
strRet = m_vData[i];
}
vValOut.push_back(strRet);
}
if (TEMPLATE_DB_COL_NUM != vValOut.size())
{
ASSERT(FALSE);
return FALSE;
}
return TRUE;
}
std::string CPlaySave::GetCurPlayBackTime()
{
std::string strRet("");
int iRet = m_prtsp_client->GetCurPlayBackTimeInPaly(m_url);
if( iRet >= 0 ) strRet = m_prtsp_client->GetCurPlayBackTime();
return strRet;
}
CString Utf8toSjis(char *utf8,int len)
{
// UTF-8 -> Ansi
// (UTF-8 -> UNICODE)
int size = MultiByteToWideChar(CP_UTF8,0,utf8,len,NULL,0);
size++;
WCHAR *buf = new WCHAR[size];
if(!buf) return "";
MultiByteToWideChar(CP_UTF8,0,utf8,len,buf,size-1);
buf[size-1] = L'\0';
// (UNICODE -> Ansi)
size = WideCharToMultiByte(CP_UTF8,0,buf,-1,0,0,NULL,NULL);
char *buf2 = new char[size];
if(!buf2)
{
delete buf;
return "";
}
WideCharToMultiByte(CP_UTF8,0,buf,-1,buf2,size,NULL,NULL);
CString strRet(buf);
delete buf;
delete buf2;
return strRet;
}
TEST(IniFile, get)
{
IniFile ini("/tmp/testini.conf");
ini.loadRawConfiguration("[Section1]\nparam1=0\nparam2=1\n;Comment\nparam3=-10\nparam4=test\n[Section2]\nparam1=1\nparam2=0\n");
string strRet("");
int signedRet(0);
unsigned unsignedRet(0);
bool boolRet(false);
// Verify parsing of the different data types
EXPECT_TRUE(ini.setSection("Section1"));
EXPECT_TRUE(ini.get("param4", strRet));
EXPECT_EQ("test", strRet);
EXPECT_TRUE(ini.get("param2", unsignedRet));
EXPECT_EQ(1u, unsignedRet);
EXPECT_TRUE(ini.get("param3", signedRet));
EXPECT_EQ(-10, signedRet);
EXPECT_TRUE(ini.get("param2", boolRet));
EXPECT_TRUE(boolRet);
EXPECT_TRUE(ini.get("param1", boolRet));
EXPECT_FALSE(boolRet);
// Verify that same parameter in different sections aren't mixed
EXPECT_TRUE(ini.setSection("Section2"));
EXPECT_TRUE(ini.get("param1", strRet));
EXPECT_EQ("1", strRet);
EXPECT_TRUE(ini.get("param2", strRet));
EXPECT_EQ("0", strRet);
}
std::wstring Win32ErrorToString(const DWORD dwErrorCode) {
// Retrieve the system error message for the last-error code
LPVOID lpMsgBuf;
LPVOID lpDisplayBuf;
DWORD dw = GetLastError();
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
dw,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &lpMsgBuf,
0, NULL);
// Display the error message and return in
lpDisplayBuf = (LPVOID)LocalAlloc(LMEM_ZEROINIT,
(lstrlen((LPCTSTR)lpMsgBuf) +
lstrlen((LPCTSTR)dwErrorCode) + 40) * sizeof(TCHAR));
StringCchPrintf((LPTSTR)lpDisplayBuf,
LocalSize(lpDisplayBuf) / sizeof(TCHAR),
TEXT("%s failed with error %d: %s"),
dwErrorCode, dw, lpMsgBuf);
// MessageBox(NULL, (LPCTSTR)lpDisplayBuf, TEXT("Error"), MB_OK);
std::wstring strRet((LPTSTR)lpDisplayBuf);
LocalFree(lpMsgBuf);
LocalFree(lpDisplayBuf);
return strRet;
}
BigData BigData::operator / (const BigData& bigdata)
{
if (bigdata._pData == "+0")
{
assert(false);
std::cout << "FileName :" <<__FILE__ << "Line :" << __LINE__ << std::endl;
}
if (_pData == "+0")
{
return BigData((INT64)0);
}
int LSize = _pData.size();
int RSize = bigdata._pData.size();
if (LSize < RSize ||
(LSize == RSize && strcmp(_pData.c_str() + 1, bigdata._pData.c_str() + 1) < 0))
{
return BigData((INT64)0);
}
if (strcmp(_pData.c_str() + 1, bigdata._pData.c_str() + 1) == 0)
{
if (_pData[0] == bigdata._pData[0])
{
return BigData((INT64)1);
}
else
{
return BigData((INT64)-1);
}
}
if (bigdata._pData == "+1")
{
return *this;
}
if (bigdata._pData == "-1")
{
std::string strRet(_pData);
if (strRet[0] == '+')
{
strRet[0] = '-';
_value = 0 - _value;
}
else
{
strRet[0] = '+';
_value = 0 - _value;
}
return BigData((char *)strRet.c_str());
}
//LSize > RSize
return BigData((char *)Div(_pData, bigdata._pData).c_str());
}
String String::SubString(int iStart, int iLen) const
{
MUTEX_LOCK(str_mutex);
// Empty strings
if (iStart < 0 || iLen <= 0) {
return "";
}
// Get the first offset
#ifdef SCRATCH_NO_UTF8
String strRet(this->str_szBuffer + iStart);
#else
void* subFirst = this->str_szBuffer;
s_char codepoint;
do {
subFirst = utf8codepoint(subFirst, &codepoint);
} while (--iStart > 0 && codepoint != '\0');
String strRet((const char*)subFirst);
#endif
// Check for stupid developers
#ifdef SCRATCH_NO_UTF8
if ((uint32_t)iLen > strlen(strRet)) {
return strRet;
}
#else
if ((uint32_t)iLen > utf8len(strRet)) {
return strRet;
}
#endif
// Then set the null terminator at the length the user wants
#ifdef SCRATCH_NO_UTF8
strRet.str_szBuffer[iLen] = '\0';
#else
void* sz = strRet.str_szBuffer;
do {
sz = utf8codepoint(sz, &codepoint);
} while (--iLen > 0 && codepoint != '\0');
*(char*)sz = '\0';
#endif
// Return
return strRet;
}
AString Converter::UTF_82ASCII(const AString& strUtf8Code){
AString strRet("");
//先把 utf8 转为 unicode
WString wstr = Utf82Unicode(strUtf8Code);
//最后把 unicode 转为 ascii
strRet = WideByte2Acsi(wstr);
return strRet;
}
std::wstring util::Win32ErrorToString(DWORD dwErrorCode)
{
wchar_t* szMsgBuffer;
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS, NULL, dwErrorCode, 0, (LPTSTR)&szMsgBuffer, 0, NULL);
std::wstring strRet(szMsgBuffer);
LocalFree(szMsgBuffer);
return strRet;
}
CUString GetWinampPluginFileName( int i )
{
CUString strRet( _T("") );
if ( i< (int)gs_vWinAmpProps.size() )
{
strRet = gs_vWinAmpProps[i].strFileName;
}
return strRet;
}
CUString GetWinampPluginInfo( int i )
{
CUString strRet( _W("") );
if ( i< (int)gs_vWinAmpProps.size() )
{
strRet = CUString( gs_vWinAmpProps[i].pModule->description, CP_UTF8);
}
return strRet;
}
//ascii 转 Utf8
string ASCII2UTF_8(string& strAsciiCode)
{
string strRet("");
//先把 ascii 转为 unicode
wstring wstr = Acsi2WideByte(strAsciiCode);
//最后把 unicode 转为 utf8
strRet = Unicode2Utf8(wstr);
return strRet;
}
GString operator+(GString &_p1, signed char _p2)
{
GString strRet(_p1._len + 2);
for (int i = 0; i < _p1._len; strRet._len++, i++)
strRet._str[strRet._len] = _p1._str[i];
strRet._str[strRet._len] = _p2;
strRet._len++;
strRet._str[strRet._len] = 0;
return strRet;
}
/**
*@brief 如果是手机号，去掉"86"前缀
* 判断依据：入参是13位数字,且 前3位是"861"
*@param input strSrc ： userNumber 有可能为 手机号或者别名， 函数处理中不涉及对该入参的修改
*@return 返回的 userNumber ，已经去了 "86"前缀
*/
std::string Trim86(const std::string& strSrc)
{
std::string strRet(strSrc);
if( 13 == strRet.size() &&
IsAllDigit(strRet.c_str()) &&
0 == strncmp(strRet.c_str(), "861", 3) )
{
strRet.erase(0, 2);
}
return strRet;
}
//utf-8 转 ascii
string UTF_82ASCII(string& strUtf8Code)
{
string strRet("");
//先把 utf8 转为 unicode
wstring wstr = Utf82Unicode(strUtf8Code);
//最后把 unicode 转为 ascii
strRet = WideByte2Acsi(wstr);
return strRet;
}
String String::Replace(const String &strNeedle, const String &strReplace) const
{
MUTEX_LOCK(str_mutex);
MUTEX_LOCK_NAMED(wait2, strNeedle.str_mutex);
MUTEX_LOCK_NAMED(wait3, strReplace.str_mutex);
String strRet("");
// Keep a pointer to the current offset and a "previous offset"
char* szOffset = this->str_szBuffer;
char* szOffsetPrev = szOffset;
do {
// Find the offset of the needle
#ifdef SCRATCH_NO_UTF8
szOffset = strstr(szOffset, strNeedle);
#else
szOffset = (char*)utf8str(szOffset, strNeedle);
#endif
// If it's found
if (szOffset != nullptr) {
// Append everything before the needle of the original characters to the return value
strRet.AppendToBuffer(szOffsetPrev, szOffset - szOffsetPrev);
// Append the replace value
strRet.AppendToBuffer(strReplace);
// Increase the offset pointer by the needle size
#ifdef SCRATCH_NO_UTF8
szOffset += strlen(strNeedle);
#else
szOffset += utf8size(strNeedle) - 1;
#endif
// Keep track of the pointer
szOffsetPrev = szOffset;
} else {
// Append the remaining part of the source string
#ifdef SCRATCH_NO_UTF8
size_t bytes = strlen(szOffsetPrev);
#else
size_t bytes = utf8size(szOffsetPrev) - 1;
#endif
strRet.AppendToBuffer(szOffsetPrev, bytes);
}
} while (szOffset != nullptr);
return strRet;
}
CStringA Util::String::Unicode2UTF8(const wchar_t* pUnicode)
{
ATLASSERT(NULL != pUnicode);
int targetLen = WideCharToMultiByte(CP_UTF8, 0, (LPWSTR)pUnicode, -1, NULL, 0, NULL, NULL);
char* pTargetData = new char[targetLen+1];
memset(pTargetData, 0, targetLen+1);
WideCharToMultiByte(CP_UTF8, 0, (LPWSTR)pUnicode, -1, (char *)pTargetData, targetLen, NULL, NULL);
CStringA strRet(pTargetData);
delete pTargetData;
return strRet;
}
tstring Utility::GetModulePath(HMODULE hModule)
{
TCHAR szPath[MAX_PATH] = {0};
if (!GetModuleFileName(hModule, szPath, MAX_PATH))
return _T("");
TCHAR *szPos = _tcsrchr(szPath, _T('\\'));
if (szPos)
*szPos = _T('\0');
tstring strRet(szPath);
strRet += _T('\\');
return strRet;
}
CStringW Util::String::UTF82Unicode(const char* pChar)
{
ATLASSERT(NULL != pChar);
int targetLen = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)pChar, -1, NULL, 0);
WCHAR* pTargetData = new WCHAR[targetLen+1];
memset(pTargetData, 0, (targetLen+1) * sizeof(WCHAR));
MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)pChar, -1, (WCHAR*)pTargetData, targetLen);
CStringW strRet(pTargetData);
delete pTargetData;
return strRet;
}
GString operator+(GString &_p1, GString &_p2)
{
GString strRet(_p1._len + _p2._len + 1);
int i;
for (i = 0; i < _p1._len; strRet._len++, i++)
strRet._str[strRet._len] = _p1._str[i];
for (i = 0; i < _p2._len; strRet._len++, i++)
strRet._str[strRet._len] = _p2._str[i];
strRet._str[strRet._len] = 0;
return strRet;
}
GString operator+(char _p1, GString &_p2)
{
GString strRet(_p2._len + 2);
strRet._str[strRet._len] = _p1;
strRet._len++;
for (int i = 0; i < _p2._len; strRet._len++, i++)
strRet._str[strRet._len] = _p2._str[i];
strRet._str[strRet._len] = 0;
return strRet;
}
string w2b(const wstring& _src)
{
int nBufSize = ::WideCharToMultiByte(GetACP(), 0, _src.c_str(),-1, NULL, 0, 0, FALSE);
char *szBuf = new char[nBufSize + 1];
::WideCharToMultiByte(GetACP(), 0, _src.c_str(),-1, szBuf, nBufSize, 0, FALSE);
string strRet(szBuf);
delete []szBuf;
szBuf = NULL;
return strRet;
}
AString Converter::ASCII2UTF_8(const AString& strAsciiCode)
{
AString strRet("");
//先把 ascii 转为 unicode
WString wstr = Acsi2WideByte(strAsciiCode);
//最后把 unicode 转为 utf8
strRet = Unicode2Utf8(wstr);
return strRet;
}
TEST(IniFile, hexData)
{
IniFile ini("/tmp/testini.conf");
ini.loadRawConfiguration("[Section]\nparam=000123456789ABCDEF00\n");
EXPECT_TRUE(ini.setSection("Section"));
// Verify getHex
string strRet("");
EXPECT_TRUE(ini.getHex("param", strRet));
EXPECT_EQ(string("\0\x01\x23\x45\x67\x89\xAB\xCD\xEF\0", 10), strRet);
// Verify setHex
EXPECT_TRUE(ini.setHex("param", string("\0\xFE\xDC\xBA\x98\x76\x54\x32\x10\0", 10)));
EXPECT_EQ("[Section]\nparam=00FEDCBA987654321000\n", ini.getRawConfiguration());
}
void WriteDebug(CString strOut)
{
extern CFile fDebug;
COleDateTime curDate=COleDateTime::GetCurrentTime();
CString strFmt;
CString strRet("\r\n");
CString strSpan('-',40);
strFmt.Format("%s\r\n",curDate.Format("%Y-%m-%d %H %M %S") );
fDebug.Write(strFmt,strFmt.GetLength());
strSpan+=strRet;
fDebug.Write(strSpan,strSpan.GetLength());
fDebug.Write(strOut,strOut.GetLength());
fDebug.Write(strRet+strRet,strRet.GetLength()*2 );
}
std::string DumpVector(const T* inputArr, int nInputSize)
{
std::string strRet("");
char sz[128];
// For each entry in the definition
int i=0, nCellCount = 0;
while(i < nInputSize)
{
if(!(nCellCount%5))
strRet += "<tr>";
const T& defObj = inputArr[i];
strRet += "<td class='ucStyle'>";
sprintf(sz, "&#%hu;", defObj.uCode);
strRet += sz;
strRet += "</td> <td>";
strRet += defObj.phRep;
int j=i+1;
while(j < nInputSize && inputArr[j].uCode == defObj.uCode)
{
strRet += ", ";
strRet += inputArr[j].phRep;
++j;
}
strRet += "</td>";
nCellCount++;
if(!(nCellCount%5))
strRet += "</tr>";
i = j;
}
if((nCellCount%5)) strRet += "</tr>";
return strRet;
}
String String::ToUpper() const
{
MUTEX_LOCK(str_mutex);
String strRet(this->str_szBuffer);
#ifdef SCRATCH_NO_UTF8
#if WINDOWS
int len = strlen(this->str_szBuffer);
_strupr_s(strRet.str_szBuffer, len + 1);
#else
strupr(strRet.str_szBuffer);
#endif
#else
utf8upr(strRet.str_szBuffer);
#endif
return strRet;
}
TEST(IniFile, getDefault)
{
IniFile ini("/tmp/testini.conf");
// Test with empty config, no section set
string strRet("");
EXPECT_FALSE(ini.get("missing", strRet, "default"));
EXPECT_EQ("default", strRet);
int signedRet(0);
EXPECT_FALSE(ini.get("missing", signedRet, -10));
EXPECT_EQ(-10, signedRet);
unsigned unsignedRet(0);
EXPECT_FALSE(ini.get("missing", unsignedRet, 10));
EXPECT_EQ(10u, unsignedRet);
bool boolRet(false);
EXPECT_FALSE(ini.get("missing", boolRet, true));
EXPECT_EQ(true, boolRet);
// Test with section set
ini.loadRawConfiguration("[Section1]\nparam1=1\nparam2=2\n");
EXPECT_TRUE(ini.setSection("Section1", false));
string strRet2("");
EXPECT_FALSE(ini.get("missing", strRet2, "default"));
EXPECT_EQ("default", strRet2);
int signedRet2(0);
EXPECT_FALSE(ini.get("missing", signedRet2, -10));
EXPECT_EQ(-10, signedRet2);
unsigned unsignedRet2(0);
EXPECT_FALSE(ini.get("missing", unsignedRet2, 10));
EXPECT_EQ(10u, unsignedRet2);
bool boolRet2(false);
EXPECT_FALSE(ini.get("missing", boolRet2, true));
EXPECT_EQ(true, boolRet2);
}
