2263 lines
70 KiB
C++
2263 lines
70 KiB
C++
//---------------------------------------------------------------------------
|
||
//#pragma hdrstop
|
||
//---------------------------------------------------------------------------
|
||
#define _CRT_SECURE_NO_WARNINGS
|
||
//---------------------------------------------------------------------------
|
||
#ifdef _WIN32
|
||
#define NOMINMAX
|
||
#endif // _WIN32
|
||
//---------------------------------------------------------------------------
|
||
#include "stdTools.h"
|
||
//#include "mathTools.h"
|
||
#include <cstdint>
|
||
|
||
//#include <Math.h>
|
||
#include <list>
|
||
#include <sstream>
|
||
#include <iostream>
|
||
#include <iomanip>
|
||
#include <fstream>
|
||
#include <locale>
|
||
#include <codecvt>
|
||
#include <vector>
|
||
#include <stdexcept>
|
||
#include <algorithm>
|
||
#include <ctime>
|
||
#include <limits> //min max
|
||
#if defined(_WIN32) || defined(_WINDOWS) || defined(_BORLAND) || defined(__BORLANDC__)
|
||
#include <windows.h>
|
||
//#include <minwinbase.h>
|
||
#include <winnt.h>
|
||
//#include <fileapi.h>
|
||
|
||
#include <shlobj.h>
|
||
#else
|
||
//#include <chrono>
|
||
#include <sys/time.h>
|
||
#include <pwd.h>
|
||
#include <unistd.h>
|
||
#include <sys/types.h>
|
||
|
||
#include <dirent.h>
|
||
#endif
|
||
#include <sys/stat.h> //mkdir
|
||
|
||
#include <iostream>
|
||
#include <clocale>
|
||
#include <cstring>
|
||
#include <cstdlib>
|
||
|
||
|
||
|
||
namespace Utility
|
||
{
|
||
|
||
//---------------------------------------------------------------------------
|
||
std::string sp3()
|
||
{
|
||
#if defined _WIN32 || defined __CYGWIN__
|
||
return "\\";
|
||
#else
|
||
return "/";
|
||
#endif
|
||
}
|
||
//------------------------------------------------------------------------------
|
||
//Разделитель для директорий
|
||
char separator()
|
||
{
|
||
#ifdef _WIN32
|
||
return '\\';
|
||
#else
|
||
return '/';
|
||
#endif
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
std::string base64_encode(const std::string &in) {
|
||
std::string out;
|
||
#if defined(__BORLANDC__)
|
||
#else
|
||
int val = 0, valb = -6;
|
||
for (unsigned char c : in) {
|
||
val = (val << 8) + c;
|
||
valb += 8;
|
||
while (valb >= 0) {
|
||
out.push_back("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[(val >> valb) & 0x3F]);
|
||
valb -= 6;
|
||
}
|
||
}
|
||
if (valb>-6) out.push_back("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[((val << 8) >> (valb + 8)) & 0x3F]);
|
||
while (out.size() % 4) out.push_back('=');
|
||
#endif
|
||
return out;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
std::string base64_decode(const std::string &in) {
|
||
|
||
std::string out;
|
||
#if defined(__BORLANDC__)
|
||
#else
|
||
std::vector<int> T(256, -1);
|
||
for (int i = 0; i<64; i++) T["ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"[i]] = i;
|
||
|
||
int val = 0, valb = -8;
|
||
for (unsigned char c : in) {
|
||
if (T[c] == -1) break;
|
||
val = (val << 6) + T[c];
|
||
valb += 6;
|
||
if (valb >= 0) {
|
||
out.push_back(char((val >> valb) & 0xFF));
|
||
valb -= 8;
|
||
}
|
||
}
|
||
#endif
|
||
return out;
|
||
}
|
||
//------------------------------------------------------------------------------
|
||
//Преобразовать HEX символ в число (вынужденный повтор чтобы не инклюдить большой файл)
|
||
int hexCharToIntTMP(char input)
|
||
{
|
||
if(input >= '0' && input <= '9')
|
||
return input - '0';
|
||
if(input >= 'A' && input <= 'F')
|
||
return input - 'A' + 10;
|
||
if(input >= 'a' && input <= 'f')
|
||
return input - 'a' + 10;
|
||
throw std::invalid_argument("Invalid input string");
|
||
}
|
||
//------------------------------------------------------------------------------
|
||
uint16_t hexString2ToUint(std::string &str, int pos,bool cut)
|
||
{
|
||
uint16_t result;
|
||
((uint8_t*)&result)[0] = hexCharToIntTMP(str[pos]) * 16 + hexCharToIntTMP(str[pos + 1]);
|
||
((uint8_t*)&result)[1] = hexCharToIntTMP(str[pos + 2]) * 16 + hexCharToIntTMP(str[pos + 3]);
|
||
if (cut)
|
||
{
|
||
str = str.substr(0, pos) + str.substr(pos+4);
|
||
}
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
uint32_t hexString4ToUint(std::string &str, int pos, bool cut)
|
||
{
|
||
uint32_t result=0;
|
||
((uint8_t*)&result)[0] = hexCharToIntTMP(str[pos]) * 16 + hexCharToIntTMP(str[pos + 1]);
|
||
((uint8_t*)&result)[1] = hexCharToIntTMP(str[pos + 2]) * 16 + hexCharToIntTMP(str[pos + 3]);
|
||
((uint8_t*)&result)[2] = hexCharToIntTMP(str[pos + 4]) * 16 + hexCharToIntTMP(str[pos + 5]);
|
||
((uint8_t*)&result)[3] = hexCharToIntTMP(str[pos + 6]) * 16 + hexCharToIntTMP(str[pos + 7]);
|
||
if (cut)
|
||
{
|
||
str = str.substr(0, pos) + str.substr(pos + 8);
|
||
}
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
uint64_t hexString6ToUint(std::string &str, int pos, bool cut)
|
||
{
|
||
uint64_t result=0;
|
||
((uint8_t*)&result)[0] = hexCharToIntTMP(str[pos]) * 16 + hexCharToIntTMP(str[pos+1]);
|
||
((uint8_t*)&result)[1] = hexCharToIntTMP(str[pos + 2]) * 16 + hexCharToIntTMP(str[pos + 3]);
|
||
((uint8_t*)&result)[2] = hexCharToIntTMP(str[pos + 4]) * 16 + hexCharToIntTMP(str[pos + 5]);
|
||
((uint8_t*)&result)[3] = hexCharToIntTMP(str[pos + 6]) * 16 + hexCharToIntTMP(str[pos + 7]);
|
||
((uint8_t*)&result)[4] = hexCharToIntTMP(str[pos + 8]) * 16 + hexCharToIntTMP(str[pos + 9]);
|
||
((uint8_t*)&result)[5] = hexCharToIntTMP(str[pos + 10]) * 16 + hexCharToIntTMP(str[pos + 11]);
|
||
if (cut)
|
||
{
|
||
str = str.substr(0, pos) + str.substr(pos + 12);
|
||
}
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Прочитать файл в строку
|
||
std::string readFileToString(std::string fName){
|
||
std::ifstream t(fName);
|
||
std::stringstream buffer;
|
||
buffer << t.rdbuf();
|
||
return buffer.str();
|
||
}
|
||
//------------------------------------------------------------------------------
|
||
bool deleteFile(std::string fileName)
|
||
{
|
||
bool result=false;
|
||
#ifdef __linux__
|
||
if(unlink(fileName.c_str())==0)
|
||
{
|
||
result=true;
|
||
}
|
||
#elif _WIN32
|
||
if(remove(fileName.c_str())==0)
|
||
{
|
||
result=true;
|
||
}
|
||
#endif
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Получить дату последнего изменения файла
|
||
long getFileDateModiff(std::string file)
|
||
{
|
||
#ifdef __linux__
|
||
struct stat fStat;
|
||
int rc = stat(file.c_str(), &fStat);
|
||
if(rc==0)
|
||
{
|
||
return fStat.st_mtim.tv_sec;
|
||
}
|
||
return 0;
|
||
#elif _WIN32
|
||
return 0;
|
||
#else
|
||
#endif
|
||
}
|
||
//------------------------------------------------------------------------------
|
||
//удалить старые файлы которые были созданы больше заданного количества дней
|
||
bool deleteOldFiles(std::string path,int days)
|
||
{
|
||
bool result=true;
|
||
std::list<std::string> fileList;
|
||
Utility::getFiles(fileList,path);
|
||
std::list<std::string>::const_iterator iterator;
|
||
for (iterator = fileList.begin(); iterator != fileList.end(); ++iterator) {
|
||
std::string fName = *iterator;
|
||
long timeS = getFileDateModiff(fName);
|
||
int tNow=std::time(NULL);
|
||
int tDiff = tNow-timeS;
|
||
if(tDiff > days*24*60*60) {
|
||
if(!deleteFile(fName)) {
|
||
result=result & false;
|
||
}
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Найти файлы в директории и под директории и добавить их в список
|
||
void getFiles(std::list<std::string>& fileList, std::string directory)
|
||
{
|
||
if(directory.length()>0 && directory[directory.length()-1]!=separator()) directory+=separator();
|
||
#ifdef __linux__
|
||
DIR *dir = opendir(directory.c_str());
|
||
if(dir)
|
||
{
|
||
struct dirent *ent;
|
||
while((ent = readdir(dir)) != NULL)
|
||
{
|
||
if(ent->d_type==0x04)
|
||
{
|
||
if ((strncmp(".", ent->d_name, 1) != 0) && (strncmp("..", ent->d_name, 2) != 0))
|
||
{
|
||
std::string newDir = directory + ent->d_name+"/";
|
||
Utility::getFiles(fileList, newDir);
|
||
}
|
||
}
|
||
else
|
||
if(ent->d_type==0x08)
|
||
{
|
||
std::string fWName = ent->d_name;
|
||
fWName = directory + fWName;
|
||
fileList.push_back(fWName);
|
||
}
|
||
}
|
||
closedir(dir);
|
||
}
|
||
#elif _WIN32
|
||
HANDLE hFind;
|
||
WIN32_FIND_DATAA FindFileData;
|
||
|
||
if ((hFind = FindFirstFileA((std::string(directory+"*.*")).c_str(), &FindFileData)) != INVALID_HANDLE_VALUE) {
|
||
do {
|
||
if (FILE_ATTRIBUTE_DIRECTORY & FindFileData.dwFileAttributes)
|
||
{
|
||
if ((strncmp(".", FindFileData.cFileName, 1) != 0) && (strncmp("..", FindFileData.cFileName, 2) != 0))
|
||
{
|
||
std::string newDir = directory + FindFileData.cFileName+"\\";
|
||
Utility::getFiles(fileList, newDir);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
std::string fWName = FindFileData.cFileName;
|
||
fWName = directory + fWName;
|
||
fileList.push_back(fWName);
|
||
}
|
||
|
||
} while (FindNextFileA(hFind, &FindFileData));
|
||
FindClose(hFind);
|
||
}
|
||
#else
|
||
|
||
#endif
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Читаем до символа перехода на новую строку
|
||
std::wstring readUTF16LEString(FILE* fp)
|
||
{
|
||
std::wstring result=L"";
|
||
wchar_t ch;
|
||
while( !feof( fp) )
|
||
{
|
||
size_t count = fread( &((char*)&ch)[0], 1, 1, fp);
|
||
if(count==1)
|
||
{
|
||
count = fread( &((char*)&ch)[1], 1, 1, fp);
|
||
if(count==1)
|
||
{
|
||
if(ch==10) break; //L'\n'
|
||
if(ch!=13) //L'\r'
|
||
result+=ch;
|
||
}
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Прочитать первый попавшийся UTF-16 (LE) FF FE во всём файле
|
||
bool seekToLEBOM(FILE* fp)
|
||
{
|
||
bool result = false;
|
||
unsigned char ch;
|
||
while( !feof( fp) )
|
||
{
|
||
size_t count = fread( &ch, 1, 1, fp);
|
||
if(count==1 && ch==0xFF)
|
||
{
|
||
count = fread( &ch, 1, 1, fp);
|
||
if(count==1 && ch==0xFE)
|
||
{
|
||
result=true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Читать в строку до первого попавшегося символа (в результате этого символа не будет)
|
||
std::string readString(FILE* fp,char ch)
|
||
{
|
||
std::string result="";
|
||
char tmp;
|
||
while( !feof( fp) )
|
||
{
|
||
size_t count = fread( &tmp, 1, 1, fp);
|
||
if(count==1)
|
||
{
|
||
if(tmp==ch)
|
||
break;
|
||
result+=tmp;
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
int readFile(FILE* fp,char* data,int len)
|
||
{
|
||
int result=0;
|
||
while( !feof( fp) )
|
||
{
|
||
size_t count = fread( &data[result], 1, 1, fp);
|
||
if(count==1)
|
||
{
|
||
result++;
|
||
if(result>=len)
|
||
break;
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
std::string lowerCaseENG(std::string str)
|
||
{
|
||
std::string result;
|
||
for(int i=0;i<(int)str.length();i++)
|
||
{
|
||
if(str[i]<='Z' && str[i]>='A')
|
||
result += str[i]-('Z'-'z');
|
||
else
|
||
result += str[i];
|
||
}
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
/*char easytolower(char in){
|
||
if(in<='Z' && in>='A')
|
||
return in-('Z'-'z');
|
||
return in;
|
||
}*/
|
||
//---------------------------------------------------------------------------
|
||
//#include <atlbase.h> //Зло :-)
|
||
//#include "stdafx.h"
|
||
#if defined(_WIN32) || defined(_WINDOWS) || defined(_BORLAND) || defined(__BORLANDC__)
|
||
#if defined( _VC )
|
||
#include < ctime >
|
||
#endif
|
||
#if defined( _BORLAND )
|
||
#include <vcl.h>
|
||
#endif
|
||
#include <Windows.h> //Для Windows
|
||
#include <sys\types.h>
|
||
#include <sys\stat.h>
|
||
#else
|
||
#include <iconv.h>
|
||
#endif
|
||
|
||
//#include <time.h> //Функция времени
|
||
|
||
#include "tcDebug.h"
|
||
//---------------------------------------------------------------------------
|
||
//260 was taken from windef.h
|
||
#ifndef MAX_PATH
|
||
#define MAX_PATH 260
|
||
#endif
|
||
//---------------------------------------------------------------------------
|
||
#define MIN(a,b) (((a)<(b))?(a):(b))
|
||
#define MAX(a,b) (((a)>(b))?(a):(b))
|
||
//---------------------------------------------------------------------------
|
||
/*template <typename T>
|
||
std::string toStdStr(T val)
|
||
{
|
||
std::ostringstream oss;
|
||
oss << val;
|
||
return oss.str();
|
||
}*/
|
||
//---------------------------------------------------------------------------
|
||
//Большее из 2х
|
||
/*int MaxI4(int v1,int v2)
|
||
{ if(v1>v2) return v1; else return v2;
|
||
}*/
|
||
//---------------------------------------------------------------------------
|
||
/*std::wstring s2ws(const std::string& str)
|
||
{
|
||
#if defined(_WIN32) || defined(_WINDOWS) || defined(_BORLAND)
|
||
int len;
|
||
int slength = (int)str.length();// + 1;
|
||
if(slength==0) return L"";
|
||
len = MultiByteToWideChar(CP_ACP, 0, str.c_str(), slength, 0, 0);
|
||
std::wstring rez(len, L'\0');
|
||
MultiByteToWideChar(CP_ACP, 0, str.c_str(), slength, &rez[0], len);
|
||
|
||
//Каз. символы из ASCII в UTF16 в ручную переводим
|
||
for(size_t i=0;i<str.length();i++)
|
||
{
|
||
switch ((char)str[i])
|
||
{
|
||
case (char)0xA3: rez[i]=L'Ә'; break;// Ә
|
||
case (char)0xBC: rez[i]=L'ә'; break;// ә
|
||
case (char)0xAA: rez[i]=L'Ғ'; break;// Ғ
|
||
case (char)0xBA: rez[i]=L'ғ'; break;// ғ
|
||
case (char)0x8D: rez[i]=L'Қ'; break;// Қ
|
||
case (char)0x9D: rez[i]=L'қ'; break;// қ
|
||
case (char)0xBD: rez[i]=L'Ң'; break;// Ң
|
||
case (char)0xBE: rez[i]=L'ң'; break;// ң
|
||
case (char)0xA5: rez[i]=L'Ө'; break;// Ө
|
||
case (char)0xB4: rez[i]=L'ө'; break;// ө
|
||
case (char)0xA1: rez[i]=L'Ұ'; break;// Ұ
|
||
case (char)0xA2: rez[i]=L'ұ'; break;// ұ
|
||
case (char)0xAF: rez[i]=L'Ү'; break;// Ү
|
||
case (char)0xBF: rez[i]=L'ү'; break;// ү
|
||
case (char)0x8E: rez[i]=L'Һ'; break;// Һ
|
||
case (char)0x9E: rez[i]=L'һ'; break;// һ
|
||
//case (char)0xB2: rez[i]=L'І'; break;// І
|
||
//case (char)0xB3: rez[i]=L'i'; break;// i
|
||
case (char)0xB9: rez[i]=L'№'; break;
|
||
}
|
||
}
|
||
|
||
return rez;
|
||
#else
|
||
std::wstring result;
|
||
const char* pt = s.c_str();
|
||
size_t max = s.length();
|
||
int length;
|
||
wchar_t dest;
|
||
mbtowc (NULL, NULL, 0);
|
||
while (max>0)
|
||
{
|
||
length = mbtowc(&dest,pt,max);
|
||
if (length<1) break;
|
||
result+=dest;
|
||
pt+=length; max-=length;
|
||
}
|
||
return result;
|
||
#endif
|
||
return L"";
|
||
}*/
|
||
//---------------------------------------------------------------------------
|
||
//Размер файла в байтах
|
||
long getFileSize(std::string filename)
|
||
{
|
||
//#if defined(_WIN32) || defined(_WINDOWS) || defined(_BORLAND)
|
||
// unsigned long FileSize = 0;
|
||
// HANDLE hF = CreateFile(
|
||
// filename.c_str(), // file name
|
||
// GENERIC_READ, // access mode
|
||
// 0, // share mode
|
||
// NULL, // SD
|
||
// OPEN_EXISTING, // how to create
|
||
// 0, // file attributes
|
||
// NULL // handle to template file
|
||
// );
|
||
// FileSize = GetFileSize(hF, NULL);
|
||
// CloseHandle(hF);
|
||
// return FileSize;
|
||
//#else
|
||
std::ifstream in(filename.c_str(), std::ifstream::ate | std::ifstream::binary);
|
||
return (long)in.tellg();
|
||
|
||
//struct stat stat_buf;
|
||
//int rc = stat(filename.c_str(), &stat_buf);
|
||
//return rc == 0 ? stat_buf.st_size : -1;
|
||
//#endif
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Размер файла в байтах
|
||
long GetWFileSize(std::wstring filename)
|
||
{
|
||
std::string str = WStringToString(filename,std::locale(""));
|
||
std::wifstream in(str.c_str(), std::wifstream::ate | std::wifstream::binary);
|
||
return (long)in.tellg();
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Сохранение лог файла по 10 мегабайт (в 2 файлика)
|
||
bool logrotateW(std::wstring fileName, std::wstring data)
|
||
{
|
||
long fileSize = GetWFileSize(fileName);
|
||
//Переименовываем файл если он привысил размер
|
||
if(fileSize>1024*1024*10)
|
||
{
|
||
#if defined(_WIN32) || defined(_WINDOWS) || defined(_BORLAND)
|
||
//_wrename(fileName.c_str(),std::wstring(fileName+L".1").c_str());
|
||
std::string str = WStringToString(fileName,std::locale(""),'?');
|
||
std::rename(str.c_str(),std::string(str+".1").c_str());
|
||
#else
|
||
std::string str = WStringToString(fileName,std::locale(""));
|
||
rename(str.c_str(),std::string(str+".1").c_str());
|
||
#endif
|
||
}
|
||
//Записываем лог
|
||
std::string str = WStringToString(fileName,std::locale(""));
|
||
std::ofstream myfile(str.c_str(),std::fstream::app | std::fstream::out);
|
||
if (myfile.is_open())
|
||
{
|
||
myfile << data.c_str();
|
||
myfile.flush();
|
||
myfile.close();
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
bool logrotateUTF8(std::wstring fileName, std::wstring data)
|
||
{
|
||
long fileSize = GetWFileSize(fileName);
|
||
//Переименовываем файл если он привысил размер
|
||
if (fileSize>1024 * 1024 * 10)
|
||
{
|
||
#if defined(_WIN32) || defined(_WINDOWS) || defined(_BORLAND)
|
||
//_wrename(fileName.c_str(),std::wstring(fileName+L".1").c_str());
|
||
|
||
std::string str = WStringToString(fileName, std::locale(""));
|
||
rename(str.c_str(), std::string(str + ".1").c_str());
|
||
#else
|
||
std::string str = WStringToString(fileName,std::locale(""));
|
||
rename(str.c_str(),std::string(str+".1").c_str());
|
||
#endif
|
||
}
|
||
else if (fileSize == 0 || fileSize == -1) //Записываю сигнатуру то что это UTF8
|
||
{
|
||
std::string str = WStringToString(fileName,std::locale(""));
|
||
std::ofstream myfile(str.c_str(), std::fstream::app | std::fstream::out);
|
||
if (myfile.is_open())
|
||
{
|
||
myfile << (char)0xEF << (char)0xBB << (char)0xBF;
|
||
myfile.flush();
|
||
myfile.close();
|
||
}
|
||
}
|
||
|
||
//Записываем лог
|
||
std::string str = WStringToString(fileName,std::locale(""));
|
||
std::ofstream myfile(str.c_str(), std::fstream::app | std::fstream::out);
|
||
if (myfile.is_open())
|
||
{
|
||
std::time_t result = std::time(0);
|
||
std::string time = std::asctime(std::localtime(&result));
|
||
time = time.substr(0, time.length() - 1);
|
||
|
||
myfile << "[" << time << "] " << convUTF16ToUTF8(data).c_str() << std::endl;
|
||
myfile.flush();
|
||
myfile.close();
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
std::string escape_json(const std::string& input) {
|
||
std::ostringstream oss;
|
||
for (char c : input) {
|
||
switch (c) {
|
||
case '"': oss << "\\\""; break;
|
||
case '\\': oss << "\\\\"; break;
|
||
case '\b': oss << "\\b"; break;
|
||
case '\f': oss << "\\f"; break;
|
||
case '\n': oss << "\\n"; break;
|
||
case '\r': oss << "\\r"; break;
|
||
case '\t': oss << "\\t"; break;
|
||
default:
|
||
if (static_cast<unsigned char>(c) < 0x20 || c == 0x7F) {
|
||
oss << "\\u" << std::hex << std::setw(4) << std::setfill('0') << static_cast<int>(c);
|
||
} else {
|
||
oss << c;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
return oss.str();
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Сохранение лог файла по 10 мегабайт (в 2 файлика) Функция отрабатывает за 4 миллисекунды
|
||
/*bool logrotate(std::string fileName, std::string data, bool cout, int size)
|
||
{
|
||
long fileSize = GetFileSize(fileName);
|
||
//Переименовываем файл если он привысил размер
|
||
if(fileSize>1024*1024* size)
|
||
{
|
||
remove(std::string(fileName + ".1").c_str()); //Пытаюсь удалить старый файл
|
||
rename(fileName.c_str(),std::string(fileName+".1").c_str());
|
||
}
|
||
|
||
//Записываем лог
|
||
std::ofstream myfile(fileName.c_str(), std::ofstream::binary | std::fstream::app);
|
||
if (myfile.is_open())
|
||
{
|
||
std::stringstream str(std::stringstream::out | std::stringstream::binary);
|
||
#if defined(_WIN32) || defined(_WINDOWS) || defined(_BORLAND)
|
||
SYSTEMTIME st;
|
||
GetLocalTime(&st);
|
||
//LONG time_ms = (st.wSecond * 1000) + st.wMilliseconds;
|
||
//для конвертиции в строку: https://www.technical-recipes.com/2014/converting-a-systemtime-to-a-stdstring-in-c/
|
||
char buffer[256];
|
||
memset(buffer, 0, sizeof(buffer));
|
||
sprintf(buffer,
|
||
"%d.%02d.%02d %02d:%02d:%02d.%03d",
|
||
st.wYear,
|
||
st.wMonth,
|
||
st.wDay,
|
||
st.wHour,
|
||
st.wMinute,
|
||
st.wSecond,
|
||
st.wMilliseconds);
|
||
str << "[" << buffer << "] " << data << std::endl;
|
||
#else
|
||
timeval curTime;
|
||
gettimeofday(&curTime, NULL);
|
||
int milli = curTime.tv_usec / 1000;
|
||
std::time_t utime = curTime.tv_sec;
|
||
char buffer[80]; memset(buffer, 0, sizeof(buffer));
|
||
std::strftime(buffer, sizeof(buffer), "%Y.%m.%d %H:%M:%S", std::localtime(&utime));
|
||
str << "[" << buffer << ":" << milli << "] " << data << std::endl;
|
||
#endif
|
||
if (cout)
|
||
std::cout << "[" << buffer << "] " << data << std::endl; //Повтор лога в консоль
|
||
|
||
myfile.write(str.str().c_str(), str.str().length());
|
||
myfile.flush();
|
||
myfile.close();
|
||
return true;
|
||
}else
|
||
{
|
||
std::cerr << "Error: " << strerror(errno) << " " << fileName << std::endl;
|
||
}
|
||
return true;
|
||
}*/
|
||
|
||
bool logrotate(std::string fileName, std::string thread, std::string level, std::string data, bool cout, int size)
|
||
{
|
||
long fileSize = getFileSize(fileName);
|
||
//Переименовываем файл если он привысил размер
|
||
if(fileSize>1024*1024* size)
|
||
{
|
||
remove(std::string(fileName + ".1").c_str()); //Пытаюсь удалить старый файл
|
||
rename(fileName.c_str(),std::string(fileName+".1").c_str());
|
||
}
|
||
if(fileSize==-1){
|
||
createFolder(BeforeFirst(fileName,separator()));
|
||
}
|
||
|
||
//Записываем лог
|
||
std::ofstream myfile(fileName.c_str(), std::ofstream::binary | std::fstream::app);
|
||
if (myfile.is_open())
|
||
{
|
||
std::stringstream str(std::stringstream::out | std::stringstream::binary);
|
||
#if defined(_WIN32) || defined(_WINDOWS) || defined(_BORLAND)
|
||
SYSTEMTIME st;
|
||
GetLocalTime(&st);
|
||
char buffer[256];
|
||
memset(buffer, 0, sizeof(buffer));
|
||
sprintf(buffer,
|
||
"%d-%02d-%02d %02d:%02d:%02d.%03d",
|
||
st.wYear,
|
||
st.wMonth,
|
||
st.wDay,
|
||
st.wHour,
|
||
st.wMinute,
|
||
st.wSecond,
|
||
st.wMilliseconds);
|
||
str << "[" << buffer << "] " << data << std::endl;
|
||
#else
|
||
timeval curTime;
|
||
gettimeofday(&curTime, NULL);
|
||
int milli = curTime.tv_usec / 1000;
|
||
std::time_t utime = curTime.tv_sec;
|
||
char buffer[80]; memset(buffer, 0, sizeof(buffer));
|
||
std::strftime(buffer, sizeof(buffer), "%Y-%m-%dT%H:%M:%S", std::localtime(&utime));
|
||
str << "{\"timestamp\":\"" << buffer << "." << std::setw(3) << std::setfill('0') << milli << "Z\", \"thread\":\"" <<thread<<"\", \"level\":\""<<level<<"\", \"message\":\"" << escape_json(data)<<"\"}" << std::endl;
|
||
#endif
|
||
if (cout)
|
||
std::cout << "[" << buffer << "] " << data << std::endl; //Повтор лога в консоль
|
||
|
||
myfile.write(str.str().c_str(), str.str().length());
|
||
myfile.flush();
|
||
myfile.close();
|
||
return true;
|
||
}else
|
||
{
|
||
std::cerr << "Error: " << strerror(errno) << " " << fileName << std::endl;
|
||
}
|
||
return true;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
bool fileExists(std::string name)
|
||
{
|
||
if (FILE *file = fopen(name.c_str(), "r")) {
|
||
fclose(file);
|
||
return true;
|
||
} else {
|
||
return false;
|
||
}
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
std::string ws2s(const std::wstring& str)
|
||
{
|
||
#if defined(_WIN32) || defined(_WINDOWS) || defined(_BORLAND)
|
||
int len;
|
||
int slength = (int)str.length();// + 1;
|
||
if(slength==0) return "";
|
||
len = WideCharToMultiByte(CP_ACP, 0, str.c_str(), slength, 0, 0, 0, 0);
|
||
std::string rez(len, '\0');
|
||
WideCharToMultiByte(CP_ACP, 0, str.c_str(), slength, &rez[0], len, 0, 0);
|
||
|
||
//Каз символы из UTF16 в ASCII в ручную переводим
|
||
for(size_t i=0;i<str.length();i++)
|
||
{
|
||
switch (str[i])
|
||
{
|
||
case L'Ә': rez[i]=(char)0xA3; break;// Ә
|
||
case L'ә': rez[i]=(char)0xBC; break;// ә
|
||
case L'Ғ': rez[i]=(char)0xAA; break;// Ғ
|
||
case L'ғ': rez[i]=(char)0xBA; break;// ғ
|
||
case L'Қ': rez[i]=(char)0x8D; break;// Қ
|
||
case L'қ': rez[i]=(char)0x9D; break;// қ
|
||
case L'Ң': rez[i]=(char)0xBD; break;// Ң
|
||
case L'ң': rez[i]=(char)0xBE; break;// ң
|
||
case L'Ө': rez[i]=(char)0xA5; break;// Ө
|
||
case L'ө': rez[i]=(char)0xB4; break;// ө
|
||
case L'Ұ': rez[i]=(char)0xA1; break;// Ұ
|
||
case L'ұ': rez[i]=(char)0xA2; break;// ұ
|
||
case L'Ү': rez[i]=(char)0xAF; break;// Ү
|
||
case L'ү': rez[i]=(char)0xBF; break;// ү
|
||
case L'Һ': rez[i]=(char)0x8E; break;// Һ
|
||
case L'һ': rez[i]=(char)0x9E; break;// һ
|
||
//case L'І': rez[i]=(char)0xB2; break;// І
|
||
//case L'i': rez[i]=(char)0xB3; break;// i
|
||
case 10402: rez[i]=(char)0xB9; break;//L'№'
|
||
}
|
||
}
|
||
|
||
return rez;
|
||
#else
|
||
std::string result( str.begin(), str.end() );
|
||
return result;
|
||
#endif
|
||
return "";
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Конвертнуть Win1251 в utf8 //TRANSLIT//IGNORE
|
||
std::string iConvert(const std::string& instr,const char* fromCode,const char* toCode)
|
||
{
|
||
std::string outstr;
|
||
#if defined(_WIN32) || defined(_WINDOWS) || defined(_BORLAND)
|
||
|
||
#else
|
||
iconv_t cd = iconv_open(toCode, fromCode);
|
||
|
||
if( cd == (iconv_t)(-1) )
|
||
throw std::runtime_error("Не удалось открыть дескриптор iconv");
|
||
|
||
size_t in_size = instr.size();
|
||
char* inPrt = (char*)instr.c_str();
|
||
|
||
int BUF_SIZE=in_size*4;
|
||
char* out_buf = new char[BUF_SIZE];
|
||
char* outPtr;
|
||
size_t out_size;
|
||
|
||
size_t rSize;
|
||
|
||
while(in_size > 0)
|
||
{
|
||
outPtr = out_buf;
|
||
out_size = BUF_SIZE;
|
||
|
||
rSize = iconv(cd, &inPrt, &in_size, &outPtr, &out_size );
|
||
|
||
if(rSize == (size_t)-1 && errno)
|
||
{
|
||
switch (errno)
|
||
{
|
||
case EILSEQ:
|
||
throw std::runtime_error("invalid multibyte chars");
|
||
case EINVAL:
|
||
throw std::runtime_error("invalid multibyte chars");
|
||
default:
|
||
throw std::runtime_error("unknown error");
|
||
}
|
||
}
|
||
outstr.append(out_buf,BUF_SIZE-out_size);
|
||
}
|
||
|
||
if(iconv_close(cd)!=0 )
|
||
std::runtime_error("Не удается закрыть дескриптор iconv");
|
||
|
||
delete[] out_buf;
|
||
|
||
#endif
|
||
|
||
return outstr;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Конвертим из Unicode в DOS 866 кодировку
|
||
std::string UnicodeToDOS886(std::wstring str)
|
||
{
|
||
std::string rez;
|
||
rez.reserve(str.length()); //Количество символов не должно измениться
|
||
|
||
for(unsigned int i=0;i<str.length();i++)
|
||
{
|
||
switch(str[i])
|
||
{
|
||
case L'А': rez+=(char)0x80; break;
|
||
case L'Б': rez+=(char)0x81; break;
|
||
case L'В': rez+=(char)0x82; break;
|
||
case L'Г': rez+=(char)0x83; break;
|
||
case L'Д': rez+=(char)0x84; break;
|
||
case L'Е': rez+=(char)0x85; break;
|
||
case L'Ё': rez+=(char)0x85; break; //case L'Ё': rez+=(char)0xF0; break;
|
||
case L'Ж': rez+=(char)0x86; break;
|
||
case L'З': rez+=(char)0x87; break;
|
||
case L'И': rez+=(char)0x88; break;
|
||
case L'Й': rez+=(char)0x89; break;
|
||
case L'К': rez+=(char)0x8A; break;
|
||
case L'Л': rez+=(char)0x8B; break;
|
||
case L'М': rez+=(char)0x8C; break;
|
||
case L'Н': rez+=(char)0x8D; break;
|
||
case L'О': rez+=(char)0x8E; break;
|
||
case L'П': rez+=(char)0x8F; break;
|
||
case L'Р': rez+=(char)0x90; break;
|
||
case L'С': rez+=(char)0x91; break;
|
||
case L'Т': rez+=(char)0x92; break;
|
||
case L'У': rez+=(char)0x93; break;
|
||
case L'Ф': rez+=(char)0x94; break;
|
||
case L'Х': rez+=(char)0x95; break;
|
||
case L'Ц': rez+=(char)0x96; break;
|
||
case L'Ч': rez+=(char)0x97; break;
|
||
case L'Ш': rez+=(char)0x98; break;
|
||
case L'Щ': rez+=(char)0x99; break;
|
||
case L'Ъ': rez+=(char)0x9A; break;
|
||
case L'Ы': rez+=(char)0x9B; break;
|
||
case L'Ь': rez+=(char)0x9C; break;
|
||
case L'Э': rez+=(char)0x9D; break;
|
||
case L'Ю': rez+=(char)0x9E; break;
|
||
case L'Я': rez+=(char)0x9F; break;
|
||
case L'а': rez+=(char)0xA0; break;
|
||
case L'б': rez+=(char)0xA1; break;
|
||
case L'в': rez+=(char)0xA2; break;
|
||
case L'г': rez+=(char)0xA3; break;
|
||
case L'д': rez+=(char)0xA4; break;
|
||
case L'е': rez+=(char)0xA5; break;
|
||
case L'ё': rez+=(char)0xA5; break; //case L'ё': rez+=(char)0xF1; break;
|
||
case L'ж': rez+=(char)0xA6; break;
|
||
case L'з': rez+=(char)0xA7; break;
|
||
case L'и': rez+=(char)0xA8; break;
|
||
case L'й': rez+=(char)0xA9; break;
|
||
case L'к': rez+=(char)0xAA; break;
|
||
case L'л': rez+=(char)0xAB; break;
|
||
case L'м': rez+=(char)0xAC; break;
|
||
case L'н': rez+=(char)0xAD; break;
|
||
case L'о': rez+=(char)0xAE; break;
|
||
case L'п': rez+=(char)0xAF; break;
|
||
case L'р': rez+=(char)0xE0; break;
|
||
case L'с': rez+=(char)0xE1; break;
|
||
case L'т': rez+=(char)0xE2; break;
|
||
case L'у': rez+=(char)0xE3; break;
|
||
case L'ф': rez+=(char)0xE4; break;
|
||
case L'х': rez+=(char)0xE5; break;
|
||
case L'ц': rez+=(char)0xE6; break;
|
||
case L'ч': rez+=(char)0xE7; break;
|
||
case L'ш': rez+=(char)0xE8; break;
|
||
case L'щ': rez+=(char)0xE9; break;
|
||
case L'ъ': rez+=(char)0xEA; break;
|
||
case L'ы': rez+=(char)0xEB; break;
|
||
case L'ь': rez+=(char)0xEC; break;
|
||
case L'э': rez+=(char)0xED; break;
|
||
case L'ю': rez+=(char)0xEE; break;
|
||
case L'я': rez+=(char)0xEF; break;
|
||
//Каз-яз
|
||
/* case L'?': rez+=(char)0xDB; break;
|
||
case L'?': rez+=(char)0xDC; break;
|
||
case L'?': rez+=(char)0xDE; break;
|
||
case L'?': rez+=(char)0xDF; break;
|
||
case L'?': rez+=(char)0xF0; break;
|
||
case L'?': rez+=(char)0xF1; break;
|
||
case L'?': rez+=(char)0xF3; break;
|
||
case L'?': rez+=(char)0xF4; break;
|
||
case L'?': rez+=(char)0xF5; break;
|
||
case L'?': rez+=(char)0xF6; break;
|
||
case L'?': rez+=(char)0xF7; break;
|
||
case L'?': rez+=(char)0xF8; break;
|
||
case L'?': rez+=(char)0xFD; break;
|
||
case L'?': rez+=(char)0xFE; break;
|
||
*/
|
||
default: rez+=(char)str[i]; break;
|
||
}
|
||
}
|
||
return rez;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Обратная конвертация из DOS886 в Unicode
|
||
std::wstring DOS886ToUnicode(std::string str)
|
||
{
|
||
std::wstring rez;
|
||
rez.reserve(str.length()); //Количество символов не должно измениться
|
||
|
||
for(unsigned int i=0;i<str.length();i++)
|
||
{
|
||
switch(str[i])
|
||
{
|
||
case (char)0x80: rez+=L'А'; break;
|
||
case (char)0x81: rez+=L'Б'; break;
|
||
case (char)0x82: rez+=L'В'; break;
|
||
case (char)0x83: rez+=L'Г'; break;
|
||
case (char)0x84: rez+=L'Д'; break;
|
||
case (char)0x85: rez+=L'Е'; break;
|
||
//case (char)0xF0: rez+=L'Ё'; break; //В место "Ё" в принтере "?"
|
||
case (char)0x86: rez+=L'Ж'; break;
|
||
case (char)0x87: rez+=L'З'; break;
|
||
case (char)0x88: rez+=L'И'; break;
|
||
case (char)0x89: rez+=L'Й'; break;
|
||
case (char)0x8A: rez+=L'К'; break;
|
||
case (char)0x8B: rez+=L'Л'; break;
|
||
case (char)0x8C: rez+=L'М'; break;
|
||
case (char)0x8D: rez+=L'Н'; break;
|
||
case (char)0x8E: rez+=L'О'; break;
|
||
case (char)0x8F: rez+=L'П'; break;
|
||
case (char)0x90: rez+=L'Р'; break;
|
||
case (char)0x91: rez+=L'С'; break;
|
||
case (char)0x92: rez+=L'Т'; break;
|
||
case (char)0x93: rez+=L'У'; break;
|
||
case (char)0x94: rez+=L'Ф'; break;
|
||
case (char)0x95: rez+=L'Х'; break;
|
||
case (char)0x96: rez+=L'Ц'; break;
|
||
case (char)0x97: rez+=L'Ч'; break;
|
||
case (char)0x98: rez+=L'Ш'; break;
|
||
case (char)0x99: rez+=L'Щ'; break;
|
||
case (char)0x9A: rez+=L'Ъ'; break;
|
||
case (char)0x9B: rez+=L'Ы'; break;
|
||
case (char)0x9C: rez+=L'Ь'; break;
|
||
case (char)0x9D: rez+=L'Э'; break;
|
||
case (char)0x9E: rez+=L'Ю'; break;
|
||
case (char)0x9F: rez+=L'Я'; break;
|
||
case (char)0xA0: rez+=L'а'; break;
|
||
case (char)0xA1: rez+=L'б'; break;
|
||
case (char)0xA2: rez+=L'в'; break;
|
||
case (char)0xA3: rez+=L'г'; break;
|
||
case (char)0xA4: rez+=L'д'; break;
|
||
case (char)0xA5: rez+=L'е'; break;
|
||
//case (char)0xF1: rez+=L'ё'; break; //В место "ё" в принтере "?"
|
||
case (char)0xA6: rez+=L'ж'; break;
|
||
case (char)0xA7: rez+=L'з'; break;
|
||
case (char)0xA8: rez+=L'и'; break;
|
||
case (char)0xA9: rez+=L'й'; break;
|
||
case (char)0xAA: rez+=L'к'; break;
|
||
case (char)0xAB: rez+=L'л'; break;
|
||
case (char)0xAC: rez+=L'м'; break;
|
||
case (char)0xAD: rez+=L'н'; break;
|
||
case (char)0xAE: rez+=L'о'; break;
|
||
case (char)0xAF: rez+=L'п'; break;
|
||
case (char)0xE0: rez+=L'р'; break;
|
||
case (char)0xE1: rez+=L'с'; break;
|
||
case (char)0xE2: rez+=L'т'; break;
|
||
case (char)0xE3: rez+=L'у'; break;
|
||
case (char)0xE4: rez+=L'ф'; break;
|
||
case (char)0xE5: rez+=L'х'; break;
|
||
case (char)0xE6: rez+=L'ц'; break;
|
||
case (char)0xE7: rez+=L'ч'; break;
|
||
case (char)0xE8: rez+=L'ш'; break;
|
||
case (char)0xE9: rez+=L'щ'; break;
|
||
case (char)0xEA: rez+=L'ъ'; break;
|
||
case (char)0xEB: rez+=L'ы'; break;
|
||
case (char)0xEC: rez+=L'ь'; break;
|
||
case (char)0xED: rez+=L'э'; break;
|
||
case (char)0xEE: rez+=L'ю'; break;
|
||
case (char)0xEF: rez+=L'я'; break;
|
||
//Каз-яз
|
||
case (char)0xDB: rez+=L'?'; break;
|
||
case (char)0xDC: rez+=L'?'; break;
|
||
case (char)0xDE: rez+=L'?'; break;
|
||
case (char)0xDF: rez+=L'?'; break;
|
||
case (char)0xF0: rez+=L'?'; break;
|
||
case (char)0xF1: rez+=L'?'; break;
|
||
case (char)0xF3: rez+=L'?'; break;
|
||
case (char)0xF4: rez+=L'?'; break;
|
||
case (char)0xF5: rez+=L'?'; break;
|
||
case (char)0xF6: rez+=L'?'; break;
|
||
case (char)0xF7: rez+=L'?'; break;
|
||
case (char)0xF8: rez+=L'?'; break;
|
||
case (char)0xFD: rez+=L'?'; break;
|
||
case (char)0xFE: rez+=L'?'; break;
|
||
|
||
default: rez+=(char)str[i]; break;
|
||
}
|
||
}
|
||
return rez;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
std::string UIntToStdStr(unsigned int val)
|
||
{
|
||
std::stringstream ss;
|
||
ss << val;
|
||
return ss.str();
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
std::string IntToStdStr(int val)
|
||
{
|
||
std::ostringstream oss;
|
||
oss << val;
|
||
return oss.str();
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
template <typename T>
|
||
std::string toStringHex(T val)
|
||
{
|
||
std::ostringstream oss;
|
||
oss << std::hex << val;
|
||
return oss.str();
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
std::string toStringHex2(int val)
|
||
{
|
||
std::ostringstream oss;
|
||
oss << std::hex << val;
|
||
std::string result = oss.str();
|
||
if (result.length() % 2 != 0)
|
||
result = "0" + result;
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
std::string toHexString(unsigned char* mas,int len)
|
||
{
|
||
std::string result="";
|
||
for(int i=0;i<len;i++)
|
||
{
|
||
std::string str=toStringHex2(mas[i]);
|
||
if(str.length()==1)
|
||
result+="0"+str;
|
||
else
|
||
result+=str;
|
||
}
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
bool hexStringToArray(std::string data, char* mas)
|
||
{
|
||
int len = data.length() / 2;
|
||
for (int i = 0; i < len; i++) {
|
||
std::string val;
|
||
val += data[i * 2];
|
||
val += data[i * 2 + 1];
|
||
mas[i] = strtol(val.c_str(), NULL, 16);
|
||
}
|
||
return true;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Преобразовать HEX строку в число
|
||
template <typename T>
|
||
T fromStringHex(std::string val)
|
||
{
|
||
T value;
|
||
std::istringstream iss(val);
|
||
iss >> std::hex >> value;
|
||
return value;
|
||
}
|
||
//----------------------------------------------------------------------------
|
||
//ord - менять порядок байт
|
||
unsigned int hexStringToInt(std::string val, bool ord)
|
||
{
|
||
if (ord)
|
||
{
|
||
return (unsigned int)strtol(val.c_str(), NULL, 16);
|
||
}
|
||
else
|
||
{
|
||
std::string tmp;
|
||
for (unsigned int i = 0; i < val.size() / 2; i++)
|
||
{
|
||
tmp = val[i * 2 + 1] + tmp;
|
||
tmp = val[i * 2] + tmp;
|
||
}
|
||
return (unsigned int)strtol(tmp.c_str(), NULL, 16);
|
||
}
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
unsigned int hexStdStrToUInt(std::string& str)
|
||
{
|
||
unsigned int x;
|
||
std::stringstream ss;
|
||
ss << std::hex << str;
|
||
ss >> x;
|
||
return x;
|
||
}
|
||
//----------------------------------------------------------------------------
|
||
//Закодировать двоично десятичное число
|
||
//Преобразовать строку цифр в строку байт пример "1234" в 2 байта [12h,34h] если нечётное то 0 в начале
|
||
std::string CodeBSD(std::string str)
|
||
{
|
||
if(str.length()%2!=0) str="0"+str;
|
||
//Преобразуем 2 символа в 1 байт
|
||
std::string rez;
|
||
size_t len=str.length()/2;
|
||
for(size_t i=0;i<len;i++)
|
||
{
|
||
std::string ch;
|
||
ch+=str[i*2];
|
||
ch+=str[i*2+1];
|
||
unsigned char hch = fromStringHex<int>(ch);
|
||
rez+=hch;
|
||
}
|
||
return rez;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Закодировать двоично десятичное число
|
||
//Преобразовать строку цифр в строку байт пример "1234" в 2 байта [12h,34h] если нечётное то 0 в начале
|
||
//len - количество (байт)символов добавит нули в начале если получилось меньше
|
||
std::string CodeBSD(int val,int len)
|
||
{
|
||
std::string str=CodeBSD(IntToStdStr(val));
|
||
for(int i=str.length();i<len;i++) //Медленно
|
||
str=(char)0x00+str;
|
||
return str;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Двоично десятичный символ в int
|
||
int BSDToInt(char chr)
|
||
{
|
||
std::string data = DecodeBSD(chr);
|
||
return StdStrToInt(data);
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Двоично десятичную строку в int
|
||
int BSDToInt(std::string str, size_t start, size_t len)
|
||
{
|
||
std::string data = DecodeBSD(str,start,len);
|
||
return StdStrToInt(data);
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Раскодировать двоично десятичное число 2 байта [12h,34h] преобразуются в строку "1234"
|
||
std::string DecodeBSD(char chr)
|
||
{
|
||
std::string rez;
|
||
unsigned char ch;
|
||
|
||
ch=(chr >> 4) & 0x0F;
|
||
if(ch<10) rez+=(char)(48+ch);
|
||
else rez+='0'; //такого не должно быть
|
||
|
||
ch=chr & 0x0F;
|
||
if(ch<10) rez+=(char)(48+ch);
|
||
else rez+='0'; //такого не должно быть
|
||
|
||
return rez;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Раскодировать двоично десятичное число 2 байта [12h,34h] преобразуются в строку "1234"
|
||
std::string DecodeBSD(std::string str, size_t start, size_t len)
|
||
{
|
||
if(len==0) len=str.length();
|
||
len=start+len;
|
||
if(len>str.length()) len=str.length();
|
||
std::string rez;
|
||
for(size_t i=start;i<len;i++)
|
||
{
|
||
rez+=DecodeBSD(str[i]);
|
||
}
|
||
return rez;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//std::wstring StringToWString( const std::string& in, std::locale loc )
|
||
std::wstring StringToWString(const std::string& in, const std::locale &loc)
|
||
{
|
||
std::wstring out;
|
||
std::string::const_iterator i( in.begin() ), ie( in.end() );
|
||
for( ; i!=ie; ++i )
|
||
out += std::use_facet<std::ctype<wchar_t> > ( loc ).widen( *i );
|
||
return out;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Запись в строку line, align: 1 = лево, 2 = центр, 3 = право
|
||
void printToPos(std::wstring& line, std::wstring data, char align) {
|
||
switch (align) {
|
||
case 1: {
|
||
for (uint32_t i = 0; i < std::min(line.length(), data.length()); i++) //На min ругалось сделал std::min
|
||
{
|
||
line[i] = data[i];
|
||
}
|
||
break;
|
||
}
|
||
case 2: {
|
||
int p1 = line.length() / 2.0f;
|
||
int p2 = data.length() / 2.0f;
|
||
int st = p1 - p2;
|
||
for (uint32_t i = st; i < st + data.length(); i++)
|
||
{
|
||
if (i > 0 && i < line.length()) {
|
||
line[i] = data[i - st];
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case 3: {
|
||
for (uint32_t i = 0; i < std::min(line.length(), data.length()); i++)
|
||
{
|
||
line[line.length()-i-1] = data[data.length()-i-1];
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
void replaseChars(std::string& str, char oldCh, char newCh)
|
||
{
|
||
int indexCh = str.find(oldCh);
|
||
while (indexCh != -1)
|
||
{
|
||
str.replace(indexCh,1,1,newCh);
|
||
indexCh = str.find(oldCh,indexCh);
|
||
}
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
/*inline std::string replace(std::string text, std::string s, std::string d)
|
||
{
|
||
for(unsigned index=0; index=text.find(s, index), index!=std::string::npos;)
|
||
{
|
||
text.replace(index, s.length(), d);
|
||
index+=d.length();
|
||
}
|
||
return text;
|
||
}*/
|
||
//---------------------------------------------------------------------------
|
||
//Заменить подстроку на другую
|
||
void replaceAll(std::wstring& str, const std::wstring from, const std::wstring to)
|
||
{
|
||
if (from.empty())
|
||
return;
|
||
size_t start_pos = 0;
|
||
while ((start_pos = str.find(from, start_pos)) != std::string::npos)
|
||
{
|
||
str.replace(start_pos, from.length(), to);
|
||
start_pos += to.length();
|
||
}
|
||
}
|
||
//------------------------------------------------------------------------------
|
||
//Заменить подстроку на другую
|
||
void replaceAll(std::string& str, const std::string from, const std::string to)
|
||
{
|
||
if (from.empty())
|
||
return;
|
||
size_t start_pos = 0;
|
||
while ((start_pos = str.find(from, start_pos)) != std::string::npos)
|
||
{
|
||
str.replace(start_pos, from.length(), to);
|
||
start_pos += to.length();
|
||
}
|
||
}
|
||
//------------------------------------------------------------------------------
|
||
//Заменить все вхождения строки find в sors на repl (wxString::Replace)
|
||
std::string replaceStrings(std::string sors,std::string find,std::string repl)
|
||
{
|
||
if(find==repl) return sors;
|
||
std::string rez="";
|
||
size_t p0=0;
|
||
size_t p1 = sors.find(find,p0);
|
||
while(p1!=std::string::npos)
|
||
{
|
||
rez.append(sors,p0,p1-p0);
|
||
rez+=repl;
|
||
p0=p1+find.length();
|
||
p1=sors.find(find,p0);
|
||
}
|
||
rez.append(sors,p0,sors.length()-p0);
|
||
return rez;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
std::wstring replaceStrings(std::wstring sors,std::wstring find,std::wstring repl)
|
||
{
|
||
if(find==repl) return sors;
|
||
std::wstring rez=L"";
|
||
size_t p0=0;
|
||
size_t p1 = sors.find(find,p0);
|
||
while(p1!=std::wstring::npos)
|
||
{
|
||
rez.append(sors,p0,p1-p0);
|
||
rez+=repl;
|
||
p0=p1+find.length();
|
||
p1=sors.find(find,p0);
|
||
}
|
||
rez.append(sors,p0,sors.length()-p0);
|
||
return rez;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Получить дату в виде ANSI строки в формате ddmmyyyy
|
||
std::string getStrDate()
|
||
{
|
||
time_t t=time(NULL);
|
||
tm* st=localtime(&t);
|
||
|
||
std::string str1=IntToStdStr(st->tm_mday);
|
||
if(str1.length()==1) str1="0"+str1;
|
||
std::string str2=IntToStdStr(st->tm_mon+1);
|
||
if(str2.length()==1) str2="0"+str2;
|
||
std::string str3=IntToStdStr(st->tm_year+1900);
|
||
if(str3.length()==1) str3="0"+str3;
|
||
|
||
//delete st; Ошибка памяти будет если удалю
|
||
return str1+str2+str3;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Преобразую строку вида 02-10-18 20:51:40 в unix time
|
||
unsigned int getTime1(std::string date)
|
||
{
|
||
#if defined(_WIN32) || defined(_WINDOWS) || defined(_BORLAND)
|
||
std::string tmp;
|
||
//struct tm {
|
||
//int tm_sec; // seconds
|
||
//int tm_min; // minutes
|
||
//int tm_hour; // hours
|
||
//int tm_mday; // day of the month
|
||
//int tm_mon; // month
|
||
//int tm_year; // year
|
||
//int tm_wday; // day of the week
|
||
//int tm_yday; // day in the year
|
||
//int tm_isdst; // daylight saving time
|
||
//};
|
||
struct tm tmd;
|
||
memset(&tmd, 0, sizeof(struct tm));
|
||
|
||
tmp=CutBeforeFirst(date, "-");
|
||
tmd.tm_mday = StdStrToInt(tmp);
|
||
tmp=CutBeforeFirst(date, "-");
|
||
tmd.tm_mon = StdStrToInt(tmp);
|
||
tmp=CutBeforeFirst(date, " ");
|
||
tmd.tm_year = (2000 + StdStrToInt(tmp)) - 1900;
|
||
|
||
tmp=CutBeforeFirst(date, ":");
|
||
tmd.tm_hour = StdStrToInt(tmp);
|
||
tmp=CutBeforeFirst(date, ":");
|
||
tmd.tm_min = StdStrToInt(tmp);
|
||
tmd.tm_sec = StdStrToInt(date);
|
||
|
||
time_t time = mktime(&tmd);
|
||
return (unsigned int)time;
|
||
#else
|
||
return 0;
|
||
#endif
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Получить дату в виде Unicode строки в формате ddmmyyyy
|
||
std::wstring getWStrDate()
|
||
{
|
||
return StringToWString(getStrDate(),std::locale(""));
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Дата и время в виде строки dd.mm.yyyy hh:mm:ss пример 24.05.2010 15:20:26
|
||
std::string getDateTime()
|
||
{
|
||
/*
|
||
#if defined( _VC )
|
||
//Для проекта с ATL библиотекой
|
||
std::string tmp,res="";
|
||
SYSTEMTIME st;
|
||
GetLocalTime(&st);
|
||
//Дата
|
||
tmp=toStdStr(st.wDay);
|
||
if(tmp.length()==1) res+="0"+tmp+"."; else res+=tmp+".";
|
||
tmp=toStdStr(st.wMonth);
|
||
if(tmp.length()==1) res+="0"+tmp+"."; else res+=tmp+".";
|
||
res+=toStdStr(st.wYear)+" ";
|
||
|
||
//Время
|
||
tmp=toStdStr(st.wHour);
|
||
if(tmp.length()==1) res+="0"+tmp+":"; else res+=tmp+":";
|
||
tmp=toStdStr(st.wMinute);
|
||
if(tmp.length()==1) res+="0"+tmp+":"; else res+=tmp+":";
|
||
tmp=toStdStr(st.wSecond);
|
||
if(tmp.length()==1) res+="0"+tmp; else res+=tmp;
|
||
|
||
return res;
|
||
#endif
|
||
#if defined( _WX )
|
||
//Для кросплатформенного проекта wxWidgets
|
||
return "";
|
||
#endif
|
||
*/
|
||
std::string tmp,res="";
|
||
|
||
time_t t=time(NULL);
|
||
tm* st=localtime(&t);
|
||
|
||
//Дата
|
||
tmp=IntToStdStr(st->tm_mday);
|
||
if(tmp.length()==1) res+="0"+tmp+"."; else res+=tmp+".";
|
||
tmp=IntToStdStr(st->tm_mon+1);
|
||
if(tmp.length()==1) res+="0"+tmp+"."; else res+=tmp+".";
|
||
res+=IntToStdStr(st->tm_year+1900)+" ";
|
||
|
||
//Время
|
||
tmp=IntToStdStr(st->tm_hour);
|
||
if(tmp.length()==1) res+="0"+tmp+":"; else res+=tmp+":";
|
||
tmp=IntToStdStr(st->tm_min);
|
||
if(tmp.length()==1) res+="0"+tmp+":"; else res+=tmp+":";
|
||
tmp=IntToStdStr(st->tm_sec);
|
||
if(tmp.length()==1) res+="0"+tmp; else res+=tmp;
|
||
|
||
//delete st; //Ошибка памяти будет если удалю
|
||
return res;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Float в строку
|
||
/*std::string FloatToStdStr(float val)
|
||
{
|
||
std::ostringstream oss;
|
||
oss << val;
|
||
return oss.str();
|
||
}*/
|
||
//---------------------------------------------------------------------------
|
||
//Преобразовать в строку (Разделитель всегда точка)
|
||
//digits - Сколько цифр после запятой оставлять если -1 то по полной
|
||
std::string FloatToStdStr(double val, int digits,char sep)
|
||
{
|
||
std::ostringstream oss;
|
||
if(digits >= 0)
|
||
oss << std::fixed << std::setprecision( digits ) << val;
|
||
else oss << std::fixed << val;
|
||
|
||
std::string str=oss.str();
|
||
if(sep=='.')
|
||
std::replace( str.begin(), str.end(), ',', '.');
|
||
if(sep==',')
|
||
std::replace( str.begin(), str.end(), '.', ',');
|
||
|
||
int pos=MAX(str.find('.'),str.find(',')); //Позиция запятой в строке (TODO взять разделитель из системных параметров)
|
||
//Обрезаем строку
|
||
if(digits>=0 && pos>=0)
|
||
{ if(digits==0) digits=-1; //Чтоб убрать запятую
|
||
|
||
std::string result="";
|
||
result.append(str,0,pos+digits+1);
|
||
return result;
|
||
}else return str;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
std::wstring FloatToStdWStr(double val, int digits)
|
||
{
|
||
std::string str = FloatToStdStr(val,digits);
|
||
std::wstring wsTmp(str.begin(), str.end());
|
||
return wsTmp;
|
||
//return s2ws(str);
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
template <typename T>
|
||
std::wstring toStdWStr(T val)
|
||
{
|
||
std::ostringstream oss;
|
||
oss << val;
|
||
|
||
std::string str=oss.str();
|
||
return StringToWString( str, std::locale(""));
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
std::wstring IntToStdWStr(int val)
|
||
{
|
||
return toStdWStr(val);
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
template<typename T>
|
||
T fromString(const std::string& s)
|
||
{
|
||
std::istringstream iss(s);
|
||
T res;
|
||
iss >> res;
|
||
return res;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Преобразовать строку в число
|
||
//str - Исходная строка с числом
|
||
//cutInt - вырезать из строки только цифры
|
||
int StdStrToInt(std::string& str, bool cutInt, int def)
|
||
{
|
||
if(cutInt)
|
||
{
|
||
std::string val="";
|
||
for(unsigned int i=0;i<str.length();i++)
|
||
{
|
||
if((str[i]=='-' && (val.length()==0 || val[0]!='-')) || str[i]=='0' || str[i]=='1' || str[i]=='2' || str[i]=='3' || str[i]=='4' || str[i]=='5' || str[i]=='6' || str[i]=='7' || str[i]=='8' || str[i]=='9')
|
||
val+=str[i];
|
||
}
|
||
if(val=="") return def;
|
||
return fromString<int>(val);
|
||
}
|
||
if(str=="") return def;
|
||
return fromString<int>(str);
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Преобразовать строку в число
|
||
//str - Исходная строка с числом
|
||
//cutInt - вырезать из строки только цифры
|
||
uint32_t StdStrToUInt(std::string& str, bool cutInt, uint32_t def)
|
||
{
|
||
if(cutInt)
|
||
{
|
||
std::string val="";
|
||
for(unsigned int i=0;i<str.length();i++)
|
||
{
|
||
if(str[i]=='0' || str[i]=='1' || str[i]=='2' || str[i]=='3' || str[i]=='4' || str[i]=='5' || str[i]=='6' || str[i]=='7' || str[i]=='8' || str[i]=='9')
|
||
val+=str[i];
|
||
}
|
||
if(val=="") return def;
|
||
return fromString<int>(val);
|
||
}
|
||
if(str=="") return def;
|
||
return fromString<int>(str);
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
float StdStrToFloat(std::string& str)
|
||
{
|
||
if(str=="") return 0;
|
||
return fromString<float>(str);
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
double StdStrToDouble(std::string& str,double defval)
|
||
{
|
||
if(str=="") return defval;
|
||
return fromString<double>(str);
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
double StdWStrToDouble(std::wstring str, double defval)
|
||
{
|
||
if (str == L"") return defval;
|
||
return fromWString<double>(str);
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
template<typename T>
|
||
T fromWString(const std::wstring& s)
|
||
{
|
||
std::string str=WStringToString(s, std::locale(""));
|
||
|
||
std::istringstream iss(str);
|
||
T res;
|
||
iss >> res;
|
||
return res;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
int StdWStrToInt(const std::wstring& str, bool cutInt)
|
||
{
|
||
if(cutInt)
|
||
{
|
||
std::wstring val=L"";
|
||
for(unsigned int i=0;i<str.length();i++)
|
||
{
|
||
if((str[i]==L'-' && (val.length()==0 || val[0]!=L'-')) || str[i]==L'0' || str[i]==L'1' || str[i]==L'2' || str[i]==L'3' || str[i]==L'4' || str[i]==L'5' || str[i]==L'6' || str[i]==L'7' || str[i]==L'8' || str[i]==L'9')
|
||
val+=str[i];
|
||
}
|
||
if(val==L"") return 0;
|
||
return fromWString<int>(val);
|
||
}
|
||
if(str==L"") return 0;
|
||
|
||
return fromWString<int>(str);
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
int StdWStrToUInt(const std::wstring& str, bool cutInt)
|
||
{
|
||
if(cutInt)
|
||
{
|
||
std::wstring val=L"";
|
||
for(unsigned int i=0;i<str.length();i++)
|
||
{
|
||
if(str[i]==L'0' || str[i]==L'1' || str[i]==L'2' || str[i]==L'3' || str[i]==L'4' || str[i]==L'5' || str[i]==L'6' || str[i]==L'7' || str[i]==L'8' || str[i]==L'9')
|
||
val+=str[i];
|
||
}
|
||
if(val==L"") return 0;
|
||
return fromWString<int>(val);
|
||
}
|
||
if(str==L"") return 0;
|
||
return fromWString<int>(str);
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
///К верхнему регистру строку
|
||
std::wstring UpperCase(const std::wstring& str)
|
||
{
|
||
std::wstring res=L""; //TODO Надо выделить память
|
||
for(unsigned int i=0;i<str.length();i++)
|
||
{
|
||
switch( str[i] )
|
||
{
|
||
case L'a': res+=L'A'; break;
|
||
case L'b': res+=L'B'; break;
|
||
case L'c': res+=L'C'; break;
|
||
case L'd': res+=L'D'; break;
|
||
case L'e': res+=L'E'; break;
|
||
case L'f': res+=L'F'; break;
|
||
case L'g': res+=L'G'; break;
|
||
case L'h': res+=L'H'; break;
|
||
case L'i': res+=L'I'; break;
|
||
case L'j': res+=L'J'; break;
|
||
case L'k': res+=L'K'; break;
|
||
case L'l': res+=L'L'; break;
|
||
case L'm': res+=L'M'; break;
|
||
case L'n': res+=L'N'; break;
|
||
case L'o': res+=L'O'; break;
|
||
case L'p': res+=L'P'; break;
|
||
case L'q': res+=L'Q'; break;
|
||
case L'r': res+=L'R'; break;
|
||
case L's': res+=L'S'; break;
|
||
case L't': res+=L'T'; break;
|
||
case L'u': res+=L'U'; break;
|
||
case L'v': res+=L'V'; break;
|
||
case L'w': res+=L'W'; break;
|
||
case L'x': res+=L'X'; break;
|
||
case L'y': res+=L'Y'; break;
|
||
case L'z': res+=L'Z'; break;
|
||
|
||
case L'а': res+=L'А'; break;
|
||
case L'б': res+=L'Б'; break;
|
||
case L'в': res+=L'В'; break;
|
||
case L'г': res+=L'Г'; break;
|
||
case L'д': res+=L'Д'; break;
|
||
case L'е': res+=L'Е'; break;
|
||
case L'ё': res+=L'Ё'; break;
|
||
case L'ж': res+=L'Ж'; break;
|
||
case L'з': res+=L'З'; break;
|
||
case L'и': res+=L'И'; break;
|
||
case L'к': res+=L'К'; break;
|
||
case L'л': res+=L'Л'; break;
|
||
case L'м': res+=L'М'; break;
|
||
case L'н': res+=L'Н'; break;
|
||
case L'о': res+=L'О'; break;
|
||
case L'п': res+=L'П'; break;
|
||
case L'р': res+=L'Р'; break;
|
||
case L'с': res+=L'С'; break;
|
||
case L'т': res+=L'Т'; break;
|
||
case L'у': res+=L'У'; break;
|
||
case L'ф': res+=L'Ф'; break;
|
||
case L'х': res+=L'Х'; break;
|
||
case L'ц': res+=L'Ц'; break;
|
||
case L'ч': res+=L'Ч'; break;
|
||
case L'ш': res+=L'Ш'; break;
|
||
case L'щ': res+=L'Щ'; break;
|
||
case L'ъ': res+=L'Ъ'; break;
|
||
case L'ы': res+=L'Ы'; break;
|
||
case L'ь': res+=L'Ь'; break;
|
||
case L'э': res+=L'Э'; break;
|
||
case L'ю': res+=L'Ю'; break;
|
||
case L'я': res+=L'Я'; break;
|
||
default:
|
||
res+=str[i];
|
||
}
|
||
}
|
||
return res;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
///Получить строку до указанного символа если символа нет то вернёт всю строку.
|
||
std::string BeforeLast(std::string str,char ch)
|
||
{
|
||
int pos=0;
|
||
for(uint32_t i=0;i<str.length();i++)
|
||
{
|
||
if(str[i]==ch) pos=i;
|
||
}
|
||
if(pos==0) pos=str.length();
|
||
|
||
std::string result="";
|
||
result.append(str,0,pos);
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
///Получить строку до указанного символа если символа нет то вернёт всю строку.
|
||
std::wstring BeforeWLast(std::wstring str,wchar_t ch)
|
||
{
|
||
int pos=0;
|
||
for(uint32_t i=0;i<str.length();i++)
|
||
{
|
||
if(str[i]==ch) pos=i;
|
||
}
|
||
if(pos==0) pos=str.length();
|
||
|
||
std::wstring result=L"";
|
||
result.append(str,0,pos);
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
std::string BeforeFirst(std::string str,const unsigned char ch)
|
||
{
|
||
unsigned int pos=str.find(ch);
|
||
std::string result="";
|
||
result.append(str,0,pos);
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
std::string BeforeFirst(std::string str,const char ch)
|
||
{
|
||
unsigned int pos=str.find(ch);
|
||
std::string result="";
|
||
result.append(str,0,pos);
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
std::wstring BeforeWFirst(std::wstring str,const wchar_t ch)
|
||
{
|
||
unsigned int pos=str.find(ch);
|
||
std::wstring result=L"";
|
||
result.append(str,0,pos);
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
std::string CutAfterFirst(std::string& str,std::string br)
|
||
{
|
||
size_t pos=str.find(br);
|
||
std::string result="";
|
||
if(pos==std::string::npos)
|
||
{
|
||
result.append(str);
|
||
str.erase();
|
||
}else
|
||
{
|
||
result.append(str,pos + br.size(),str.length() - pos - br.size());
|
||
str.erase(pos);
|
||
}
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Если не найдёт нужный символ то вернёт всю строку
|
||
std::string CutAfterLast(std::string& str,const unsigned char ch)
|
||
{
|
||
std::string result="";
|
||
size_t pos=str.find_last_of(ch);
|
||
if(pos!=std::string::npos)
|
||
{
|
||
result.append(str,pos+1,str.length()-pos-1);
|
||
str.erase(pos);
|
||
}else
|
||
{
|
||
result.append(str);
|
||
str.erase();
|
||
}
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Отрезать от строки до указанного символа если не найден символ отрезается вся строка
|
||
std::string CutBeforeFirst(std::string& str,const char ch)
|
||
{
|
||
int pos=str.find(ch);
|
||
std::string result="";
|
||
if(pos==-1)
|
||
{
|
||
result.append(str);
|
||
str.erase();
|
||
}else
|
||
{
|
||
result.append(str,0,pos);
|
||
str.erase(0,pos+1);
|
||
}
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Отрезать от строки до указанного символа если не найден символ отрезается вся строка
|
||
std::string CutBeforeFirst(std::string& str,const std::string br)
|
||
{
|
||
int pos=str.find(br);
|
||
std::string result="";
|
||
if(pos==-1)
|
||
{
|
||
result.append(str);
|
||
str.erase();
|
||
}else
|
||
{
|
||
if(pos>0)
|
||
result.append(str,0,pos);
|
||
str.erase(0,pos+br.size());
|
||
}
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Отрезать от строки до указанного символа если не найден символ отрезается вся строка
|
||
std::wstring CutBeforeWFirst(std::wstring& str,const wchar_t ch)
|
||
{
|
||
int pos=str.find(ch);
|
||
std::wstring result=L"";
|
||
if(pos==-1)
|
||
{
|
||
result.append(str);
|
||
str.erase();
|
||
}else
|
||
{
|
||
result.append(str,0,pos);
|
||
str.erase(0,pos+1);
|
||
}
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
std::string AfterFirst(std::string str,const char ch)
|
||
{
|
||
unsigned int pos=str.find(ch);
|
||
std::string result="";
|
||
result.append(str,pos+1,str.size());
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
std::wstring AfterWFirst(std::wstring str,const wchar_t ch)
|
||
{
|
||
unsigned int pos=str.find(ch);
|
||
std::wstring result=L"";
|
||
result.append(str,pos+1,str.size());
|
||
return result;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Всё после заданного разделителя, если разделитель не найден то сначала строки
|
||
std::string AfterLast(std::string str,const char ch)
|
||
{
|
||
int pos=str.find_last_of(ch)+1;
|
||
int len=str.length()-pos;
|
||
return str.substr(pos,len);
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
std::string WStringToString(const std::wstring &wstr, const std::locale &loc, char default_char)
|
||
{
|
||
//std::wcout << L"wstr=" << wstr<< std::endl;;
|
||
|
||
if (wstr.empty())
|
||
return std::string();
|
||
|
||
//закоментил потому что маленькую букву я не преобразует
|
||
std::string ret;
|
||
ret.resize(wstr.length());
|
||
std::use_facet<std::ctype<wchar_t> >(loc).narrow(&wstr[0], &wstr[0] + wstr.length(), '?', &ret[0]);
|
||
return ret;
|
||
|
||
|
||
/*
|
||
std::ctype<wchar_t> const &facet = std::use_facet<std::ctype<wchar_t> >(loc);
|
||
wchar_t const *first = wstr.c_str();
|
||
wchar_t const *last = first + wstr.size();
|
||
std::vector<char> result(wstr.size());
|
||
|
||
facet.narrow(first, last, default_char, &result[0]);
|
||
|
||
return std::string(result.begin(), result.end());
|
||
*/
|
||
|
||
/*
|
||
//setup converter
|
||
using convert_type = std::codecvt_utf8<wchar_t>;
|
||
std::wstring_convert<convert_type, wchar_t> converter;
|
||
//use converter (.to_bytes: wstr->str, .from_bytes: str->wstr)
|
||
std::string converted_str = converter.to_bytes( wstr );
|
||
return converted_str;
|
||
*/
|
||
|
||
/*
|
||
using convert_typeX = std::codecvt_utf8<wchar_t>;
|
||
std::wstring_convert<convert_typeX, wchar_t> converterX;
|
||
return converterX.to_bytes(wstr);*/
|
||
/*
|
||
static std::wstring_convert< std::codecvt_utf8<wchar_t>, wchar_t > converter ;
|
||
return converter.to_bytes(wstr) ;
|
||
*/
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Получить полный путь к текущему EXE файлу
|
||
std::wstring getExePathW(bool add)
|
||
{
|
||
#if defined(_WIN32) || defined(_WINDOWS) || defined(_BORLAND)
|
||
std::wstring str;
|
||
wchar_t pathBuf[MAX_PATH] = { 0 };
|
||
GetModuleFileNameW(NULL, pathBuf, MAX_PATH);
|
||
str = pathBuf;
|
||
str = BeforeWLast(str, L'\\');
|
||
if (add) str += L'\\';
|
||
return str;
|
||
#else
|
||
std::wstring str = L".";
|
||
if (add) str += L'\\';
|
||
return str;
|
||
#endif
|
||
return L"";
|
||
/*
|
||
это к DLL делал но не пригодилось (по хенделу)
|
||
std::wstring str;
|
||
#if defined(_WIN32) || defined(_WINDOWS) || defined(_BORLAND)
|
||
wchar_t pathBuf[MAX_PATH] = {0};
|
||
HMODULE thisModule = 0;
|
||
BOOL ret = GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (LPCTSTR)&__FUNCTION__, &thisModule);
|
||
DWORD nLen = GetModuleFileName(thisModule, pathBuf, MAX_PATH);
|
||
str=pathBuf;
|
||
if(!add) str=BeforeWLast(str,L'\\')+L'\\';
|
||
#endif
|
||
return str;
|
||
*/
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
/*std::string getExePath()
|
||
{
|
||
//если EXE то
|
||
//return ExtractFilePath(ParamStr(0)).c_str();
|
||
//Если DLL то
|
||
return "";
|
||
}*/
|
||
//---------------------------------------------------------------------------
|
||
//Получить полный путь к текущему EXE файлу
|
||
std::string getExePathA(bool add)
|
||
{
|
||
#if defined(_WIN32) || defined(_WINDOWS) || defined(_BORLAND)
|
||
std::string str;
|
||
char pathBuf[MAX_PATH] = {0};
|
||
GetModuleFileNameA(NULL,pathBuf,MAX_PATH);
|
||
str=pathBuf;
|
||
str=BeforeLast(str,'\\');
|
||
if (add) str += '\\';
|
||
return str;
|
||
#else
|
||
std::string str=".";
|
||
if (add) str += '\\';
|
||
return str;
|
||
#endif
|
||
return "";
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Путь к дирректории приложений, для хранения настроек (если линукс то к томайней директории пользователя) без завершающего слеша
|
||
std::string getAppPath()
|
||
{
|
||
#if defined(_WIN32) || defined(_WINDOWS) || defined(_BORLAND)
|
||
std::string path;
|
||
char szPath[MAX_PATH];
|
||
memset(szPath,0,MAX_PATH);
|
||
if (SUCCEEDED(SHGetFolderPathA(NULL, CSIDL_COMMON_APPDATA, NULL, 0, szPath)))
|
||
//if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_APPDATA, NULL, 0, szPath)))
|
||
{
|
||
path=szPath;
|
||
}
|
||
return path;
|
||
#else
|
||
struct passwd *pw = getpwuid(getuid());
|
||
return pw->pw_dir;
|
||
#endif
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Добавить 0 в начало строоки если 1 символ для даты нужно
|
||
std::string add0(std::string str)
|
||
{
|
||
if(str.length()==1) return "0"+str;
|
||
else return str;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Конвертация из UTF16LE в UTF8
|
||
std::string convUTF16ToUTF8(const std::wstring& widestring)
|
||
{
|
||
unsigned int len8=0;
|
||
unsigned int len16=widestring.length();
|
||
const wchar_t* p16=widestring.data();
|
||
for(unsigned int i=0;i<len16;i++) //Подсчитываем размер буфера
|
||
{
|
||
if(p16[i]<=0x7f) len8++; else
|
||
if(p16[i]<=0x7ff) len8+=2; else
|
||
if(p16[i]<=0xffff) len8+=3; else
|
||
if(p16[i]<=0x10ffff) len8+=4;
|
||
}
|
||
unsigned char * p8=new unsigned char[len8];
|
||
unsigned int pos=0;
|
||
for(unsigned int i=0;i<len16;i++)
|
||
{
|
||
if(p16[i]<=0x7f)
|
||
{
|
||
p8[pos]=(unsigned char)p16[i];
|
||
pos++;
|
||
}else
|
||
if(p16[i]<=0x7ff) //110xxxxx, 10xxxxxx
|
||
{
|
||
p8[pos]=(p16[i]>>6 | 192) & 223;
|
||
pos++;
|
||
p8[pos]=(p16[i] | 128) & 191;
|
||
pos++;
|
||
}else
|
||
if(p16[i]<=0xffff) //1110xxxx 10xxxxxx 10xxxxxx
|
||
{
|
||
p8[pos]=(p16[i]>>12 | 224) & 239;
|
||
pos++;
|
||
p8[pos]=(p16[i]>>6 | 128) & 191;
|
||
pos++;
|
||
p8[pos]=(p16[i] | 128) & 191;
|
||
pos++;
|
||
}else
|
||
if(p16[i]<=0x10ffff) //11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
|
||
{
|
||
p8[pos]=(p16[i]>>18 | 240) & 247;
|
||
pos++;
|
||
p8[pos]=(p16[i]>>12 | 128) & 191;
|
||
pos++;
|
||
p8[pos]=(p16[i]>>6 | 128) & 191;
|
||
pos++;
|
||
p8[pos]=(p16[i] | 128) & 191;
|
||
pos++;
|
||
}
|
||
}
|
||
std::string str;
|
||
str.append((char*)p8,len8);
|
||
delete[] p8;
|
||
return str;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Конвертация из UTF8 в UTF16LE
|
||
std::wstring convUTF8ToUTF16(const std::string& str)
|
||
{
|
||
unsigned int len16=0;
|
||
unsigned int len8=str.length();
|
||
const char* p8=str.data();
|
||
|
||
unsigned int i=0;
|
||
while(i<len8) //Подсчитываем сколько символов в строке
|
||
{
|
||
if((p8[i] & 0x80)==0) i++; else //0 в начале знач 1 символ
|
||
if((p8[i] & 0xF0)==0xF0) i+=4; else //11110xxx
|
||
if((p8[i] & 0xE0)==0xE0) i+=3; else //1110xxxx
|
||
if((p8[i] & 0xC0)==0xC0) i+=2; //110xxxxx
|
||
len16++;
|
||
}
|
||
wchar_t* p16=new wchar_t[len16];
|
||
unsigned int pos=0;
|
||
i=0;
|
||
while(i<len8)
|
||
{
|
||
if((p8[i] & 0x80)==0) //0xxxxxxx (0 в начале знач 1 символ)
|
||
{
|
||
p16[pos]=p8[i];
|
||
pos++; i++;
|
||
}else
|
||
if((p8[i] & 0xF0)==0xF0) //11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
|
||
{
|
||
p16[pos]=((p8[i] & 0x7) << 18) | ((p8[i+1] & 0x3F) << 12) | ((p8[i+2] & 0x3F) << 6) | (p8[i+3] & 0x3F);
|
||
pos++; i+=4;
|
||
}else
|
||
if((p8[i] & 0xE0)==0xE0) //1110xxxx 10xxxxxx 10xxxxxx
|
||
{
|
||
p16[pos]=((p8[i] & 0xf) << 12) | ((p8[i+1] & 0x3F) << 6) | (p8[i+2] & 0x3F);
|
||
pos++; i+=3;
|
||
} else
|
||
if((p8[i] & 0xC0)==0xC0) //110xxxxx 10xxxxxx
|
||
{
|
||
p16[pos]=((p8[i] & 0x1F) << 6) | (p8[i+1] & 0x3F);
|
||
pos++; i+=2;
|
||
}else i++; //если дошло до сюда то ошибка
|
||
}
|
||
|
||
std::wstring wstr;
|
||
wstr.append(p16,len16);
|
||
delete[] p16;
|
||
return wstr;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Убрать начальные и конечные пробелы \t\r
|
||
void Trim(std::string& s)
|
||
{
|
||
TrimLeft(s);
|
||
TrimRight(s);
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
std::string trim(const std::string & s)
|
||
{
|
||
size_t startPos = s.find_first_not_of(" \t\r");
|
||
if (startPos == std::string::npos)
|
||
return "";
|
||
size_t endPos = s.find_last_not_of(" \t\r");
|
||
return s.substr(startPos, endPos - startPos + 1);
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
void TrimW(std::wstring& s)
|
||
{
|
||
TrimWLeft(s);
|
||
TrimWRight(s);
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
void TrimWLeft(std::wstring& str)
|
||
{
|
||
size_t startpos = str.find_first_not_of(L" \t\f\n\r");
|
||
if (startpos != std::string::npos)
|
||
{
|
||
str = str.substr(startpos);
|
||
}
|
||
else
|
||
{
|
||
str.clear(); //Вся строка из спец символов
|
||
}
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
void TrimWRight(std::wstring& str)
|
||
{
|
||
std::wstring::size_type endpos = str.find_last_not_of(L" \t\f\n\r");
|
||
if (endpos != std::string::npos)
|
||
{
|
||
str = str.substr(0, endpos + 1);
|
||
}
|
||
else
|
||
{
|
||
str.clear(); //Вся строка из спец символов
|
||
}
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
void TrimLeft(std::string& str)
|
||
{
|
||
size_t startpos = str.find_first_not_of(" \t\f\n\r");
|
||
if(startpos != std::string::npos)
|
||
{
|
||
str = str.substr( startpos );
|
||
}else
|
||
{
|
||
str.clear(); //Вся строка из спец символов
|
||
}
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
void TrimRight(std::string& str)
|
||
{
|
||
std::string::size_type endpos = str.find_last_not_of(" \t\f\n\r");
|
||
if( endpos != std::string::npos )
|
||
{
|
||
str = str.substr( 0, endpos+1 );
|
||
}else
|
||
{
|
||
str.clear(); //Вся строка из спец символов
|
||
}
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Заменить текст str на тот что из txt
|
||
std::string printToPos(std::string str, int pos, std::string txt)
|
||
{
|
||
//Дополняю длину строки
|
||
if (str.length() < pos + txt.length()) {
|
||
str.append(std::string(pos + txt.length() - str.length(), ' '));
|
||
}
|
||
//Переписываю строку
|
||
for(long unsigned int i = 0; i < txt.length();i++) {
|
||
str[pos + i] = txt[i];
|
||
}
|
||
return str;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Разделить текст по разделителю на слова
|
||
std::vector<std::wstring> split(const std::wstring& str, wchar_t delimiter)
|
||
{
|
||
std::wstring temp;
|
||
std::vector<std::wstring> parts;
|
||
std::wstringstream wss(str);
|
||
while(std::getline(wss, temp, delimiter))
|
||
parts.push_back(temp);
|
||
return parts;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
void killProcessByName(const wchar_t *filename)
|
||
{
|
||
#if defined(_WIN32) || defined(_WINDOWS) || defined(_BORLAND)
|
||
/* HANDLE hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPALL, NULL);
|
||
PROCESSENTRY32 pEntry;
|
||
pEntry.dwSize = sizeof(pEntry);
|
||
BOOL hRes = Process32First(hSnapShot, &pEntry);
|
||
while (hRes)
|
||
{
|
||
if (wcscmp(pEntry.szExeFile, filename) == 0)
|
||
{
|
||
HANDLE hProcess = OpenProcess(PROCESS_TERMINATE, 0,
|
||
(DWORD)pEntry.th32ProcessID);
|
||
if (hProcess != NULL)
|
||
{
|
||
TerminateProcess(hProcess, 9);
|
||
CloseHandle(hProcess);
|
||
}
|
||
}
|
||
hRes = Process32Next(hSnapShot, &pEntry);
|
||
}
|
||
CloseHandle(hSnapShot);*/
|
||
#else
|
||
|
||
#endif
|
||
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
bool dirExists(std::string path)
|
||
{
|
||
struct stat info;
|
||
if(stat( path.c_str(), &info ) != 0)
|
||
return 0;
|
||
else if(info.st_mode & S_IFDIR)
|
||
return 1;
|
||
else
|
||
return 0;
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
//Создать папку
|
||
bool createFolder(std::string directory,int mode)
|
||
{
|
||
#if defined(_WIN32) || defined(_WINDOWS) || defined(_BORLAND)
|
||
CreateDirectoryA(directory.c_str(), NULL);
|
||
return true;
|
||
#else
|
||
mode_t tmp = mode; //На винде тен типа mode_t
|
||
int rez=0;
|
||
if(!dirExists(directory)){
|
||
rez=mkdir(directory.c_str(), mode); //Если папки нет то создать её
|
||
}
|
||
if(rez==0){
|
||
chmod(directory.c_str(), mode); //Бывало что при создании права не назначались
|
||
}
|
||
return rez==0;
|
||
#endif
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
std::string intToString(int val)
|
||
{
|
||
std::stringstream ss;
|
||
ss << val;
|
||
return ss.str();
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
std::string uintToString(unsigned int val)
|
||
{
|
||
std::stringstream ss;
|
||
ss << val;
|
||
return ss.str();
|
||
}
|
||
//---------------------------------------------------------------------------
|
||
std::string ullintToString(unsigned long long int val)
|
||
{
|
||
std::stringstream ss;
|
||
ss << val;
|
||
return ss.str();
|
||
}
|
||
|
||
}
|