2151 lines
48 KiB
C++
2151 lines
48 KiB
C++
// fstring.cpp
|
|
// class FString
|
|
|
|
#include "fstring.h"
|
|
|
|
//----------------------------------------------------------------------
|
|
// class FString
|
|
//----------------------------------------------------------------------
|
|
|
|
|
|
// constructors and destructor
|
|
//----------------------------------------------------------------------
|
|
FString::FString()
|
|
{
|
|
length = 0;
|
|
bufsize = 0;
|
|
string = 0;
|
|
c_string = 0;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString::FString (int len)
|
|
{
|
|
if ( len >= 0 )
|
|
initLength(uInt(len));
|
|
else
|
|
initLength(0);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString::FString (uInt len)
|
|
{
|
|
initLength(len);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString::FString (int len, wchar_t c)
|
|
{
|
|
string = 0;
|
|
length = 0;
|
|
bufsize = 0;
|
|
c_string = 0;
|
|
|
|
if ( len >= 0 )
|
|
_replace ( FString(uInt(len), c).string );
|
|
else
|
|
initLength(0);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString::FString (uInt len, wchar_t c)
|
|
{
|
|
register wchar_t* ps;
|
|
register wchar_t* pe;
|
|
|
|
initLength(len);
|
|
ps = string;
|
|
pe = string + len;
|
|
|
|
while ( pe != ps )
|
|
*--pe = c;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString::FString (int len, char c)
|
|
{
|
|
string = 0;
|
|
length = 0;
|
|
bufsize = 0;
|
|
c_string = 0;
|
|
|
|
if ( len >= 0 )
|
|
_replace ( FString(uInt(len), c).string );
|
|
else
|
|
initLength(0);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString::FString (uInt len, char c)
|
|
{
|
|
register wchar_t* ps;
|
|
register wchar_t* pe;
|
|
|
|
initLength(len);
|
|
ps = string;
|
|
pe = string + len;
|
|
|
|
while ( pe != ps )
|
|
*--pe = wchar_t(c);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString::FString (const FString& s)
|
|
{
|
|
string = 0;
|
|
length = 0;
|
|
bufsize = 0;
|
|
c_string = 0;
|
|
if ( s.string )
|
|
_replace (s.string);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString::FString (const std::wstring& s)
|
|
{
|
|
string = 0;
|
|
length = 0;
|
|
bufsize = 0;
|
|
c_string = 0;
|
|
if ( ! s.empty() )
|
|
_replace ( s.c_str() );
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString::FString (const wchar_t* s)
|
|
{
|
|
string = 0;
|
|
length = 0;
|
|
bufsize = 0;
|
|
c_string = 0;
|
|
if ( s )
|
|
_replace (s);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString::FString (const std::string& s)
|
|
{
|
|
string = 0;
|
|
length = 0;
|
|
bufsize = 0;
|
|
c_string = 0;
|
|
|
|
if ( ! s.empty() )
|
|
{
|
|
const wchar_t* wc_str;
|
|
wc_str = c_to_wc_str(s.c_str());
|
|
|
|
if ( wc_str )
|
|
{
|
|
_replace( wc_str );
|
|
if ( *wc_str )
|
|
delete[] wc_str;
|
|
}
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString::FString (const char* s)
|
|
{
|
|
const wchar_t* wc_str;
|
|
|
|
string = 0;
|
|
length = 0;
|
|
bufsize = 0;
|
|
c_string = 0;
|
|
|
|
wc_str = c_to_wc_str(s);
|
|
|
|
if ( wc_str )
|
|
{
|
|
_replace( wc_str );
|
|
if ( *wc_str )
|
|
delete[] wc_str;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString::FString (const wchar_t c)
|
|
{
|
|
string = 0;
|
|
c_string = 0;
|
|
wchar_t s[2];
|
|
s[0] = c;
|
|
s[1] = L'\0';
|
|
_replace (s);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString::FString (const char c)
|
|
{
|
|
string = 0;
|
|
c_string = 0;
|
|
wchar_t s[2];
|
|
s[0] = wchar_t(c & 0xff);
|
|
s[1] = L'\0';
|
|
_replace (s);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString::~FString() // destructor
|
|
{
|
|
if ( string )
|
|
delete[](string);
|
|
if ( c_string )
|
|
delete[](c_string);
|
|
}
|
|
|
|
|
|
// private methods of FString
|
|
//----------------------------------------------------------------------
|
|
inline void FString::initLength (uInt len)
|
|
{
|
|
if ( len > 0 )
|
|
{
|
|
length = len;
|
|
bufsize = FWDBUFFER + len + 1;
|
|
string = new wchar_t[bufsize];
|
|
wmemset(string, L'\0', bufsize);
|
|
}
|
|
else
|
|
{
|
|
length = 0;
|
|
bufsize = 0;
|
|
string = 0;
|
|
}
|
|
c_string = 0;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
inline void FString::_replace (const wchar_t* s)
|
|
{
|
|
if ( string )
|
|
delete[](string);
|
|
|
|
length = uInt(wcslen(s));
|
|
bufsize = FWDBUFFER + length + 1;
|
|
|
|
try
|
|
{
|
|
string = new wchar_t[bufsize];
|
|
}
|
|
catch (const std::bad_alloc& ex)
|
|
{
|
|
std::cerr << bad_alloc_str << ex.what() << std::endl;
|
|
return;
|
|
}
|
|
/* catch (std::exception& e)
|
|
{
|
|
std::cerr << "not enough memory for a new FString object "
|
|
<< e.what() << std::endl;
|
|
return;
|
|
}*/
|
|
wcscpy (string, s);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
inline void FString::_insert (uInt pos, uInt len, const wchar_t* s)
|
|
{
|
|
if ( ! string )
|
|
{
|
|
// string is null
|
|
length = len;
|
|
bufsize = FWDBUFFER + length + 1;
|
|
try
|
|
{
|
|
string = new wchar_t[bufsize];
|
|
}
|
|
catch (const std::bad_alloc& ex)
|
|
{
|
|
std::cerr << bad_alloc_str << " " << ex.what() << std::endl;
|
|
return;
|
|
}
|
|
wcscpy (string, s);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
uInt x;
|
|
|
|
if ( (length + len + 1) <= bufsize )
|
|
{
|
|
// output string <= bufsize
|
|
for (x = length+1; x >= pos+1; x--)
|
|
string[x+len-1] = string[x-1];
|
|
for (x=0; x < len; x++)
|
|
string[x+pos] = s[x];
|
|
length += len;
|
|
}
|
|
else
|
|
{
|
|
wchar_t* sptr;
|
|
// output string > bufsize
|
|
bufsize = FWDBUFFER + length + len + 1;
|
|
|
|
try
|
|
{
|
|
sptr = new wchar_t[bufsize];
|
|
}
|
|
catch (const std::bad_alloc& ex)
|
|
{
|
|
std::cerr << bad_alloc_str << " " << ex.what() << std::endl;
|
|
return;
|
|
}
|
|
uInt y = 0;
|
|
for (x=0; x < pos; x++)
|
|
sptr[y++] = string[x];
|
|
for (x=0; x < len; x++)
|
|
sptr[y++] = s[x];
|
|
for (x=pos; x <= length; x++)
|
|
sptr[y++] = string[x];
|
|
length += len;
|
|
delete[](string);
|
|
string = sptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
inline void FString::_remove (uInt pos, uInt len)
|
|
{
|
|
if ( (bufsize - length - 1 + len) <= FWDBUFFER )
|
|
{
|
|
for (uInt i=pos; (i+len) <= length; i++)
|
|
string[i] = string[i+len];
|
|
length -= len;
|
|
}
|
|
else
|
|
{
|
|
wchar_t* sptr;
|
|
bufsize = length + 1 - len + FWDBUFFER;
|
|
|
|
try
|
|
{
|
|
sptr = new wchar_t[bufsize];
|
|
}
|
|
catch (const std::bad_alloc& ex)
|
|
{
|
|
std::cerr << bad_alloc_str << " " << ex.what() << std::endl;
|
|
return;
|
|
}
|
|
uInt x, y = 0;
|
|
for (x=0; x < pos; x++)
|
|
sptr[y++] = string[x];
|
|
for (x=pos+len; x <= length; x++)
|
|
sptr[y++] = string[x];
|
|
delete[](string);
|
|
string = sptr;
|
|
length -= len;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
inline char* FString::wc_to_c_str (const wchar_t* s) const
|
|
{
|
|
int mblength, size, dest_size;
|
|
const wchar_t* src;
|
|
|
|
if ( ! s ) // handle NULL string
|
|
return 0;
|
|
if ( ! *s ) // handle empty string
|
|
return const_cast<char*>("");
|
|
if ( c_string )
|
|
delete[](c_string);
|
|
|
|
size = int(wcslen(s)) + 1;
|
|
dest_size = size * int(CHAR_SIZE);
|
|
src = s;
|
|
mbstate_t state;
|
|
memset (&state, '\0', sizeof(mbstate_t));
|
|
|
|
try
|
|
{
|
|
c_string = new char[dest_size];
|
|
|
|
// pre-initialiaze the whole string with '\0'
|
|
memset (c_string, '\0', size_t(dest_size));
|
|
}
|
|
catch (const std::bad_alloc& ex)
|
|
{
|
|
std::cerr << bad_alloc_str << " " << ex.what() << std::endl;
|
|
return 0;
|
|
}
|
|
|
|
mblength = int(wcsrtombs (c_string, &src, uLong(dest_size), &state));
|
|
|
|
if ( mblength == -1 && errno != EILSEQ )
|
|
{
|
|
delete[](c_string);
|
|
c_string = 0;
|
|
return const_cast<char*>("");
|
|
}
|
|
return c_string;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
inline wchar_t* FString::c_to_wc_str (const char* s) const
|
|
{
|
|
int wclength, size, dest_size;
|
|
const char* src;
|
|
wchar_t* dest;
|
|
|
|
if ( ! s ) // handle NULL string
|
|
return 0;
|
|
if ( ! *s ) // handle empty string
|
|
return const_cast<wchar_t*>(L"");
|
|
|
|
|
|
size = int(strlen(s)) + 1;
|
|
dest_size = size * int(CHAR_SIZE);
|
|
src = s;
|
|
mbstate_t state;
|
|
memset (&state, '\0', sizeof(mbstate_t));
|
|
|
|
try
|
|
{
|
|
dest = new wchar_t[size];
|
|
// pre-initialiaze the whole string with '\0'
|
|
wmemset (dest, L'\0', size_t(size));
|
|
}
|
|
catch (const std::bad_alloc& ex)
|
|
{
|
|
std::cerr << bad_alloc_str << " " << ex.what() << std::endl;
|
|
return 0;
|
|
}
|
|
|
|
wclength = int(mbsrtowcs (dest, &src, uLong(dest_size), &state));
|
|
|
|
if ( wclength == -1 )
|
|
{
|
|
if ( src != s )
|
|
return dest;
|
|
else
|
|
{
|
|
delete[] dest;
|
|
return 0;
|
|
}
|
|
}
|
|
if ( wclength == size )
|
|
dest[size-1] = '\0';
|
|
if ( wclength )
|
|
return dest;
|
|
else
|
|
{
|
|
delete[] dest;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
inline wchar_t* FString::extractToken ( wchar_t** rest,
|
|
const wchar_t* s,
|
|
const wchar_t* delim )
|
|
{
|
|
register wchar_t* token;
|
|
token = ( s ) ? const_cast<wchar_t*>(s) : *rest;
|
|
|
|
if ( ! *token )
|
|
return 0;
|
|
|
|
*rest = wcspbrk(token, delim);
|
|
|
|
if ( *rest )
|
|
*(*rest)++ = '\0';
|
|
else
|
|
*rest = token + wcslen(token);
|
|
return token;
|
|
}
|
|
|
|
|
|
// FString operators
|
|
//----------------------------------------------------------------------
|
|
std::ostream& operator << (std::ostream& outstr, const FString& s)
|
|
{
|
|
if ( s.length )
|
|
outstr << s.wc_to_c_str( s.string );
|
|
return (outstr);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
std::istream& operator >> (std::istream& instr, FString& s)
|
|
{
|
|
const wchar_t* wc_str;
|
|
char buf[INPBUFFER+1];
|
|
|
|
instr.getline (buf, INPBUFFER);
|
|
wc_str = s.c_to_wc_str(buf);
|
|
|
|
if ( wc_str )
|
|
{
|
|
s._replace (wc_str);
|
|
if ( *wc_str )
|
|
delete[] wc_str;
|
|
}
|
|
return (instr);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
std::wostream& operator << (std::wostream& outstr, const FString& s)
|
|
{
|
|
if ( s.length )
|
|
outstr << s.string;
|
|
return (outstr);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
std::wistream& operator >> (std::wistream& instr, FString& s)
|
|
{
|
|
wchar_t buf[INPBUFFER+1];
|
|
instr.getline (buf, INPBUFFER);
|
|
s._replace (buf);
|
|
return (instr);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString& FString::operator = (const FString& s)
|
|
{
|
|
if ( s )
|
|
_replace (s.string);
|
|
else
|
|
length = bufsize = 0, string = 0;
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString& FString::operator = (const std::wstring& s)
|
|
{
|
|
if ( ! s.empty() )
|
|
_replace (s.c_str());
|
|
else
|
|
length = bufsize = 0, string = 0;
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString& FString::operator = (const wchar_t* s)
|
|
{
|
|
if ( s )
|
|
_replace (s);
|
|
else
|
|
length = bufsize = 0, string = 0;
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString& FString::operator = (const std::string& s)
|
|
{
|
|
const wchar_t* wc_str = c_to_wc_str(s.c_str());
|
|
if ( wc_str )
|
|
{
|
|
_replace( wc_str );
|
|
if ( *wc_str )
|
|
delete[] wc_str;
|
|
}
|
|
else
|
|
length = bufsize = 0, string = 0;
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString& FString::operator = (const char* s)
|
|
{
|
|
const wchar_t* wc_str = c_to_wc_str(s);
|
|
if ( wc_str )
|
|
{
|
|
_replace( wc_str );
|
|
if ( *wc_str )
|
|
delete[] wc_str;
|
|
}
|
|
else
|
|
length = bufsize = 0, string = 0;
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString& FString::operator = (const wchar_t c)
|
|
{
|
|
wchar_t s[2];
|
|
s[0] = c;
|
|
s[1] = L'\0';
|
|
_replace (s);
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString& FString::operator = (const char c)
|
|
{
|
|
wchar_t s[2];
|
|
s[0] = wchar_t(c & 0xff);
|
|
s[1] = L'\0';
|
|
_replace (s);
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString& FString::operator += (const FString& s)
|
|
{
|
|
_insert (length, s.length, s.string);
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString& FString::operator += (const std::wstring& s)
|
|
{
|
|
_insert (length, uInt(s.length()), s.c_str());
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString& FString::operator += (const wchar_t* s)
|
|
{
|
|
_insert (length, uInt(wcslen(s)), s);
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString& FString::operator += (const std::string& s)
|
|
{
|
|
const wchar_t* wc_str = c_to_wc_str(s.c_str());
|
|
if ( wc_str )
|
|
{
|
|
_insert (length, uInt(s.length()), wc_str);
|
|
if ( *wc_str )
|
|
delete[] wc_str;
|
|
}
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString& FString::operator += (const char* s)
|
|
{
|
|
const wchar_t* wc_str = c_to_wc_str(s);
|
|
if ( wc_str )
|
|
{
|
|
_insert (length, uInt(strlen(s)), wc_str);
|
|
if ( *wc_str )
|
|
delete[] wc_str;
|
|
}
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString& FString::operator += (const wchar_t c)
|
|
{
|
|
_insert (length, 1, &c);
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString& FString::operator += (const char c)
|
|
{
|
|
const wchar_t wc = static_cast<wchar_t>(c);
|
|
_insert (length, 1, &wc );
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString FString::operator + (const FString& s)
|
|
{
|
|
FString tmp(string);
|
|
tmp._insert (length, s.length, s.string);
|
|
return (tmp);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString FString::operator + (const std::wstring& s)
|
|
{
|
|
FString tmp(string);
|
|
tmp._insert (length, uInt(s.length()), s.c_str());
|
|
return (tmp);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString FString::operator + (const wchar_t* s)
|
|
{
|
|
FString tmp(string);
|
|
tmp._insert (length, uInt(wcslen(s)), s);
|
|
return (tmp);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString FString::operator + (const std::string& s)
|
|
{
|
|
FString tmp(string);
|
|
wchar_t* wc_str = c_to_wc_str(s.c_str());
|
|
if ( ! wc_str )
|
|
return (tmp);
|
|
tmp._insert (length, uInt(wcslen(wc_str)), wc_str);
|
|
if ( *wc_str )
|
|
delete[] wc_str;
|
|
return (tmp);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString FString::operator + (const char* s)
|
|
{
|
|
FString tmp(string);
|
|
wchar_t* wc_str = c_to_wc_str(s);
|
|
if ( ! wc_str )
|
|
return (tmp);
|
|
tmp._insert (length, uInt(wcslen(wc_str)), wc_str);
|
|
if ( *wc_str )
|
|
delete[] wc_str;
|
|
return (tmp);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString FString::operator + (const wchar_t c)
|
|
{
|
|
FString tmp(string);
|
|
tmp._insert (length, 1, &c);
|
|
return(tmp);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString FString::operator + (const char c)
|
|
{
|
|
const wchar_t wc = static_cast<wchar_t>(c);
|
|
FString tmp(string);
|
|
tmp._insert (length, 1, &wc);
|
|
return(tmp);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString operator + (const FString& s1, const FString& s2)
|
|
{
|
|
FString tmp(s1);
|
|
tmp._insert ( uInt(wcslen(s1.wc_str())),
|
|
uInt(wcslen(s2.wc_str())),
|
|
s2.wc_str() );
|
|
return (tmp);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString operator + (const FString& s, const wchar_t c)
|
|
{
|
|
FString tmp(s);
|
|
tmp._insert ( uInt(wcslen(s.wc_str())), 1, &c);
|
|
return (tmp);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString operator + (const std::wstring& s1, const FString& s2)
|
|
{
|
|
FString tmp(s1);
|
|
tmp._insert ( uInt(wcslen(s1.c_str())),
|
|
uInt(wcslen(s2.wc_str())),
|
|
s2.wc_str() );
|
|
return (tmp);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString operator + (const wchar_t* s1, const FString& s2)
|
|
{
|
|
FString tmp(s1);
|
|
tmp._insert ( uInt(wcslen(s1)),
|
|
uInt(wcslen(s2.wc_str())),
|
|
s2.wc_str() );
|
|
return (tmp);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString operator + (const std::string& s1, const FString& s2)
|
|
{
|
|
FString tmp(s1);
|
|
tmp._insert ( tmp.getLength(),
|
|
uInt(wcslen(s2.wc_str())),
|
|
s2.wc_str() );
|
|
return (tmp);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString operator + (const char* s1, const FString& s2)
|
|
{
|
|
FString tmp(s1);
|
|
tmp._insert ( tmp.getLength(),
|
|
uInt(wcslen(s2.wc_str())),
|
|
s2.wc_str() );
|
|
return (tmp);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString operator + (const wchar_t c, const FString& s)
|
|
{
|
|
FString tmp(c);
|
|
tmp._insert (1, uInt(wcslen(s.wc_str())), s.wc_str());
|
|
return (tmp);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString operator + (const char c, const FString& s)
|
|
{
|
|
FString tmp(c);
|
|
tmp._insert (1, uInt(wcslen(s.wc_str())), s.wc_str());
|
|
return (tmp);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString operator + (const wchar_t c, const std::wstring& s)
|
|
{
|
|
FString tmp(c);
|
|
tmp._insert (1, uInt(s.length()), s.c_str());
|
|
return (tmp);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
wchar_t& FString::operator [] (uInt pos)
|
|
{
|
|
assert ( (pos < length) && "Invalid index position!" );
|
|
if (pos >= length)
|
|
throw std::out_of_range("");
|
|
return (string[pos]);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString FString::operator () (uInt pos, uInt len)
|
|
{
|
|
assert ( (pos < length) && ((pos+len) <= length) );
|
|
FString tmp(L"");
|
|
tmp._insert (0, len, string + pos);
|
|
return (tmp);
|
|
}
|
|
|
|
|
|
// public methods of FString
|
|
//----------------------------------------------------------------------
|
|
uInt FString::getUTF8length() const
|
|
{
|
|
uInt len;
|
|
const char* s;
|
|
|
|
len = 0;
|
|
s = c_str();
|
|
|
|
while ( *s )
|
|
len += uInt((*s++ & 0xc0) != 0x80);
|
|
|
|
return len;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString& FString::sprintf (const wchar_t* format, ...)
|
|
{
|
|
const int buf_size = 4096;
|
|
wchar_t buffer[buf_size];
|
|
va_list args;
|
|
|
|
va_start (args, format);
|
|
vswprintf (buffer, buf_size, format, args);
|
|
va_end (args);
|
|
|
|
this->_replace (buffer);
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString& FString::sprintf (const char* format, ...)
|
|
{
|
|
const wchar_t* wc_str;
|
|
char buf[1024];
|
|
char* buffer;
|
|
int len;
|
|
va_list args;
|
|
|
|
buffer = buf;
|
|
va_start (args, format);
|
|
len = vsnprintf (buffer, sizeof(buf), format, args);
|
|
va_end (args);
|
|
|
|
if ( len >= int(sizeof(buf)) )
|
|
{
|
|
buffer = new char[len+1];
|
|
va_start (args, format);
|
|
vsnprintf (buffer, uLong(len+1), format, args);
|
|
va_end (args);
|
|
}
|
|
|
|
wc_str = c_to_wc_str(buffer);
|
|
if ( wc_str )
|
|
{
|
|
this->_replace(wc_str);
|
|
if ( *wc_str )
|
|
delete[] wc_str;
|
|
}
|
|
if ( buffer != buf )
|
|
delete[] buffer;
|
|
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::clear()
|
|
{
|
|
if ( string )
|
|
delete[](string);
|
|
length = 0;
|
|
bufsize = 0;
|
|
string = 0;
|
|
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const wchar_t* FString::wc_str() const
|
|
{
|
|
return (string);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const char* FString::c_str() const
|
|
{
|
|
return wc_to_c_str (string);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const std::string FString::toString() const
|
|
{
|
|
return std::string(this->c_str(), length+1);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::toLower() const
|
|
{
|
|
register wchar_t* p;
|
|
FString s(this->string);
|
|
p = s.string;
|
|
|
|
if ( p )
|
|
{
|
|
while ( *p )
|
|
{
|
|
*p = wchar_t(towlower(uInt(*p)));
|
|
p++;
|
|
}
|
|
}
|
|
return s;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::toUpper() const
|
|
{
|
|
register wchar_t* p;
|
|
FString s(this->string);
|
|
p = s.string;
|
|
|
|
if ( p )
|
|
{
|
|
while ( *p )
|
|
{
|
|
*p = wchar_t(towupper(uInt(*p)));
|
|
p++;
|
|
}
|
|
}
|
|
return s;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
sInt16 FString::toShort() const
|
|
{
|
|
register long num;
|
|
num = this->toLong();
|
|
|
|
if ( num > SHRT_MAX || num < SHRT_MIN )
|
|
throw std::overflow_error ("overflow");
|
|
|
|
return sInt16(num);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
uInt16 FString::toUShort() const
|
|
{
|
|
register uLong num;
|
|
num = uLong(this->toLong());
|
|
|
|
if ( num > USHRT_MAX )
|
|
throw std::overflow_error ("overflow");
|
|
|
|
return uInt16(num);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
int FString::toInt() const
|
|
{
|
|
register long num;
|
|
num = this->toLong();
|
|
|
|
if ( num > INT_MAX || num < INT_MIN )
|
|
throw std::overflow_error ("overflow");
|
|
|
|
return int(num);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
uInt FString::toUInt() const
|
|
{
|
|
register uLong num;
|
|
num = uLong(this->toLong());
|
|
|
|
if ( num > UINT_MAX )
|
|
throw std::overflow_error ("overflow");
|
|
|
|
return uInt(num);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
long FString::toLong() const
|
|
{
|
|
register long num;
|
|
register long tenth_limit;
|
|
register long tenth_limit_digit;
|
|
register wchar_t* p;
|
|
FString s;
|
|
|
|
num = 0;
|
|
tenth_limit = LONG_MAX / 10;
|
|
tenth_limit_digit = LONG_MAX % 10;
|
|
s = this->trim();
|
|
p = s.string;
|
|
|
|
if ( ! p )
|
|
throw std::invalid_argument ("null value");
|
|
|
|
if ( ! *p )
|
|
throw std::invalid_argument ("empty value");
|
|
|
|
if ( *p == L'-' )
|
|
{
|
|
p++;
|
|
tenth_limit = -(LONG_MIN / 10);
|
|
tenth_limit_digit += 1;
|
|
}
|
|
else if ( *p == L'+' )
|
|
{
|
|
p++;
|
|
}
|
|
|
|
while ( isdigit(*p) )
|
|
{
|
|
register uChar d = uChar((*p) - L'0');
|
|
if ( num > tenth_limit
|
|
|| (num == tenth_limit && d > tenth_limit_digit) )
|
|
{
|
|
throw std::overflow_error ("overflow");
|
|
}
|
|
num = (num<<3)+(num<<1) + d; // (10 * num) + d
|
|
p++;
|
|
}
|
|
|
|
if ( *p != L'\0' && ! isdigit(*p) )
|
|
throw std::invalid_argument ("no valid number");
|
|
|
|
return num;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
uLong FString::toULong() const
|
|
{
|
|
register uLong num;
|
|
register uLong tenth_limit;
|
|
register uLong tenth_limit_digit;
|
|
register wchar_t* p;
|
|
FString s;
|
|
|
|
num = 0;
|
|
tenth_limit = ULONG_MAX / 10;
|
|
tenth_limit_digit = ULONG_MAX % 10;
|
|
s = this->trim();
|
|
p = s.string;
|
|
|
|
if ( ! p )
|
|
throw std::invalid_argument ("null value");
|
|
|
|
if ( ! *p )
|
|
throw std::invalid_argument ("empty value");
|
|
|
|
if ( *p == L'+' )
|
|
{
|
|
p++;
|
|
}
|
|
|
|
while ( isdigit(*p) )
|
|
{
|
|
register uChar d = uChar((*p) - L'0');
|
|
if ( num > tenth_limit
|
|
|| (num == tenth_limit && d > tenth_limit_digit) )
|
|
{
|
|
throw std::overflow_error ("overflow");
|
|
}
|
|
num = (num<<3)+(num<<1) + d; // (10 * num) + d
|
|
p++;
|
|
}
|
|
|
|
if ( *p != L'\0' && ! isdigit(*p) )
|
|
throw std::invalid_argument ("no valid number");
|
|
|
|
return num;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
float FString::toFloat() const
|
|
{
|
|
register double num;
|
|
num = this->toDouble();
|
|
|
|
if ( num > FLT_MAX || num < FLT_MIN )
|
|
throw std::overflow_error ("overflow");
|
|
|
|
return float(num);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
double FString::toDouble() const
|
|
{
|
|
wchar_t* p;
|
|
register double ret;
|
|
|
|
if ( ! this->string )
|
|
throw std::invalid_argument ("null value");
|
|
|
|
if ( ! *this->string )
|
|
throw std::invalid_argument ("empty value");
|
|
|
|
ret = wcstod(this->string, &p);
|
|
|
|
if ( p != 0 && *p != '\0' )
|
|
throw std::invalid_argument ("no valid floating point value");
|
|
|
|
if ( errno == ERANGE )
|
|
{
|
|
if ( ret >= HUGE_VAL || ret <= -HUGE_VAL )
|
|
throw std::overflow_error ("overflow");
|
|
if ( ret == 0.0l )
|
|
throw std::underflow_error ("underflow");
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::ltrim() const
|
|
{
|
|
register wchar_t* p;
|
|
FString s(this->string);
|
|
|
|
// handle NULL and empty string
|
|
if ( ! this->string || ! *this->string )
|
|
return s;
|
|
p = s.string;
|
|
while ( iswspace(uInt(*p)) )
|
|
p++;
|
|
return FString(p);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::rtrim() const
|
|
{
|
|
register wchar_t* p;
|
|
register wchar_t* last;
|
|
FString s(this->string);
|
|
|
|
// handle NULL and empty string
|
|
if ( ! this->string || ! *this->string )
|
|
return s;
|
|
p = s.string;
|
|
last = p + length;
|
|
while ( iswspace(uInt(*--last)) && last > p );
|
|
if ( last == p && iswspace(uInt(*last)) )
|
|
s.clear();
|
|
else
|
|
*(last+1) = '\0';
|
|
|
|
return s;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::trim() const
|
|
{
|
|
// handle NULL and empty string
|
|
if ( ! this->string || ! *this->string )
|
|
return (*this);
|
|
FString s(this->ltrim());
|
|
return s.rtrim();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::left(uInt len) const
|
|
{
|
|
register wchar_t* p;
|
|
FString s(this->string);
|
|
|
|
// handle NULL and empty string
|
|
if ( ! this->string || ! *this->string )
|
|
return s;
|
|
if ( len > length )
|
|
return s;
|
|
p = s.string;
|
|
*(p+len) = '\0';
|
|
return s;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::right(uInt len) const
|
|
{
|
|
register wchar_t* p;
|
|
FString s(this->string);
|
|
|
|
// handle NULL and empty string
|
|
if ( ! this->string || ! *this->string )
|
|
return s;
|
|
if ( len > length )
|
|
return s;
|
|
p = s.string;
|
|
p += (length-len);
|
|
return FString(p);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::mid(uInt pos, uInt len) const
|
|
{
|
|
register wchar_t* p;
|
|
register wchar_t* first;
|
|
FString s(this->string);
|
|
|
|
// handle NULL and empty string
|
|
if ( ! this->string || ! *this->string )
|
|
return s;
|
|
if ( pos == 0 )
|
|
pos = 1;
|
|
if ( pos <= length && pos+len > length )
|
|
len = length - pos + 1;
|
|
if ( pos > length || pos+len-1 > length || len == 0 )
|
|
return FString(L"");
|
|
|
|
p = s.string;
|
|
first = p + pos - 1;
|
|
*(first+len) = '\0';
|
|
return FString(first);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
std::vector<FString> FString::split (const FString& delimiter)
|
|
{
|
|
wchar_t* rest;
|
|
wchar_t* token;
|
|
FString s(this->string);
|
|
std::vector<FString> stringList;
|
|
|
|
// handle NULL and empty string
|
|
if ( ! this->string || ! *this->string )
|
|
return stringList;
|
|
|
|
rest = 0;
|
|
token = extractToken(&rest, s.string, delimiter.wc_str());
|
|
|
|
while ( token )
|
|
{
|
|
stringList.push_back (FString(token));
|
|
token = extractToken (&rest, 0, delimiter.wc_str());
|
|
}
|
|
return stringList;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString& FString::setString (const wchar_t* s)
|
|
{
|
|
_replace (s);
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString& FString::setString (const char* s)
|
|
{
|
|
const wchar_t* wc_str = c_to_wc_str(s);
|
|
if ( wc_str )
|
|
{
|
|
_replace (wc_str);
|
|
if ( *wc_str )
|
|
delete[] wc_str;
|
|
}
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString& FString::setNumber (long num)
|
|
{
|
|
register wchar_t* s;
|
|
register bool neg;
|
|
wchar_t buf[30];
|
|
|
|
s = &buf[29];
|
|
|
|
if ( num < 0 )
|
|
{
|
|
neg = true;
|
|
num = -num;
|
|
}
|
|
else
|
|
{
|
|
neg = false;
|
|
}
|
|
*s = '\0';
|
|
do
|
|
{
|
|
*--s = wchar_t(int(num%10) + '0');
|
|
num /= 10;
|
|
} while ( num );
|
|
|
|
if ( neg )
|
|
*--s = '-';
|
|
_replace (s);
|
|
return *this;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString& FString::setNumber (uLong num)
|
|
{
|
|
register wchar_t* s;
|
|
wchar_t buf[30];
|
|
|
|
s = &buf[29];
|
|
*s = '\0';
|
|
|
|
do
|
|
{
|
|
*--s = wchar_t(int(num%10) + '0');
|
|
num /= 10;
|
|
} while ( num );
|
|
|
|
_replace (s);
|
|
|
|
return *this;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString& FString::setNumber (lDouble num, int precision)
|
|
{
|
|
register wchar_t *s;
|
|
wchar_t format[20]; // = "%.<precision>Lg"
|
|
|
|
s = &format[0];
|
|
*s++ = L'%';
|
|
*s++ = L'.';
|
|
|
|
if ( precision > 99 )
|
|
precision = 99;
|
|
|
|
if ( precision >= 10 )
|
|
{
|
|
*s++ = precision / 10 + L'0';
|
|
*s++ = precision % 10 + L'0';
|
|
}
|
|
else
|
|
*s++ = precision + L'0';
|
|
|
|
*s++ = L'L';
|
|
*s++ = L'g';
|
|
*s = L'\0';
|
|
|
|
return sprintf(format, num);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString& FString::setFormatedNumber (long num, char separator)
|
|
{
|
|
register int n;
|
|
register wchar_t* s;
|
|
register bool neg;
|
|
wchar_t buf[30];
|
|
|
|
n = 0;
|
|
s = &buf[29];
|
|
|
|
if ( num < 0 )
|
|
{
|
|
neg = true;
|
|
num = -num;
|
|
}
|
|
else
|
|
{
|
|
neg = false;
|
|
}
|
|
*s = L'\0';
|
|
do
|
|
{
|
|
*--s = wchar_t(int(num%10) + '0');
|
|
num /= 10;
|
|
if ( num && ++n % 3 == 0 )
|
|
*--s = separator;
|
|
} while ( num );
|
|
|
|
if ( neg )
|
|
*--s = '-';
|
|
_replace (s);
|
|
return *this;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString& FString::setFormatedNumber (uLong num, char separator)
|
|
{
|
|
register int n;
|
|
register wchar_t* s;
|
|
wchar_t buf[30];
|
|
|
|
n = 0;
|
|
s = &buf[29];
|
|
*s = L'\0';
|
|
|
|
do
|
|
{
|
|
*--s = wchar_t(int(num%10) + '0');
|
|
num /= 10;
|
|
if ( num && ++n % 3 == 0 )
|
|
*--s = separator;
|
|
|
|
} while ( num );
|
|
|
|
_replace (s);
|
|
|
|
return *this;
|
|
}
|
|
|
|
// FString operators
|
|
//----------------------------------------------------------------------
|
|
bool FString::operator < (const FString& s) const
|
|
{
|
|
if ( ! s )
|
|
return false;
|
|
if ( string && ! s.string )
|
|
return false;
|
|
if ( ! string && s.string )
|
|
return true;
|
|
if ( ! string && ! s.string )
|
|
return false;
|
|
return (wcscmp(string, s.string) < 0);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
bool FString::operator <= (const FString& s) const
|
|
{
|
|
if ( ! s )
|
|
return false;
|
|
if ( string && ! s.string )
|
|
return false;
|
|
if ( ! string && s.string )
|
|
return true;
|
|
if ( ! string && ! s.string )
|
|
return true;
|
|
return (wcscmp(string, s.string) <= 0);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
bool FString::operator == (const FString& s) const
|
|
{
|
|
if ( ! s )
|
|
return false;
|
|
if ( (string && ! s.string ) || (! string && s.string) )
|
|
return false;
|
|
if ( ! string && ! s.string )
|
|
return true;
|
|
return (wcscmp(string, s.string) == 0);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
bool FString::operator != (const FString& s) const
|
|
{
|
|
if ( ! s )
|
|
return true;
|
|
if ( (string && ! s.string ) || (! string && s.string) )
|
|
return true;
|
|
if ( ! string && ! s.string )
|
|
return false;
|
|
return (wcscmp(string, s.string) != 0);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
bool FString::operator >= (const FString& s) const
|
|
{
|
|
if ( ! s )
|
|
return true;
|
|
if ( string && ! s.string )
|
|
return true;
|
|
if ( ! string && s.string )
|
|
return false;
|
|
if ( ! string && ! s.string )
|
|
return true;
|
|
return (wcscmp(string, s.string) >= 0);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
bool FString::operator > (const FString& s) const
|
|
{
|
|
if ( ! s )
|
|
return true;
|
|
if ( string && ! s.string )
|
|
return true;
|
|
if ( ! string && s.string )
|
|
return false;
|
|
if ( ! string && ! s.string )
|
|
return false;
|
|
return (wcscmp(string, s.string) > 0);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString& FString::insert (const FString& s, uInt pos)
|
|
{
|
|
// assert (pos <= length);
|
|
if ( pos >= length )
|
|
throw std::out_of_range("");
|
|
_insert (pos, s.length, s.string);
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString& FString::insert (const wchar_t* s, uInt pos)
|
|
{
|
|
// assert (pos <= length);
|
|
if ( pos >= length )
|
|
throw std::out_of_range("");
|
|
_insert (pos, uInt(wcslen(s)), s);
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString& FString::insert (const char* s, uInt pos)
|
|
{
|
|
return (insert(FString(s), pos));
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString& FString::insert (const wchar_t c, uInt pos)
|
|
{
|
|
return (insert(FString(c), pos));
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString& FString::insert (const char c, uInt pos)
|
|
{
|
|
return (insert(FString(c), pos));
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const FString& from, const FString& to)
|
|
{
|
|
register wchar_t* p;
|
|
uInt from_length, to_length, pos;
|
|
FString s(this->string);
|
|
|
|
// handle NULL and empty string
|
|
if ( ! this->string || ! *this->string )
|
|
return s;
|
|
if ( from.isNull() || to.isNull() )
|
|
return s;
|
|
p = s.string;
|
|
from_length = from.getLength();
|
|
to_length = to.getLength();
|
|
pos = 0;
|
|
while ( *p )
|
|
{
|
|
if ( wcsncmp(p, from.string, from_length) == 0 )
|
|
{
|
|
s._remove(pos, from_length);
|
|
s._insert(pos, to_length, to.string);
|
|
pos += to_length;
|
|
p = s.string + pos;
|
|
}
|
|
else
|
|
{
|
|
pos++;
|
|
p++;
|
|
}
|
|
}
|
|
return s;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const FString& from, const std::wstring& to)
|
|
{
|
|
FString to_str(to);
|
|
return replace (from, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const FString& from, const wchar_t* to)
|
|
{
|
|
FString to_str(to);
|
|
return replace (from, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const FString& from, const std::string& to)
|
|
{
|
|
FString to_str(to);
|
|
return replace (from, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const FString& from, const char* to)
|
|
{
|
|
FString to_str(to);
|
|
return replace (from, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const FString& from, const wchar_t to)
|
|
{
|
|
FString to_wchar(to);
|
|
return replace (from, to_wchar);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const FString& from, const char to)
|
|
{
|
|
FString to_char(to);
|
|
return replace (from, to_char);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const std::wstring& from, const FString& to)
|
|
{
|
|
FString from_str(from);
|
|
return replace (from_str, to);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const std::wstring& from, const std::wstring& to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_str(to);
|
|
return replace (from_str, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const std::wstring& from, const wchar_t* to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_str(to);
|
|
return replace (from_str, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const std::wstring& from, const std::string& to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_str(to);
|
|
return replace (from_str, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const std::wstring& from, const char* to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_str(to);
|
|
return replace (from_str, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const std::wstring& from, const wchar_t to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_wchar(to);
|
|
return replace (from_str, to_wchar);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const std::wstring& from, const char to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_char(to);
|
|
return replace (from_str, to_char);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const std::string& from, const FString& to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_str(to);
|
|
return replace (from_str, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const std::string& from, const std::wstring& to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_str(to);
|
|
return replace (from_str, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const std::string& from, const wchar_t* to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_str(to);
|
|
return replace (from_str, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const std::string& from, const std::string& to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_str(to);
|
|
return replace (from_str, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const std::string& from, const char* to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_str(to);
|
|
return replace (from_str, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const std::string& from, const wchar_t to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_wchar(to);
|
|
return replace (from_str, to_wchar);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const std::string& from, const char to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_char(to);
|
|
return replace (from_str, to_char);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const wchar_t* from, const FString& to)
|
|
{
|
|
FString from_str(from);
|
|
return replace (from_str, to);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const wchar_t* from, const std::wstring& to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_str(to);
|
|
return replace (from_str, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const wchar_t* from, const wchar_t* to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_str(to);
|
|
return replace (from_str, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const wchar_t* from, const wchar_t to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_wchar(to);
|
|
return replace (from_str, to_wchar);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const wchar_t* from, const char to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_char(to);
|
|
return replace (from_str, to_char);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const char* from, const FString& to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_str(to);
|
|
return replace (from_str, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const char* from, const std::wstring& to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_str(to);
|
|
return replace (from_str, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const char* from, const wchar_t* to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_str(to);
|
|
return replace (from_str, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const char* from, const std::string& to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_str(to);
|
|
return replace (from_str, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const char* from, const char* to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_str(to);
|
|
return replace (from_str, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const char* from, const wchar_t to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_wchar(to);
|
|
return replace (from_str, to_wchar);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const char* from, const char to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_char(to);
|
|
return replace (from_str, to_char);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const wchar_t from, const FString& to)
|
|
{
|
|
register wchar_t* p;
|
|
FString s(this->string);
|
|
|
|
// handle NULL and empty string
|
|
if ( ! this->string || ! *this->string )
|
|
return s;
|
|
if ( to.isNull() )
|
|
return s;
|
|
p = s.string;
|
|
uInt to_length = to.getLength();
|
|
uInt pos = 0;
|
|
while ( *p )
|
|
{
|
|
if ( wchar_t(*p) == from )
|
|
{
|
|
s._remove(pos, 1);
|
|
s._insert(pos, to_length, to.wc_str());
|
|
pos += to_length;
|
|
p = s.string + pos;
|
|
}
|
|
else
|
|
{
|
|
pos++;
|
|
p++;
|
|
}
|
|
}
|
|
return s;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const wchar_t from, const std::wstring& to)
|
|
{
|
|
FString to_str(to);
|
|
return replace (from, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const wchar_t from, const wchar_t* to)
|
|
{
|
|
FString to_str(to);
|
|
return replace (from, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const wchar_t from, const std::string& to)
|
|
{
|
|
FString to_str(to);
|
|
return replace (from, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const wchar_t from, const char* to)
|
|
{
|
|
FString to_str(to);
|
|
return replace (from, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const wchar_t from, const wchar_t to)
|
|
{
|
|
FString to_wchar(to);
|
|
return replace (from, to_wchar);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const char from, const FString& to)
|
|
{
|
|
FString from_str(from);
|
|
return replace (from_str, to);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const char from, const std::wstring& to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_str(to);
|
|
return replace (from_str, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const char from, const wchar_t* to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_str(to);
|
|
return replace (from_str, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const char from, const std::string& to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_str(to);
|
|
return replace (from_str, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const char from, const char* to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_str(to);
|
|
return replace (from_str, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const char from, const wchar_t to)
|
|
{
|
|
FString from_str(from);
|
|
FString to_str(to);
|
|
return replace (from_str, to_str);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replace (const char from, const char to)
|
|
{
|
|
register wchar_t* p;
|
|
FString s(this->string);
|
|
|
|
// handle NULL and empty string
|
|
if ( ! this->string || ! *this->string )
|
|
return s;
|
|
|
|
p = s.string;
|
|
while ( *p )
|
|
{
|
|
if ( char(*p) == from )
|
|
*p = to;
|
|
p++;
|
|
}
|
|
return s;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::replaceControlCodes() const
|
|
{
|
|
register wchar_t* p;
|
|
FString s(this->string);
|
|
|
|
p = s.string;
|
|
|
|
if ( p )
|
|
{
|
|
while ( *p )
|
|
{
|
|
if ( *p <= L'\x1f' )
|
|
{
|
|
*p += L'\x2400';
|
|
}
|
|
else if ( *p == L'\x7f' )
|
|
{
|
|
*p = L'\x2421';
|
|
}
|
|
else if ( *p >= L'\x80' && *p <= L'\x9f' )
|
|
{
|
|
*p = L' ';
|
|
}
|
|
else if ( ! iswprint(wint_t(*p)) )
|
|
*p = L' ';
|
|
p++;
|
|
}
|
|
}
|
|
return s;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::expandTabs (uInt tabstop) const
|
|
{
|
|
uLong end;
|
|
FString instr(this->string);
|
|
FString outstr("");
|
|
|
|
std::vector<FString> tab_split = instr.split("\t");
|
|
end = tab_split.size();
|
|
for (uInt i=0; i < end; i++)
|
|
{
|
|
uInt len = tab_split[i].getLength();
|
|
outstr += tab_split[i] + FString(tabstop - len % tabstop, L' ');
|
|
}
|
|
return outstr;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::removeDel() const
|
|
{
|
|
register wchar_t* p;
|
|
|
|
FString s(this->string);
|
|
p = s.string;
|
|
|
|
if ( p )
|
|
{
|
|
uInt i=0;
|
|
uInt d=0;
|
|
while ( *p )
|
|
{
|
|
if ( *p == 0x7f )
|
|
{
|
|
d++;
|
|
}
|
|
else if ( d > 0 )
|
|
{
|
|
d--;
|
|
}
|
|
else
|
|
{
|
|
s.string[i] = *p;
|
|
i++;
|
|
}
|
|
p++;
|
|
}
|
|
s.string[i] = L'\0';
|
|
s.length = i;
|
|
}
|
|
return s;
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
FString FString::removeBackspaces() const
|
|
{
|
|
register wchar_t* p;
|
|
|
|
FString s(this->string);
|
|
p = s.string;
|
|
|
|
if ( p )
|
|
{
|
|
uInt i=0;
|
|
while ( *p )
|
|
{
|
|
if ( *p != L'\b' )
|
|
{
|
|
s.string[i] = *p;
|
|
i++;
|
|
}
|
|
else if ( i > 0 )
|
|
{
|
|
i--;
|
|
}
|
|
p++;
|
|
}
|
|
s.string[i] = L'\0';
|
|
s.length = i;
|
|
}
|
|
return s;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString& FString::overwrite (const FString& s, uInt pos)
|
|
{
|
|
if (length >= (pos + s.length))
|
|
{
|
|
wcsncpy(string + pos, s.string, s.length);
|
|
}
|
|
else
|
|
{
|
|
wcsncpy (string + pos, s.string, length - pos);
|
|
_insert (length, pos + s.length - length, s.string + length - pos);
|
|
}
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString& FString::overwrite (const wchar_t* s, uInt pos)
|
|
{
|
|
uInt len = uInt(wcslen(s));
|
|
if (length >= (pos+len) )
|
|
{
|
|
wcsncpy (string + pos, s, len);
|
|
}
|
|
else
|
|
{
|
|
wcsncpy (string + pos, s, length - pos);
|
|
_insert (length, pos + len - length, s + length - pos);
|
|
}
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString& FString::overwrite (const wchar_t c, uInt pos)
|
|
{
|
|
if ( length >= (pos+1) )
|
|
{
|
|
string[pos] = c;
|
|
}
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
const FString& FString::remove (uInt pos, uInt len)
|
|
{
|
|
assert ((pos < length) && ((pos + len) <= length));
|
|
_remove (pos, len);
|
|
return (*this);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
bool FString::includes (const FString& s)
|
|
{
|
|
return (wcsstr(string, s.string) != 0);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
bool FString::includes (const wchar_t* s)
|
|
{
|
|
return (wcsstr(string, s) != 0);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
bool FString::includes (const char* s)
|
|
{
|
|
bool ret;
|
|
const wchar_t* wc_str = c_to_wc_str(s);
|
|
if ( ! wc_str )
|
|
return false;
|
|
ret = bool(wcsstr(string, wc_str) != 0);
|
|
if ( *wc_str )
|
|
delete[] wc_str;
|
|
return (ret);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
bool FString::includes (const wchar_t c)
|
|
{
|
|
wchar_t s[2];
|
|
s[0] = c;
|
|
s[1] = L'\0';
|
|
return (wcsstr(string, s) != 0);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
bool FString::includes (const char c)
|
|
{
|
|
wchar_t s[2];
|
|
s[0] = wchar_t(c & 0xff);
|
|
s[1] = L'\0';
|
|
return (wcsstr(string, s) != 0);
|
|
}
|