366 lines
12 KiB
C++
366 lines
12 KiB
C++
/*
|
||
* utility.h
|
||
*
|
||
* Created on: 10 дек. 2014 г.
|
||
* Author: ivanov.i
|
||
*/
|
||
|
||
#ifndef UTILITY_H_
|
||
#define UTILITY_H_
|
||
|
||
#include <string>
|
||
#include <vector>
|
||
#include <list>
|
||
#ifdef __linux__
|
||
#include <inttypes.h>
|
||
#elif _WIN32
|
||
#include <windows.h>
|
||
#include <stdint.h> //C++Builder
|
||
#else
|
||
|
||
#endif
|
||
|
||
|
||
namespace UtilityW
|
||
{
|
||
#ifdef _WIN32
|
||
void UnixTimeToFileTime(time_t t, LPFILETIME pft);
|
||
void UnixTimeToSystemTime(time_t t, LPSYSTEMTIME pst);
|
||
#endif
|
||
|
||
//time_t g_file_name_cnt_time;
|
||
//int g_file_name_cnt;
|
||
std::string getNextFileName(); //Генерировать уникальное имя файла на основе времени и порядкового номера из глобавльной переменной
|
||
|
||
char separator();
|
||
bool checkPort(const char *hostname,int portno,int timeout); //Проверяем открыт ли сокет
|
||
uint8_t CRC8(const signed char *pcBlock, unsigned char len, unsigned char crc);
|
||
|
||
bool DeCrypt(std::string strKey, std::string fNameIn, std::string fNameOut);
|
||
unsigned char setBitVal(unsigned char bit,unsigned char pos,bool val); //Установит знначение бита в заданную позицию pos - Позиция 7..0
|
||
bool getBitVal(unsigned char bit,unsigned char pos); //Вернёт значение бита на заданной позиции, pos - Позиция 7..0
|
||
|
||
unsigned int getMSecTime();
|
||
|
||
std::string urlEncode(const std::string &url);
|
||
std::string urlDecode(const std::string &encoded);
|
||
|
||
std::string charToHex(unsigned char c);
|
||
std::string shortToHex(unsigned short c);
|
||
std::string uintToHex(unsigned int val,char size);
|
||
|
||
unsigned char hexToChar(const std::string &str);
|
||
unsigned char bitStrToChar(std::string str);
|
||
unsigned int HexStdStrToUInt(std::string& str);
|
||
bool hexStrToArray(const std::string &str,char* arr);
|
||
bool arrayToHexStr(char* arr,unsigned int len,std::string &str);
|
||
bool vectorToHexStr(std::vector < unsigned char >& arr,std::string &str);
|
||
|
||
bool initPin(std::string pinnum); //Инициализируем ножку чтоб в неё можно записывать 0 или 1 как в файл (Документация GPIO: http://www.avrfreaks.net/wiki/index.php/Documentation:Linux/GPIO)
|
||
bool setPinDir(std::string pinnum, bool dir); //Задать направление чтения или записи (сейчас вывод) dit=true на вывод, dit=false на ввод, pull - подтяжка к 0 или к 1 питания.
|
||
bool setPinVal(std::string pinnum, bool val); //Задаём напряжение для ножки
|
||
char getPinVal(std::string pinnum); //Получить значение ножки
|
||
|
||
std::string doubleToString(double val);
|
||
std::string intToString(signed int val);
|
||
std::string ullintToString(unsigned long long int val);
|
||
std::string uintToString(unsigned int val);
|
||
std::string AfterFirst(std::string str,const char ch);
|
||
std::string DecToBinStr(int N,int cnt=0);
|
||
std::string DecToBinStr(unsigned int N,int cnt=0);
|
||
std::string addZero(std::string str,int count,char ch='0');
|
||
std::string addZero(int val,int count,char ch='0');
|
||
std::string escape_json(const std::string& input);
|
||
|
||
|
||
std::string AfterLast(std::string str,const unsigned char ch);
|
||
std::string BeforeFirst(std::string str,const unsigned char ch);
|
||
std::string BeforeLast(std::string str,char ch);
|
||
std::string CutBeforeFirst(std::string& str,const unsigned char ch);
|
||
std::string CutBeforeFirst(std::string& str,std::string br);
|
||
std::string CutAfterLast(std::string& str,const unsigned char ch);
|
||
std::string CutAfterFirst(std::string& str,std::string br);
|
||
|
||
void Trim(std::string& s);
|
||
void TrimLeft(std::string& s);
|
||
void TrimRight(std::string& s);
|
||
|
||
double StdStrToDouble(std::string& str);
|
||
float StdStrToFloat(std::string& str);
|
||
bool StdStrToFloat(std::string& str,float& val);
|
||
|
||
int StdStrToInt(std::string& str);
|
||
unsigned int StdStrToUInt(std::string& str);
|
||
unsigned long long StdStrToULLInt(std::string& str);
|
||
|
||
|
||
long getMaxFileSize(std::string path); //Получить размер самого большого файла в каталоге
|
||
long getAllFSSize(std::string anyfile);
|
||
long getFreeFSSize(std::string anyfile);
|
||
long getFileSize(std::string file);
|
||
long getFileDateModiff(std::string file);
|
||
int readFile(std::string file, char* data, int size);
|
||
bool dirExists(std::string path);
|
||
bool fileExists(std::string name);
|
||
void GetFiles(std::list<std::string>& fileList, std::string directory); //Получить список файлов в директории (в том числе и в подпапках)
|
||
void GetFolders(std::list<std::string>& folderList, std::string directory); //Получить список папок в директории (без подпапок)
|
||
bool createFolder(std::string directory,int mode); //Создать папку
|
||
|
||
void delString(std::vector<std::string> *mas, int pos);
|
||
std::string unixTimeToDate(double time);
|
||
|
||
//bool logrotate(int cnt,int size, std::string name, std::string data); //Сохранение лог файла в 2 версии по 10 мегабайт
|
||
bool logrotate(std::string fileName,std::string name,std::string level, std::string data,bool cout=false,int size=10); //Сохранение лог файла в 2 версии по 10 мегабайт
|
||
|
||
void Distance(float r, float cx, float cy, float lx1, float ly1, float lx2, float ly2, bool& Coincides, float& x, float& y);
|
||
|
||
bool parseGPRMC(std::string ans,time_t& utime,double& lon,double& lat,float& speed,float& angle); //На вход строка вида: $GPRMC,074353.0,A,4315.286297,N,07651.391112,E,0.0,255.3,191214,,,A*68
|
||
void sleep2(int sec); //В секундах
|
||
|
||
bool deleteFile(std::string fileName); //Удалить файл
|
||
bool deleteOldFiles(std::string path,int days); //Удалить файлы старше заданного количества дней
|
||
bool deleteOldFile(std::string path); //Удалить 1 последний файл
|
||
}
|
||
//------------------------------------------------------------------------------
|
||
//Расширяемый массив элементов, может выступать в качестве родителя те. удалять элементы при уничтожении списка или при удалении элемента из списка
|
||
template <class T> class TSimpleList
|
||
{
|
||
private:
|
||
T* f_NULL; //При выходе за пределы массива выдаётся этот элемент
|
||
T* List; //массив элементов
|
||
unsigned int f_size; //размер массива (без учёта занятых позиций)
|
||
unsigned int f_count; //количество элементов
|
||
unsigned int f_step; //шаг увеличения массива
|
||
public:
|
||
bool f_owner; //являеться ли владельцем элементов данный списк (нужно ли удалять элементы списка)
|
||
|
||
explicit TSimpleList(unsigned int step=10,bool owner=false)
|
||
{
|
||
if(step==0)step=1;
|
||
f_step=step;
|
||
List=new T[f_step];
|
||
f_size=f_step;
|
||
f_count=0;
|
||
f_owner=owner;
|
||
f_NULL=NULL;
|
||
};
|
||
~TSimpleList()
|
||
{
|
||
if(f_owner)
|
||
for(unsigned int i=0;i<f_count;i++)
|
||
delete List[i];
|
||
delete[] List;
|
||
};
|
||
unsigned int count()
|
||
{
|
||
return f_count;
|
||
};
|
||
unsigned int size() //количество элементов
|
||
{
|
||
return f_count;
|
||
};
|
||
//Добавить элемент в конец массива
|
||
T add(T item)
|
||
{
|
||
if(f_count<f_size)
|
||
{
|
||
List[f_count]=item;
|
||
f_count++;
|
||
}else
|
||
{
|
||
T* buf=new T[f_size+=f_step];
|
||
for(unsigned int i=0;i<=f_count;i++) buf[i]=List[i];
|
||
T* buf0=List;
|
||
List=buf;
|
||
delete[] buf0;
|
||
List[f_count++]=item;
|
||
}
|
||
return item;
|
||
};
|
||
void push_back(T item) {add(item);};
|
||
|
||
void insert(T item, unsigned int pos) //pos - 0..N
|
||
{
|
||
if(pos>=f_count)
|
||
{
|
||
if(pos<f_size){List[pos]=item; f_count=pos+1;} //в пустую область
|
||
else //в не выделенную область
|
||
{
|
||
T* buf=new T[pos+1];
|
||
for(unsigned int i=0;i<=f_count;i++) buf[i]=List[i];
|
||
T* buf0=List;
|
||
List=buf;
|
||
delete[] buf0;
|
||
List[pos]=item;
|
||
f_count=pos+1;
|
||
}
|
||
}else//сдвинуть имеющиеся
|
||
{
|
||
add(List[f_count-1]);
|
||
for(unsigned int i=f_count-2;i>pos;i--)
|
||
List[i]=List[i-1];
|
||
List[pos]=item;
|
||
}
|
||
};
|
||
void del(T item) //удаляем элемент и сдвигаем все элементы на 1 в лево
|
||
{
|
||
unsigned int cnt=0;
|
||
bool b=false;
|
||
for(unsigned int i=0;i<f_count;i++)
|
||
{
|
||
//if(List[i]==item){cnt--; b=true;}
|
||
if(List[i]==item){b=true; continue;}
|
||
List[cnt]=List[i];
|
||
cnt++;
|
||
}
|
||
if(b)
|
||
{
|
||
f_count--;
|
||
if(f_owner)delete item;
|
||
}
|
||
};
|
||
bool del(unsigned int pos) //удаляем элемент и сдвигаем все элементы на 1 в лево
|
||
{
|
||
if(pos>=f_count)return false;
|
||
f_count--;
|
||
if(f_owner) delete List[pos];
|
||
for(unsigned int i=pos;i<f_count;i++) List[i]=List[i+1];
|
||
return true;
|
||
};
|
||
T& get(unsigned int i)
|
||
{ if(i>=f_count) {return (T&)f_NULL;}
|
||
return List[i];
|
||
};
|
||
T& operator[](unsigned int i)
|
||
{ if(i>=f_count) {return (T&)f_NULL;}
|
||
return List[i];
|
||
};
|
||
bool Pos(T item,unsigned int &pos) //Узнать позицию элемента в массиве
|
||
{
|
||
for(unsigned int i=0;i<f_count;i++)
|
||
if(List[i]==item) { pos=i; return true; }
|
||
return false;
|
||
};
|
||
//Очистить массив с уменьшением размерности до одного шага увеличения массива
|
||
void clear()
|
||
{
|
||
unsigned int cnt=f_count;
|
||
f_count=0;
|
||
if(f_owner) for(unsigned int i=0;i<cnt;i++) delete List[i];
|
||
T* tmp=List;
|
||
f_size=f_step;
|
||
List=new T[f_step];
|
||
delete[] tmp;
|
||
};
|
||
};
|
||
//------------------------------------------------------------------------------
|
||
//простой список не являющийся владельцем своих элементов (можно задавать реальные обьекты а не ссылки)
|
||
template <class T> class TSimpleList2
|
||
{
|
||
private:
|
||
T* List; //массив элементов
|
||
unsigned int f_size;//размер массива
|
||
unsigned int f_count;//количество элементов
|
||
unsigned int f_step;//шаг увеличения массива
|
||
public:
|
||
explicit TSimpleList2() //Для использования конструктора по умолчанию
|
||
{
|
||
f_step=10;
|
||
List=new T[f_step];
|
||
f_size=f_step;
|
||
f_count=0;
|
||
};
|
||
|
||
TSimpleList2(unsigned int step)
|
||
{
|
||
if(step==0)step=1;
|
||
f_step=step;
|
||
List=new T[f_step];
|
||
f_size=f_step;
|
||
f_count=0;
|
||
};
|
||
|
||
~TSimpleList2()
|
||
{
|
||
delete[] List;
|
||
};
|
||
unsigned int count() //количество элементов
|
||
{
|
||
return f_count;
|
||
};
|
||
unsigned int size() //количество элементов
|
||
{
|
||
return f_count;
|
||
};
|
||
|
||
//Добавить элемент в конец массива
|
||
void add(T item)
|
||
{
|
||
if(f_count<f_size)
|
||
{
|
||
List[f_count]=item;
|
||
f_count++;
|
||
}
|
||
else
|
||
{
|
||
T* buf=new T[f_size+=f_step];
|
||
for(unsigned int i=0;i<=f_count;i++) buf[i]=List[i];
|
||
T* buf0=List;
|
||
List=buf;
|
||
delete[] buf0;
|
||
List[f_count]=item;
|
||
f_count++;
|
||
}
|
||
};
|
||
|
||
void push_back(T item){add(item);};
|
||
|
||
void del(T item) //удаляем элемент и сдвигаем все элементы на 1 в лево
|
||
{
|
||
unsigned int cnt=0;
|
||
bool b=false;
|
||
for(unsigned int i=0;i<f_count;i++)
|
||
{
|
||
//if(List[i]==item){cnt--; b=true;}
|
||
if(List[i]==item){b=true; continue;}
|
||
List[cnt]=List[i];
|
||
cnt++;
|
||
}
|
||
if(b)
|
||
{
|
||
f_count--;
|
||
}
|
||
};
|
||
bool del(unsigned int pos) //удаляем элемент и сдвигаем все элементы на 1 в лево
|
||
{
|
||
if(pos>=f_count)return false;
|
||
f_count--;
|
||
for(unsigned int i=pos;i<f_count;i++) List[i]=List[i+1];
|
||
return true;
|
||
};
|
||
bool pop_front(){ return del(0); };
|
||
|
||
T& front(){return List[0];};
|
||
T& get(unsigned int i){return List[i];};
|
||
T& operator[](unsigned int i){return List[i];};
|
||
bool Position(T item, unsigned int &pos) //Найти позицию элемента в списке перебором
|
||
{
|
||
for(unsigned int i=0;i<f_count;i++)
|
||
if(List[i]==item) { pos=i; return true; }
|
||
return false;
|
||
};
|
||
|
||
void clear()
|
||
{
|
||
unsigned int cnt=f_count;
|
||
f_count=0;
|
||
T* tmp=List;
|
||
f_size=f_step;
|
||
List=new T[f_step];
|
||
delete[] tmp;
|
||
};
|
||
};
|
||
//------------------------------------------------------------------------------
|
||
|
||
#endif /* UTILITY_H_ */
|