/***********************************************************************
* fstring.cpp - Unicode string class with UTF-8 support *
* *
* This file is part of the Final Cut widget toolkit *
* *
* Copyright 2012-2018 Markus Gans *
* *
* The Final Cut is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Lesser General Public License *
* as published by the Free Software Foundation; either version 3 of *
* the License, or (at your option) any later version. *
* *
* The Final Cut is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with this program. If not, see *
* . *
***********************************************************************/
#include
#include
#include "final/fstring.h"
namespace finalcut
{
//----------------------------------------------------------------------
// class FString
//----------------------------------------------------------------------
// constructors and destructor
//----------------------------------------------------------------------
FString::FString (int len)
{
if ( len > 0 )
initLength(std::size_t(len));
else
initLength(0);
}
//----------------------------------------------------------------------
FString::FString (std::size_t len)
{
initLength(len);
}
//----------------------------------------------------------------------
FString::FString (std::size_t len, wchar_t c)
{
wchar_t* ps;
wchar_t* pe;
initLength(len);
ps = string;
pe = string + len;
while ( pe != ps )
*--pe = c;
}
//----------------------------------------------------------------------
FString::FString (const FString& s) // copy constructor
{
if ( ! s.isNull() )
_assign (s.string);
}
//----------------------------------------------------------------------
FString::FString (const std::wstring& s)
{
if ( ! s.empty() )
_assign (s.c_str());
}
//----------------------------------------------------------------------
FString::FString (const wchar_t s[])
{
if ( s )
_assign (s);
}
//----------------------------------------------------------------------
FString::FString (const std::string& s)
{
if ( ! s.empty() )
{
const wchar_t* wc_string = c_to_wc_str(s.c_str());
_assign(wc_string);
delete[] wc_string;
}
}
//----------------------------------------------------------------------
FString::FString (const char s[])
{
if ( s )
{
const wchar_t* wc_string = c_to_wc_str(s);
_assign( wc_string );
delete[] wc_string;
}
}
//----------------------------------------------------------------------
FString::FString (fc::SpecialCharacter c)
{
if ( c )
{
wchar_t s[2];
s[0] = static_cast(c);
s[1] = L'\0';
_assign (s);
}
}
//----------------------------------------------------------------------
FString::FString (const wchar_t c)
{
if ( c )
{
wchar_t s[2];
s[0] = c;
s[1] = L'\0';
_assign (s);
}
}
//----------------------------------------------------------------------
FString::FString (const char c)
{
if ( c )
{
wchar_t s[2];
s[0] = wchar_t(c & 0xff);
s[1] = L'\0';
_assign (s);
}
}
//----------------------------------------------------------------------
FString::~FString() // destructor
{
if ( string )
delete[](string);
if ( c_string )
delete[](c_string);
}
// FString operators
//----------------------------------------------------------------------
FString& FString::operator = (const FString& s)
{
_assign (s.string);
return *this;
}
//----------------------------------------------------------------------
const FString& FString::operator += (const FString& s)
{
_insert (length, s.length, s.string);
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 wchar_t c)
{
wchar_t s[2];
s[0] = c;
s[1] = L'\0';
FString tmp(string);
tmp._insert (length, 1, s);
return tmp;
}
//----------------------------------------------------------------------
const FString FString::operator + (const char c)
{
wchar_t s[2];
s[0] = wchar_t(c & 0xff);
s[1] = L'\0';
FString tmp(string);
tmp._insert (length, 1, s);
return tmp;
}
//----------------------------------------------------------------------
FString& FString::operator << (const FString& s)
{
_insert (length, s.length, s.string);
return *this;
}
//----------------------------------------------------------------------
FString& FString::operator << (fc::SpecialCharacter c)
{
FString s(static_cast(c));
_insert (length, s.length, s.string);
return *this;
}
//----------------------------------------------------------------------
FString& FString::operator << (const wchar_t c)
{
FString s(c);
_insert (length, s.length, s.string);
return *this;
}
//----------------------------------------------------------------------
FString& FString::operator << (const char c)
{
FString s(c);
_insert (length, s.length, s.string);
return *this;
}
//----------------------------------------------------------------------
FString& FString::operator << (const sInt16 num)
{
FString numstr = FString().setNumber(num);
_insert (length, numstr.length, numstr.string);
return *this;
}
//----------------------------------------------------------------------
FString& FString::operator << (const uInt16 num)
{
FString numstr = FString().setNumber(num);
_insert (length, numstr.length, numstr.string);
return *this;
}
//----------------------------------------------------------------------
FString& FString::operator << (const int num)
{
FString numstr = FString().setNumber(num);
_insert (length, numstr.length, numstr.string);
return *this;
}
//----------------------------------------------------------------------
FString& FString::operator << (const uInt num)
{
FString numstr = FString().setNumber(num);
_insert (length, numstr.length, numstr.string);
return *this;
}
//----------------------------------------------------------------------
FString& FString::operator << (const long num)
{
FString numstr = FString().setNumber(num);
_insert (length, numstr.length, numstr.string);
return *this;
}
//----------------------------------------------------------------------
FString& FString::operator << (const uLong num)
{
FString numstr = FString().setNumber(num);
_insert (length, numstr.length, numstr.string);
return *this;
}
//----------------------------------------------------------------------
FString& FString::operator << (const float num)
{
FString numstr = FString().setNumber(num);
_insert (length, numstr.length, numstr.string);
return *this;
}
//----------------------------------------------------------------------
FString& FString::operator << (const double num)
{
FString numstr = FString().setNumber(num);
_insert (length, numstr.length, numstr.string);
return *this;
}
//----------------------------------------------------------------------
FString& FString::operator << (const lDouble num)
{
FString numstr = FString().setNumber(num);
_insert (length, numstr.length, numstr.string);
return *this;
}
//----------------------------------------------------------------------
const FString& FString::operator >> (FString& s)
{
s._insert (s.length, length, string);
_assign(s.string);
return *this;
}
//----------------------------------------------------------------------
const FString& FString::operator >> (std::wstring& s)
{
s += std::wstring(string);
return *this;
}
//----------------------------------------------------------------------
const FString& FString::operator >> (std::string& s)
{
s += toString();
return *this;
}
//----------------------------------------------------------------------
const FString& FString::operator >> (wchar_t& c)
{
c = ( length > 0 ) ? string[0] : L'\0';
return *this;
}
//----------------------------------------------------------------------
const FString& FString::operator >> (char& c)
{
c = ( length > 0 ) ? char(string[0] & 0xff) : '\0';
return *this;
}
//----------------------------------------------------------------------
const FString& FString::operator >> (sInt16& num)
{
num = toShort();
return *this;
}
//----------------------------------------------------------------------
const FString& FString::operator >> (uInt16& num)
{
num = toUShort();
return *this;
}
//----------------------------------------------------------------------
const FString& FString::operator >> (int& num)
{
num = toInt();
return *this;
}
//----------------------------------------------------------------------
const FString& FString::operator >> (uInt& num)
{
num = toUInt();
return *this;
}
//----------------------------------------------------------------------
const FString& FString::operator >> (long& num)
{
num = toLong();
return *this;
}
//----------------------------------------------------------------------
const FString& FString::operator >> (uLong& num)
{
num = toULong();
return *this;
}
//----------------------------------------------------------------------
const FString& FString::operator >> (double& num)
{
num = toDouble();
return *this;
}
//----------------------------------------------------------------------
const FString& FString::operator >> (float& num)
{
num = toFloat();
return *this;
}
//----------------------------------------------------------------------
const FString& FString::operator () ()
{
return *this;
}
// public methods of FString
//----------------------------------------------------------------------
std::size_t FString::getUTF8length() const
{
std::size_t len;
const char* s;
if ( ! string )
return 0;
len = 0;
s = c_str();
while ( *s )
len += std::size_t((*s++ & 0xc0) != 0x80);
return len;
}
//----------------------------------------------------------------------
FString& FString::sprintf (const FString format, ...)
{
static constexpr int BUFSIZE = 4096;
wchar_t buffer[BUFSIZE];
va_list args;
if ( ! format )
{
clear();
return *this;
}
va_start (args, format);
std::vswprintf (buffer, BUFSIZE, format.wc_str(), args);
va_end (args);
_assign (buffer);
return *this;
}
//----------------------------------------------------------------------
FString FString::clear()
{
if ( string )
delete[](string);
length = 0;
bufsize = 0;
string = nullptr;
return *this;
}
//----------------------------------------------------------------------
const wchar_t* FString::wc_str() const
{
// Returns a constant wide character string
return string;
}
//----------------------------------------------------------------------
wchar_t* FString::wc_str()
{
// Returns a wide character string
return string;
}
//----------------------------------------------------------------------
const char* FString::c_str() const
{
// Returns a constant c-string
if ( length > 0 )
return wc_to_c_str (string);
else if ( string )
return const_cast("");
else
return 0;
}
//----------------------------------------------------------------------
char* FString::c_str()
{
// Returns a c-string
if ( length > 0 )
return wc_to_c_str (string);
else if ( string )
return const_cast("");
else
return 0;
}
//----------------------------------------------------------------------
const std::string FString::toString() const
{
return std::string(c_str(), length);
}
//----------------------------------------------------------------------
FString FString::toLower() const
{
wchar_t* p;
FString s(string);
p = s.string;
if ( p )
{
while ( *p )
{
*p = wchar_t(std::towlower(wint_t(*p)));
p++;
}
}
return s;
}
//----------------------------------------------------------------------
FString FString::toUpper() const
{
wchar_t* p;
FString s(string);
p = s.string;
if ( p )
{
while ( *p )
{
*p = wchar_t(std::towupper(wint_t(*p)));
p++;
}
}
return s;
}
//----------------------------------------------------------------------
sInt16 FString::toShort() const
{
long num;
num = toLong();
if ( num > SHRT_MAX )
throw std::overflow_error ("overflow");
if ( num < SHRT_MIN )
throw std::underflow_error ("underflow");
return sInt16(num);
}
//----------------------------------------------------------------------
uInt16 FString::toUShort() const
{
uLong num;
num = uLong(toULong());
if ( num > USHRT_MAX )
throw std::overflow_error ("overflow");
return uInt16(num);
}
//----------------------------------------------------------------------
int FString::toInt() const
{
long num;
num = toLong();
if ( num > INT_MAX )
throw std::overflow_error ("overflow");
if ( num < INT_MIN )
throw std::underflow_error ("underflow");
return int(num);
}
//----------------------------------------------------------------------
uInt FString::toUInt() const
{
uLong num;
num = uLong(toULong());
if ( num > UINT_MAX )
throw std::overflow_error ("overflow");
return uInt(num);
}
//----------------------------------------------------------------------
long FString::toLong() const
{
bool neg;
long num;
long tenth_limit;
long tenth_limit_digit;
wchar_t* p;
FString s;
neg = false;
num = 0;
tenth_limit = LONG_MAX / 10;
tenth_limit_digit = LONG_MAX % 10;
s = trim();
p = s.string;
if ( ! p )
throw std::invalid_argument ("null value");
if ( ! *p )
throw std::invalid_argument ("empty value");
if ( *p == L'-' )
{
p++;
neg = true;
tenth_limit = -(LONG_MIN / 10);
tenth_limit_digit += 1;
}
else if ( *p == L'+' )
{
p++;
}
while ( std::iswdigit(wint_t(*p)) )
{
uChar d = uChar((*p) - L'0');
if ( num > tenth_limit
|| (num == tenth_limit && d > tenth_limit_digit) )
{
if ( neg )
throw std::underflow_error ("underflow");
else
throw std::overflow_error ("overflow");
}
num = (num << 3) + (num << 1) + d; // (10 * num) + d
p++;
}
if ( *p != L'\0' && ! std::iswdigit(wint_t(*p)) )
throw std::invalid_argument ("no valid number");
if ( neg )
num = (~num) + 1;
return num;
}
//----------------------------------------------------------------------
uLong FString::toULong() const
{
uLong num;
uLong tenth_limit;
uLong tenth_limit_digit;
wchar_t* p;
FString s;
num = 0;
tenth_limit = ULONG_MAX / 10;
tenth_limit_digit = ULONG_MAX % 10;
s = trim();
p = s.string;
if ( ! p )
throw std::invalid_argument ("null value");
if ( ! *p )
throw std::invalid_argument ("empty value");
if ( *p == L'-' )
{
throw std::underflow_error ("underflow");
}
else if ( *p == L'+' )
{
p++;
}
while ( std::iswdigit(wint_t(*p)) )
{
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' && ! std::iswdigit(wint_t(*p)) )
throw std::invalid_argument ("no valid number");
return num;
}
//----------------------------------------------------------------------
float FString::toFloat() const
{
double num;
num = toDouble();
if ( num > double(FLT_MAX) || num < double(-FLT_MAX) )
throw std::overflow_error ("overflow");
if ( std::fabs(num) < double(FLT_EPSILON) ) // num == 0.0f
throw std::underflow_error ("underflow");
return float(num);
}
//----------------------------------------------------------------------
double FString::toDouble() const
{
wchar_t* p;
double ret;
if ( ! string )
throw std::invalid_argument ("null value");
if ( ! *string )
throw std::invalid_argument ("empty value");
ret = std::wcstod(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 ( std::fabs(ret) < DBL_EPSILON ) // ret == 0.0l
throw std::underflow_error ("underflow");
}
return ret;
}
//----------------------------------------------------------------------
FString FString::ltrim() const
{
wchar_t* p;
FString s(string);
// handle NULL and empty string
if ( ! (string && *string) )
return s;
p = s.string;
while ( std::iswspace(wint_t(*p)) )
p++;
return FString(p);
}
//----------------------------------------------------------------------
FString FString::rtrim() const
{
wchar_t* p;
wchar_t* last;
FString s(string);
// handle NULL and empty string
if ( ! (string && *string) )
return s;
p = s.string;
last = p + length;
while ( std::iswspace(wint_t(*--last)) && last > p )
s.length--;
if ( last == p && std::iswspace(wint_t(*last)) )
s = L"";
else
*(last + 1) = '\0';
return s;
}
//----------------------------------------------------------------------
FString FString::trim() const
{
// handle NULL and empty string
if ( ! (string && *string) )
return *this;
FString s(ltrim());
return s.rtrim();
}
//----------------------------------------------------------------------
FString FString::left (std::size_t len) const
{
wchar_t* p;
FString s(string);
// handle NULL and empty string
if ( ! (string && *string) )
return s;
if ( len > length )
return s;
p = s.string;
s.length = len;
*(p + len) = '\0';
return s;
}
//----------------------------------------------------------------------
FString FString::right (std::size_t len) const
{
wchar_t* p;
FString s(string);
// handle NULL and empty string
if ( ! (string && *string) )
return s;
if ( len > length )
return s;
p = s.string;
p += (length - len);
return FString(p);
}
//----------------------------------------------------------------------
FString FString::mid (std::size_t pos, std::size_t len) const
{
wchar_t* p;
wchar_t* first;
FString s(string);
// handle NULL and empty string
if ( ! (string && *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);
}
//----------------------------------------------------------------------
FStringList FString::split (const FString& delimiter)
{
wchar_t* rest;
wchar_t* token;
FString s(string);
FStringList string_list;
// handle NULL and empty string
if ( ! (string && *string) )
return string_list;
rest = nullptr;
token = extractToken(&rest, s.string, delimiter.wc_str());
while ( token )
{
string_list.push_back (FString(token));
token = extractToken (&rest, 0, delimiter.wc_str());
}
return string_list;
}
//----------------------------------------------------------------------
FString& FString::setString (const FString& s)
{
_assign (s.string);
return *this;
}
//----------------------------------------------------------------------
FString& FString::setNumber (sInt64 num)
{
wchar_t* s;
bool neg;
wchar_t buf[30];
s = &buf[29];
if ( num < 0 )
{
neg = true;
num = -num;
}
else
{
neg = false;
}
*s = '\0';
do
{
*--s = L"0123456789"[num % 10];
num /= 10;
}
while ( num );
if ( neg )
*--s = '-';
_assign (s);
return *this;
}
//----------------------------------------------------------------------
FString& FString::setNumber (uInt64 num)
{
wchar_t* s;
wchar_t buf[30];
s = &buf[29];
*s = '\0';
do
{
*--s = L"0123456789"[num % 10];
num /= 10;
}
while ( num );
_assign (s);
return *this;
}
//----------------------------------------------------------------------
FString& FString::setNumber (lDouble f_num, int precision)
{
wchar_t* s;
wchar_t format[20]; // = "%.Lg"
s = &format[0];
*s++ = L'%';
*s++ = L'.';
// The precision can not have more than 2 digits
if ( precision > 99 )
precision = 99;
if ( precision >= 10 )
{
// The precision value is 2 digits long
*s++ = precision / 10 + L'0';
*s++ = precision % 10 + L'0';
}
else
{
// The precision value has only 1 digit
*s++ = precision + L'0';
}
*s++ = L'L';
*s++ = L'g';
*s = L'\0';
return sprintf(format, f_num);
}
//----------------------------------------------------------------------
FString& FString::setFormatedNumber (sInt64 num, char separator)
{
int n;
wchar_t* s;
bool neg;
wchar_t buf[30];
n = 0;
s = &buf[29];
if ( separator == 0 )
separator = ' ';
if ( num < 0 )
{
neg = true;
num = -num;
}
else
{
neg = false;
}
*s = L'\0';
do
{
*--s = L"0123456789"[num % 10];
num /= 10;
if ( num && ++n % 3 == 0 )
*--s = separator;
}
while ( num );
if ( neg )
*--s = '-';
_assign (s);
return *this;
}
//----------------------------------------------------------------------
FString& FString::setFormatedNumber (uInt64 num, char separator)
{
int n;
wchar_t* s;
wchar_t buf[30];
n = 0;
s = &buf[29];
*s = L'\0';
if ( separator == 0 )
separator = ' ';
do
{
*--s = L"0123456789"[num % 10];
num /= 10;
if ( num && ++n % 3 == 0 )
*--s = separator;
}
while ( num );
_assign (s);
return *this;
}
// FString operators
//----------------------------------------------------------------------
bool FString::operator < (const FString& s) const
{
if ( string && ! s.string )
return false;
if ( ! string && s.string )
return true;
if ( ! (string || s.string) )
return false;
return ( std::wcscmp(string, s.string) < 0 );
}
//----------------------------------------------------------------------
bool FString::operator <= (const FString& s) const
{
if ( ! (string || s.string) )
return true;
if ( string && ! s.string )
return false;
if ( ! string && s.string )
return true;
return ( std::wcscmp(string, s.string) <= 0 );
}
//----------------------------------------------------------------------
bool FString::operator == (const FString& s) const
{
if ( ! (string || s.string) )
return true;
if ( bool(string) != bool(s.string) )
return false;
return ( std::wcscmp(string, s.string) == 0 );
}
//----------------------------------------------------------------------
bool FString::operator != (const FString& s) const
{
if ( ! (string || s.string) )
return false;
if ( bool(string) != bool(s.string) )
return true;
return ( std::wcscmp(string, s.string) != 0 );
}
//----------------------------------------------------------------------
bool FString::operator >= (const FString& s) const
{
if ( string && ! s.string )
return true;
if ( ! string && s.string )
return false;
if ( ! (string || s.string) )
return true;
return ( std::wcscmp(string, s.string) >= 0 );
}
//----------------------------------------------------------------------
bool FString::operator > (const FString& s) const
{
if ( ! (string || s.string) )
return false;
if ( string && ! s.string )
return true;
if ( ! string && s.string )
return false;
return ( std::wcscmp(string, s.string) > 0 );
}
//----------------------------------------------------------------------
const FString& FString::insert (const FString& s, int pos)
{
if ( isNegative(pos) || uInt(pos) > length )
throw std::out_of_range("");
_insert (uInt(pos), s.length, s.string);
return *this;
}
//----------------------------------------------------------------------
const FString& FString::insert (const FString& s, std::size_t pos)
{
if ( pos > length )
throw std::out_of_range("");
_insert (pos, s.length, s.string);
return *this;
}
//----------------------------------------------------------------------
FString FString::replace (const FString& from, const FString& to)
{
wchar_t* p;
std::size_t from_length, to_length, pos;
FString s(string);
// handle NULL and empty string
if ( ! (string && *string) )
return s;
if ( from.isNull() || to.isNull() )
return s;
if ( from.isEmpty() )
return s;
p = s.string;
from_length = from.getLength();
to_length = to.getLength();
pos = 0;
while ( *p )
{
if ( std::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::replaceControlCodes() const
{
wchar_t* p;
FString s(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 ( ! std::iswprint(wint_t(*p)) )
*p = L' ';
p++;
}
}
return s;
}
//----------------------------------------------------------------------
FString FString::expandTabs (int tabstop) const
{
uLong last;
FStringList tab_split;
FString instr(string);
FString outstr;
if ( tabstop <= 0 )
return instr;
tab_split = instr.split("\t");
last = tab_split.size();
for (std::size_t i = 0; i < last; i++)
{
std::size_t len = tab_split[i].getLength();
std::size_t tab_len = std::size_t(tabstop);
if ( i == last - 1 )
outstr += tab_split[i];
else
outstr += tab_split[i] + FString(tab_len - (len % tab_len), L' ');
}
return outstr;
}
//----------------------------------------------------------------------
FString FString::removeDel() const
{
wchar_t* p;
FString s(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
{
wchar_t* p;
FString s(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, int pos)
{
if ( pos < 0 )
return overwrite (s, 0);
return overwrite (s, std::size_t(pos));
}
//----------------------------------------------------------------------
const FString& FString::overwrite (const FString& s, std::size_t pos)
{
if ( pos > length )
pos = length;
if ( length >= (pos + s.length) )
{
std::wcsncpy (string + pos, s.string, s.length);
}
else
{
std::wcsncpy (string + pos, s.string, length - pos);
_insert (length, pos + s.length - length, s.string + length - pos);
}
return *this;
}
//----------------------------------------------------------------------
const FString& FString::remove (std::size_t pos, std::size_t len)
{
if ( pos > length )
return *this;
if ( pos + len > length )
len = length - pos;
_remove (pos, len);
return *this;
}
//----------------------------------------------------------------------
bool FString::includes (const FString& s) const
{
if ( ! s )
return false;
if ( ! (string && s.string) )
return false;
return ( std::wcsstr(string, s.string) != 0 );
}
// private methods of FString
//----------------------------------------------------------------------
inline void FString::initLength (std::size_t len)
{
if ( len == 0 )
return;
length = len;
bufsize = FWDBUFFER + len + 1;
try
{
string = new wchar_t[bufsize]();
std::wmemset (string, L'\0', bufsize);
}
catch (const std::bad_alloc& ex)
{
std::cerr << bad_alloc_str << ex.what() << std::endl;
}
}
//----------------------------------------------------------------------
inline void FString::_assign (const wchar_t s[])
{
if ( ! s )
{
clear();
return;
}
if ( string && std::wcscmp(string, s) == 0 )
return; // string == s
uInt new_length = uInt(std::wcslen(s));
if ( ! string || new_length > capacity() )
{
if ( string )
delete[](string);
bufsize = FWDBUFFER + new_length + 1;
try
{
string = new wchar_t[bufsize]();
}
catch (const std::bad_alloc& ex)
{
std::cerr << bad_alloc_str << ex.what() << std::endl;
return;
}
}
std::wcsncpy (string, s, bufsize);
length = new_length;
string[capacity()] = L'\0';
}
//----------------------------------------------------------------------
inline void FString::_insert (std::size_t len, const wchar_t s[])
{
if ( len == 0 ) // String s is a null or a empty string
return;
if ( string )
delete[](string);
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;
}
std::wcsncpy (string, s, bufsize);
string[capacity()] = L'\0';
}
//----------------------------------------------------------------------
inline void FString::_insert ( std::size_t pos
, std::size_t len
, const wchar_t s[] )
{
if ( len == 0 ) // String s is a null or a empty string
return;
if ( ! string ) // string is null
{
_insert (len, s);
}
else
{
std::size_t x;
if ( length + len <= capacity() )
{
// output string <= bufsize
for (x = length; x + 1 > pos; x--) // shifting right side + '\0'
string[x + len] = string[x];
for (x = 0; x < len; x++) // insert string
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](); // generate new string
}
catch (const std::bad_alloc& ex)
{
std::cerr << bad_alloc_str << " " << ex.what() << std::endl;
return;
}
std::size_t y = 0;
for (x = 0; x < pos; x++) // left side
sptr[y++] = string[x];
for (x = 0 ; x < len; x++) // insert string
sptr[y++] = s[x];
for (x = pos; x < length + 1; x++) // right side + '\0'
sptr[y++] = string[x];
length += len;
delete[](string); // delete old string
string = sptr;
}
}
}
//----------------------------------------------------------------------
inline void FString::_remove (std::size_t pos, std::size_t len)
{
if ( capacity() - length + len <= FWDBUFFER )
{
// shifting left side to pos
for (std::size_t i = pos; i + len < length + 1; i++)
string[i] = string[i + len];
length -= len;
}
else
{
wchar_t* sptr;
bufsize = length + 1 - len + FWDBUFFER;
try
{
sptr = new wchar_t[bufsize](); // generate new string
}
catch (const std::bad_alloc& ex)
{
std::cerr << bad_alloc_str << " " << ex.what() << std::endl;
return;
}
std::size_t x, y = 0;
for (x = 0; x < pos; x++) // left side
sptr[y++] = string[x];
for (x = pos + len; x < length + 1; x++) // right side + '\0'
sptr[y++] = string[x];
delete[](string); // delete old 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
{
try
{
// Generate a empty string ("")
c_string = new char[1]();
}
catch (const std::bad_alloc& ex)
{
std::cerr << bad_alloc_str << " " << ex.what() << std::endl;
return 0;
}
return c_string;
}
if ( c_string )
delete[](c_string);
size = int(std::wcslen(s)) + 1;
dest_size = size * int(CHAR_SIZE);
src = s;
std::mbstate_t state;
std::memset (&state, '\0', sizeof(mbstate_t));
try
{
c_string = new char[std::size_t(dest_size)]();
// pre-initialiaze the whole string with '\0'
std::memset (c_string, '\0', std::size_t(dest_size));
}
catch (const std::bad_alloc& ex)
{
std::cerr << bad_alloc_str << " " << ex.what() << std::endl;
return 0;
}
mblength = int(std::wcsrtombs (c_string, &src, std::size_t(dest_size), &state));
if ( mblength == -1 && errno != EILSEQ )
{
delete[](c_string);
c_string = nullptr;
return const_cast("");
}
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
{
try
{
// Generate a empty wide string (L"")
return new wchar_t[1]();
}
catch (const std::bad_alloc& ex)
{
std::cerr << bad_alloc_str << " " << ex.what() << std::endl;
return 0;
}
}
size = int(std::strlen(s)) + 1;
dest_size = size * int(CHAR_SIZE);
src = s;
std::mbstate_t state;
std::memset (&state, '\0', sizeof(mbstate_t));
try
{
dest = new wchar_t[std::size_t(size)]();
// pre-initialiaze the whole string with '\0'
std::wmemset (dest, L'\0', std::size_t(size));
}
catch (const std::bad_alloc& ex)
{
std::cerr << bad_alloc_str << " " << ex.what() << std::endl;
return 0;
}
wclength = int(std::mbsrtowcs (dest, &src, std::size_t(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[] )
{
wchar_t* token;
token = ( s ) ? const_cast(s) : *rest;
if ( ! token )
return 0;
if ( ! token[0] )
return 0;
*rest = std::wcspbrk(token, delim);
if ( *rest )
*(*rest)++ = '\0';
else
*rest = token + std::wcslen(token);
return token;
}
// FString non-member operators
//----------------------------------------------------------------------
const FString operator + (const FString& s1, const FString& s2)
{
FString tmp(s1);
tmp._insert ( uInt(std::wcslen(s1.wc_str()))
, uInt(std::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(std::wcslen(s.wc_str())), 1, &c);
return tmp;
}
//----------------------------------------------------------------------
const FString operator + (const std::wstring& s1, const FString& s2)
{
FString tmp(s1);
tmp._insert ( uInt(std::wcslen(s1.c_str()))
, uInt(std::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(std::wcslen(s1))
, uInt(std::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(std::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(std::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(std::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(std::wcslen(s.wc_str())), s.wc_str());
return tmp;
}
//----------------------------------------------------------------------
const FString operator + (const FString& s, const char c)
{
FString tmp1(s);
wchar_t tmp2[2];
tmp2[0] = wchar_t(c & 0xff);
tmp2[1] = L'\0';
tmp1._insert (s.length, 1, tmp2);
return tmp1;
}
//----------------------------------------------------------------------
std::ostream& operator << (std::ostream& outstr, const FString& s)
{
if ( s.length > 0 )
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[FString::INPBUFFER + 1];
instr.getline (buf, FString::INPBUFFER);
wc_str = s.c_to_wc_str(buf);
if ( wc_str )
{
s._assign (wc_str);
delete[] wc_str;
}
return instr;
}
//----------------------------------------------------------------------
std::wostream& operator << (std::wostream& outstr, const FString& s)
{
if ( s.length > 0 )
outstr << s.string;
return outstr;
}
//----------------------------------------------------------------------
std::wistream& operator >> (std::wistream& instr, FString& s)
{
wchar_t buf[FString::INPBUFFER + 1];
instr.getline (buf, FString::INPBUFFER);
s._assign (buf);
return instr;
}
} // namespace finalcut