421 lines
9.5 KiB
C++
Executable File
421 lines
9.5 KiB
C++
Executable File
/*
|
|
* This file is a part of Winix
|
|
* and is not publicly distributed
|
|
*
|
|
* Copyright (c) 2008-2010, Tomasz Sowa
|
|
* All rights reserved.
|
|
*
|
|
*/
|
|
|
|
#ifndef headerfilecmslucoremisc
|
|
#define headerfilecmslucoremisc
|
|
|
|
|
|
#include <string>
|
|
#include <sstream>
|
|
#include <ctime>
|
|
#include <cstdio>
|
|
#include "item.h"
|
|
|
|
|
|
|
|
/*
|
|
conversions between text and numbers
|
|
*/
|
|
|
|
int Toi(const std::string & str, int base = 10);
|
|
int Toi(const std::wstring & str, int base = 10);
|
|
int Toi(const char * str, int base = 10);
|
|
int Toi(const wchar_t * str, int base = 10);
|
|
|
|
long Tol(const std::string & str, int base = 10);
|
|
long Tol(const std::wstring & str, int base = 10);
|
|
long Tol(const char * str, int base = 10);
|
|
long Tol(const wchar_t * str, int base = 10);
|
|
|
|
|
|
// if the buffer is too small it will be terminated at the beginning (empty string)
|
|
// and the function returns false
|
|
template<class CharType>
|
|
bool Toa(unsigned long value, CharType * buffer, size_t buf_len, int base = 10)
|
|
{
|
|
size_t i1, i2;
|
|
long rest;
|
|
|
|
if( buf_len == 0 )
|
|
return false;
|
|
|
|
i1 = i2 = 0;
|
|
|
|
if( base < 2 ) base = 2;
|
|
if( base > 16 ) base = 16;
|
|
|
|
do
|
|
{
|
|
rest = value % base;
|
|
value = value / base;
|
|
buffer[i2++] = (rest < 10) ? char(rest) + '0' : char(rest) - 10 + 'A';
|
|
}
|
|
while(value != 0 && i2 < buf_len);
|
|
|
|
if( i2 >= buf_len )
|
|
{
|
|
buffer[0] = 0; // ops, the buffer was too small
|
|
return false;
|
|
}
|
|
|
|
buffer[i2--] = 0;
|
|
|
|
for( ; i1 < i2 ; ++i1, --i2)
|
|
{
|
|
CharType temp = buffer[i1];
|
|
buffer[i1] = buffer[i2];
|
|
buffer[i2] = temp;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// if the buffer is too small it will be terminated at the beginning (empty string)
|
|
// and the function returns false
|
|
template<class CharType>
|
|
bool Toa(long value, CharType * buffer, size_t buf_len, int base = 10)
|
|
{
|
|
if( buf_len == 0 )
|
|
return false;
|
|
|
|
CharType * buf = buffer;
|
|
|
|
if( value < 0 )
|
|
{
|
|
buffer[0] = '-';
|
|
buf += 1;
|
|
buf_len -= 1;
|
|
value = -value;
|
|
}
|
|
|
|
bool res = Toa(static_cast<unsigned long>(value), buf, buf_len, base);
|
|
|
|
if( !res )
|
|
buffer[0] = 0;
|
|
|
|
return res;
|
|
}
|
|
|
|
|
|
template<class CharType>
|
|
bool Toa(unsigned int value, CharType * buffer, size_t buf_len, int base = 10)
|
|
{
|
|
return Toa(static_cast<unsigned long>(value), buffer, buf_len, base);
|
|
}
|
|
|
|
|
|
template<class CharType>
|
|
bool Toa(int value, CharType * buffer, size_t buf_len, int base = 10)
|
|
{
|
|
return Toa(static_cast<long>(value), buffer, buf_len, base);
|
|
}
|
|
|
|
|
|
// warning: it uses its own static buffer
|
|
// one buffer for both these functions
|
|
const wchar_t * Toa(unsigned int value, int base = 10);
|
|
const wchar_t * Toa(unsigned long value, int base = 10);
|
|
const wchar_t * Toa(int value, int base = 10);
|
|
const wchar_t * Toa(long value, int base = 10);
|
|
|
|
|
|
void Toa(int value, std::string & res, int base = 10, bool clear = true);
|
|
void Toa(long value, std::string & res, int base = 10, bool clear = true);
|
|
void Toa(int value, std::wstring & res, int base = 10, bool clear = true);
|
|
void Toa(long value, std::wstring & res, int base = 10, bool clear = true);
|
|
|
|
|
|
|
|
|
|
/*
|
|
conversions between ascii text and wide characters
|
|
(destination is always std::string or std::wstring)
|
|
|
|
characters are copied as they are without any locales checking
|
|
*/
|
|
|
|
void AssignString(const char * src, size_t len, std::wstring & dst, bool clear = true);
|
|
void AssignString(const char * src, std::wstring & dst, bool clear = true);
|
|
void AssignString(const std::string & src, std::wstring & dst, bool clear = true);
|
|
|
|
void AssignString(const wchar_t * src, size_t len, std::string & dst, bool clear = true);
|
|
void AssignString(const wchar_t * src, std::string & dst, bool clear = true);
|
|
void AssignString(const std::wstring & src, std::string & dst, bool clear = true);
|
|
|
|
void AssignString(const char * src, size_t len, std::string & dst, bool clear = true);
|
|
void AssignString(const char * src, std::string & dst, bool clear = true);
|
|
void AssignString(const std::string & src, std::string & dst, bool clear = true);
|
|
|
|
void AssignString(const wchar_t * src, size_t len, std::wstring & dst, bool clear = true);
|
|
void AssignString(const wchar_t * src, std::wstring & dst, bool clear = true);
|
|
void AssignString(const std::wstring & src, std::wstring & dst, bool clear = true);
|
|
|
|
|
|
|
|
|
|
|
|
bool CorrectUrlChar(wchar_t c);
|
|
void CorrectUrlDots(std::wstring & url);
|
|
void CorrectUrlChars(std::wstring & url);
|
|
void CorrectUrlOnlyAllowedChar(std::wstring & url);
|
|
|
|
|
|
const wchar_t * DateToStr(int year, int month, int day);
|
|
const wchar_t * DateToStr(int year, int month, int day, int hour, int min, int sec);
|
|
const wchar_t * DateToStr(const tm * ptm);
|
|
const wchar_t * DateToStr(const tm & rtm);
|
|
const wchar_t * DateToStr(time_t t);
|
|
const wchar_t * DateToStrWithoutHours(const tm * ptm);
|
|
const wchar_t * DateToStrWithoutHours(const tm & rtm);
|
|
const wchar_t * DateToStrWithoutHours(time_t t);
|
|
|
|
const char * DateToStrCookie(int year, int month, int day, int hour, int min, int sec);
|
|
const char * DateToStrCookie(const tm * ptm);
|
|
const char * DateToStrCookie(const tm & rtm);
|
|
const char * DateToStrCookie(time_t t);
|
|
|
|
const wchar_t * IpToStr(unsigned int ip_);
|
|
|
|
bool IsWhite(wchar_t s);
|
|
|
|
template<class StringType>
|
|
void TrimWhite(StringType & s)
|
|
{
|
|
typename StringType::size_type i;
|
|
|
|
if( s.empty() )
|
|
return;
|
|
|
|
// looking for white characters at the end
|
|
for(i=s.size()-1 ; i>0 && IsWhite(s[i]) ; --i);
|
|
|
|
if( i==0 && IsWhite(s[i]) )
|
|
{
|
|
// the whole string has white characters
|
|
s.clear();
|
|
return;
|
|
}
|
|
|
|
// deleting white characters at the end
|
|
if( i != s.size() - 1 )
|
|
s.erase(i+1, StringType::npos);
|
|
|
|
// looking for white characters at the beginning
|
|
for(i=0 ; i<s.size() && IsWhite(s[i]) ; ++i);
|
|
|
|
// deleting white characters at the beginning
|
|
if( i != 0 )
|
|
s.erase(0, i);
|
|
}
|
|
|
|
|
|
template<class StringType>
|
|
void Trim(StringType & s, wchar_t c)
|
|
{
|
|
typename StringType::size_type i;
|
|
|
|
if( s.empty() )
|
|
return;
|
|
|
|
// looking for the 'c' characters at the end
|
|
for(i=s.size()-1 ; i>0 && s[i]==c ; --i);
|
|
|
|
if( i==0 && s[i]==c )
|
|
{
|
|
// the whole string has the 'c' characters
|
|
s.clear();
|
|
return;
|
|
}
|
|
|
|
// deleting 'c' characters at the end
|
|
if( i != s.size() - 1 )
|
|
s.erase(i+1, StringType::npos);
|
|
|
|
// looking for the 'c' characters at the beginning
|
|
for(i=0 ; i<s.size() && s[i]==c ; ++i);
|
|
|
|
// deleting the 'c' characters at the beginning
|
|
if( i != 0 )
|
|
s.erase(0, i);
|
|
}
|
|
|
|
|
|
wchar_t ToSmall(wchar_t c);
|
|
void ToSmall(std::wstring & s);
|
|
|
|
const char * SkipWhite(const char * s);
|
|
const wchar_t * SkipWhite(const wchar_t * s);
|
|
|
|
|
|
|
|
template<class StringType1, class StringType2>
|
|
bool IsSubString(const StringType1 * short_str, const StringType2 * long_str)
|
|
{
|
|
while( *short_str && *long_str && wchar_t(*short_str) == wchar_t(*long_str) )
|
|
{
|
|
++short_str;
|
|
++long_str;
|
|
}
|
|
|
|
if( *short_str == 0 )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
template<class StringType1, class StringType2>
|
|
bool IsSubString(const StringType1 & short_str, const StringType2 & long_str)
|
|
{
|
|
return IsSubString(short_str.c_str(), long_str.c_str());
|
|
}
|
|
|
|
|
|
|
|
template<class StringType1, class StringType2>
|
|
bool IsSubStringNoCase(const StringType1 * short_str, const StringType2 * long_str)
|
|
{
|
|
while( *short_str && *long_str && ToSmall(*short_str) == ToSmall(*long_str) )
|
|
{
|
|
++short_str;
|
|
++long_str;
|
|
}
|
|
|
|
if( *short_str == 0 )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
template<class StringType1, class StringType2>
|
|
bool IsSubStringNoCase(const StringType1 & short_str, const StringType2 & long_str)
|
|
{
|
|
return IsSubStringNoCase(short_str.c_str(), long_str.c_str());
|
|
}
|
|
|
|
|
|
|
|
template<class StringType1, class StringType2>
|
|
bool Equal(const StringType1 * str1, const StringType2 * str2)
|
|
{
|
|
while( *str1 && *str2 && wchar_t(*str1) == wchar_t(*str2) )
|
|
{
|
|
++str1;
|
|
++str2;
|
|
}
|
|
|
|
if( *str1 == 0 && *str2 == 0 )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
template<class StringType1, class StringType2>
|
|
bool Equal(const StringType1 & str1, const StringType2 & str2)
|
|
{
|
|
return Equal(str1.c_str(), str2.c_str());
|
|
}
|
|
|
|
|
|
|
|
template<class StringType1, class StringType2>
|
|
bool EqualNoCase(const StringType1 * str1, const StringType2 * str2)
|
|
{
|
|
while( *str1 && *str2 && ToSmall(*str1) == ToSmall(*str2) )
|
|
{
|
|
++str1;
|
|
++str2;
|
|
}
|
|
|
|
if( *str1 == 0 && *str2 == 0 )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
template<class StringType1, class StringType2>
|
|
bool EqualNoCase(const StringType1 & str1, const StringType2 & str2)
|
|
{
|
|
return EqualNoCase(str1.c_str(), str2.c_str());
|
|
}
|
|
|
|
|
|
|
|
template<class StringType>
|
|
void NoLastSlash(StringType & s)
|
|
{
|
|
if( s.empty() )
|
|
return;
|
|
|
|
size_t i = s.size();
|
|
|
|
for( ; i>0 && s[i-1]=='/' ; --i);
|
|
|
|
if( i < s.size() )
|
|
s.erase(i);
|
|
}
|
|
|
|
|
|
|
|
template<class StringType>
|
|
void NoFirstHttp(StringType & s)
|
|
{
|
|
if( s.empty() )
|
|
return;
|
|
|
|
const char http[] = "http://";
|
|
const char https[] = "https://";
|
|
|
|
if( IsSubStringNoCase(http, s.c_str()) )
|
|
{
|
|
s.erase(0, sizeof(http)/sizeof(char));
|
|
}
|
|
else
|
|
if( IsSubStringNoCase(https, s.c_str()) )
|
|
{
|
|
s.erase(0, sizeof(https)/sizeof(char));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool ValidateEmail(const std::wstring & email);
|
|
|
|
bool IsFile(const wchar_t * file);
|
|
bool IsFile(const std::wstring & file);
|
|
bool CreateDir(const wchar_t * dir, int priv);
|
|
bool CreateDir(const std::wstring & dir, int priv);
|
|
bool CreateDirs(const wchar_t * base_dir, const wchar_t * dirs, int priv);
|
|
bool CreateDirs(const std::wstring & base_dir, const std::wstring & dirs, int priv);
|
|
|
|
bool CopyFile(FILE * in, FILE * out);
|
|
bool CopyFile(const wchar_t * src, const wchar_t * dst);
|
|
bool CopyFile(const std::wstring & src, const std::wstring & dst);
|
|
|
|
bool RemoveFile(const wchar_t * file);
|
|
bool RemoveFile(const std::wstring & file);
|
|
|
|
bool RenameFile(const wchar_t * from, const wchar_t * to);
|
|
bool RenameFile(const std::wstring & from, const std::wstring & to);
|
|
|
|
const wchar_t * GetFileExt(const wchar_t * name);
|
|
Item::Auth SelectFileType(const wchar_t * file_name);
|
|
|
|
time_t Time(const tm & par);
|
|
time_t Time(const tm * par);
|
|
tm Time(time_t par);
|
|
|
|
#endif
|