tomasz.sowa/winix
1
0
Fork 0
Code Issues 5 Pull Requests Releases Activity

added: uptime winix function prints how many sessions there are

Browse Source 
changed: functions for text/numbers conversions
         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);

         template<class CharType>
         bool Toa(unsigned long value, CharType * buffer, size_t buf_len, int base = 10);

         template<class CharType>
         bool Toa(long value, CharType * buffer, size_t buf_len, int base = 10);

         template<class CharType>
         bool Toa(unsigned int value, CharType * buffer, size_t buf_len, int base = 10);

         template<class CharType>
         bool Toa(int value, CharType * buffer, size_t buf_len, int base = 10);

         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);

added:   HtmlTextStream class (files htmltextstream.cpp htmltextstream.h in templates)
         this is a special stream for automatically escaping html tags
	     



git-svn-id: svn://ttmath.org/publicrep/winix/trunk@682 e52654a7-88a9-db11-a3e9-0013d4bc506e
This commit is contained in:
Tomasz Sowa
2010-11-25 01:34:46 +00:00
parent 518281e101
commit 933c8841ff
53 changed files with 1925 additions and 1098 deletions
Download Patch File Download Diff File Expand all files Collapse all files

321
core/misc.cpp
View File

@@ -14,96 +14,155 @@
#include "templates/templates.h"
int Atoi(const std::string & str, int base)
int Toi(const std::string & str, int base)
{
return Atoi(str.c_str(), base);
return Toi(str.c_str(), base);
}
int Atoi(const std::wstring & str, int base)
int Toi(const std::wstring & str, int base)
{
return Atoi(str.c_str(), base);
return Toi(str.c_str(), base);
}
int Atoi(const char * str, int base)
int Toi(const char * str, int base)
{
return static_cast<int>(strtol(str, 0, base));
}
int Atoi(const wchar_t * str, int base)
int Toi(const wchar_t * str, int base)
{
return static_cast<int>(wcstol(str, 0, base));
}
long Atol(const std::string & str, int base)
long Tol(const std::string & str, int base)
{
return Atol(str.c_str(), base);
return Tol(str.c_str(), base);
}
long Atol(const std::wstring & str, int base)
long Tol(const std::wstring & str, int base)
{
return Atol(str.c_str(), base);
return Tol(str.c_str(), base);
}
long Atol(const char * str, int base)
long Tol(const char * str, int base)
{
return strtol(str, 0, base);
}
long Atol(const wchar_t * str, int base)
long Tol(const wchar_t * str, int base)
{
return wcstol(str, 0, base);
}
const wchar_t * Itoa(int value, int base)
const wchar_t * Toa(unsigned int value, int base)
{
return Ltoa(value, base);
return Toa(static_cast<unsigned long>(value), base);
}
const wchar_t * Ltoa(long value, int base)
const wchar_t * Toa(unsigned long value, int base)
{
static wchar_t digits[] = L"0123456789ABCDEF";
static wchar_t buffer_[50];
wchar_t * buffer = buffer_;
size_t i1, i2;
long rest;
static wchar_t buffer[50];
size_t len = sizeof(buffer) / sizeof(wchar_t);
i1 = i2 = 0;
Toa(value, buffer, len, base);
if( base < 2 )
base = 2;
return buffer;
}
if( base > 16 )
base = 16;
if( value < 0 )
{
buffer[0] = '-';
buffer += 1;
value = -value;
}
do
{
rest = value % base;
value = value / base;
buffer[i2++] = digits[rest];
}
while(value != 0);
buffer[i2--] = 0;
const wchar_t * Toa(int value, int base)
{
return Toa(static_cast<long>(value), base);
}
for( ; i1 < i2 ; ++i1, --i2)
{
wchar_t temp = buffer[i1];
buffer[i1] = buffer[i2];
buffer[i2] = temp;
}
return buffer_;
const wchar_t * Toa(long value, int base)
{
static wchar_t buffer[50];
size_t len = sizeof(buffer) / sizeof(wchar_t);
Toa(value, buffer, len, base);
return buffer;
}
void Toa(int value, std::string & res, int base, bool clear)
{
static char buffer[50];
size_t len = sizeof(buffer) / sizeof(char);
if( clear )
res.clear();
Toa(value, buffer, len, base);
res += buffer;
}
void Toa(long value, std::string & res, int base, bool clear)
{
static char buffer[50];
size_t len = sizeof(buffer) / sizeof(char);
if( clear )
res.clear();
Toa(value, buffer, len, base);
res += buffer;
}
void Toa(int value, std::wstring & res, int base, bool clear)
{
static wchar_t buffer[50];
size_t len = sizeof(buffer) / sizeof(wchar_t);
if( clear )
res.clear();
Toa(value, buffer, len, base);
res += buffer;
}
void Toa(long value, std::wstring & res, int base, bool clear)
{
static wchar_t buffer[50];
size_t len = sizeof(buffer) / sizeof(wchar_t);
if( clear )
res.clear();
Toa(value, buffer, len, base);
res += buffer;
}
void AssignString(const char * src, size_t len, std::wstring & dst, bool clear)
{
if( clear )
dst.clear();
if( dst.capacity() < dst.size() + len )
dst.reserve(dst.size() + len + 128);
for(size_t i=0 ; i<len ; ++i )
dst += static_cast<unsigned char>(src[i]);
}
@@ -112,29 +171,31 @@ void AssignString(const char * src, std::wstring & dst, bool clear)
{
size_t len;
if( clear )
dst.clear();
for(len=0 ; src[len] ; ++len){}
if( dst.capacity() < dst.size() + len )
dst.reserve(dst.size() + len + 128);
for( ; *src ; ++src )
dst += static_cast<unsigned char>(*src);
AssignString(src, len, dst, clear);
}
void AssignString(const std::string & src, std::wstring & dst, bool clear)
{
AssignString(src.c_str(), src.size(), dst, clear);
}
void AssignString(const wchar_t * src, size_t len, std::string & dst, bool clear)
{
if( clear )
dst.clear();
if( dst.capacity() < dst.size() + src.size() )
dst.reserve(dst.size() + src.size() + 128);
if( dst.capacity() < dst.size() + len )
dst.reserve(dst.size() + len + 128);
for(size_t i=0 ; i<src.size() ; ++i )
dst += static_cast<unsigned char>(src[i]);
for(size_t i=0 ; i<len ; ++i)
dst += static_cast<char>(src[i]);
}
@@ -142,29 +203,37 @@ void AssignString(const wchar_t * src, std::string & dst, bool clear)
{
size_t len;
if( clear )
dst.clear();
for(len=0 ; src[len] ; ++len){}
if( dst.capacity() < dst.size() + len )
dst.reserve(dst.size() + len + 128);
for( ; *src ; ++src )
dst += static_cast<char>(*src);
AssignString(src, len, dst, clear);
}
void AssignString(const std::wstring & src, std::string & dst, bool clear)
{
AssignString(src.c_str(), src.size(), dst, clear);
}
void AssignString(const char * src, size_t len, std::string & dst, bool clear)
{
if( clear )
dst.clear();
if( dst.capacity() < dst.size() + src.size() )
dst.reserve(dst.size() + src.size() + 128);
// we suppose that append is smart enough and we don't have to use reserve()
dst.append(src, len);
}
for(size_t i=0 ; i<src.size() ; ++i )
dst += static_cast<char>(src[i]);
void AssignString(const char * src, std::string & dst, bool clear)
{
size_t len;
for(len=0 ; src[len] ; ++len){}
AssignString(src, len, dst, clear);
}
@@ -175,53 +244,47 @@ void AssignString(const std::string & src, std::string & dst, bool clear)
if( clear )
dst.clear();
dst += src;
dst.append(src);
}
void AssignString(const wchar_t * src, size_t len, std::wstring & dst, bool clear)
{
if( clear )
dst.clear();
// we suppose that append is smart enough and we don't have to use reserve()
dst.append(src, len);
}
void AssignString(const wchar_t * src, std::wstring & dst, bool clear)
{
size_t len;
for(len=0 ; src[len] ; ++len){}
AssignString(src, len, dst, clear);
}
void AssignString(const std::wstring & src, std::wstring & dst, bool clear)
{
if( clear )
dst.clear();
dst += src;
}
// !! skasowac, jest juz Itoa
void ToString(std::string & s, int value)
{
static char buffer[50];
sprintf(buffer, "%d", value);
s = buffer;
dst.append(src);
}
void ToString(std::string & s, long value)
{
static char buffer[50];
sprintf(buffer, "%ld", value);
s = buffer;
}
void ToString(std::wstring & s, int value)
{
static wchar_t buffer[50];
swprintf(buffer, sizeof(buffer)/sizeof(wchar_t), L"%d", value);
s = buffer;
}
void ToString(std::wstring & s, long value)
{
static wchar_t buffer[50];
swprintf(buffer, sizeof(buffer)/sizeof(wchar_t), L"%ld", value);
s = buffer;
}
@@ -264,7 +327,6 @@ std::wstring::iterator i;
{
if( !CorrectUrlChar(*i) )
{
//wchar_t c = ChangeLocalChar(*i);
wchar_t c = TemplatesFunctions::locale.Subst(*i);
if( CorrectUrlChar(c) )
@@ -309,51 +371,6 @@ void CorrectUrlOnlyAllowedChar(std::wstring & url)
/*
int polish_letters_simple[] =
{ 'a', 'A',
'c', 'C',
's', 'S',
'e', 'E',
'l', 'L',
'o', 'O',
'z', 'Z',
'z', 'Z',
'n', 'N', 0 }; // 0 - terminating
int polish_letters_iso88592[] =
{ 0xb1, 0xa1,
0xe6, 0xc6,
0xb6, 0xa6,
0xea, 0xca,
0xb3, 0xa3,
0xf3, 0xd3,
0xbf, 0xaf,
0xbc, 0xac,
0xf1, 0xd1, 0 };
int ChangeLocalChar(unsigned char c)
{
// if( language == polish_iso88592 )
for(int i = 0 ; polish_letters_iso88592[i] ; ++i)
{
if( polish_letters_simple[i] == 0 )
{
log << log1 << "localization tables don't have the same size" << logend;
return c;
}
if( polish_letters_iso88592[i] == c )
return polish_letters_simple[i];
}
return c;
}
*/
@@ -502,14 +519,6 @@ return buffer;
}
const wchar_t * ToStr(int value)
{
static wchar_t buffer[100];
swprintf(buffer, sizeof(buffer)/sizeof(wchar_t), L"%d", value);
return buffer;
}
bool IsWhite(wchar_t s)