mirror of
https://git.dev.opencascade.org/repos/occt.git
synced 2025-04-07 18:30:55 +03:00
fb73c3b712
Clang-tidy applying rule for cppcoreguidelines-pro-type-member-init. Updated: TKernel and TKMath Update constructor in some classes instead of direct initialization Refactor Bnd_BoundSortBox and Bnd_Box constructors to initialize member variables directly
993 lines
31 KiB
C++
993 lines
31 KiB
C++
// Copyright (c) 1993-1999 Matra Datavision
|
|
// Copyright (c) 1999-2014 OPEN CASCADE SAS
|
|
//
|
|
// This file is part of Open CASCADE Technology software library.
|
|
//
|
|
// This library is free software; you can redistribute it and/or modify it under
|
|
// the terms of the GNU Lesser General Public License version 2.1 as published
|
|
// by the Free Software Foundation, with special exception defined in the file
|
|
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
|
|
// distribution for complete text of the license and disclaimer of any warranty.
|
|
//
|
|
// Alternatively, this file may be used under the terms of Open CASCADE
|
|
// commercial license or contractual agreement.
|
|
|
|
#include <TCollection_ExtendedString.hxx>
|
|
|
|
#include <NCollection_UtfIterator.hxx>
|
|
#include <Standard.hxx>
|
|
#include <Standard_NullObject.hxx>
|
|
#include <TCollection_AsciiString.hxx>
|
|
|
|
#include <algorithm>
|
|
|
|
namespace
|
|
{
|
|
static Standard_ExtCharacter THE_DEFAULT_EXT_CHAR_STRING[1] = {0};
|
|
|
|
//! Returns the number of 16-bit code units in Unicode string
|
|
template <typename T>
|
|
static Standard_Integer nbSymbols(const T* theUtfString)
|
|
{
|
|
Standard_Integer aNbCodeUnits = 0;
|
|
for (NCollection_UtfIterator<T> anIter(theUtfString); *anIter != 0; ++anIter)
|
|
{
|
|
aNbCodeUnits += anIter.AdvanceCodeUnitsUtf16();
|
|
}
|
|
return aNbCodeUnits;
|
|
}
|
|
|
|
//! Convert from wchar_t* to extended string.
|
|
//! Default implementation when size of wchar_t and extended char is different (e.g. Linux / UNIX).
|
|
template <size_t CharSize>
|
|
inline Standard_ExtCharacter* Standard_UNUSED fromWideString(const Standard_WideChar* theUtfString,
|
|
Standard_Integer& theLength)
|
|
{
|
|
theLength = nbSymbols(theUtfString);
|
|
if (theLength == 0)
|
|
{
|
|
return THE_DEFAULT_EXT_CHAR_STRING;
|
|
}
|
|
const Standard_Size aRoundSize = (((theLength + 1) * sizeof(Standard_ExtCharacter)) + 3) & ~0x3;
|
|
Standard_ExtCharacter* aString =
|
|
static_cast<Standard_PExtCharacter>(Standard::AllocateOptimal(aRoundSize));
|
|
NCollection_UtfWideIter anIterRead(theUtfString);
|
|
for (Standard_ExtCharacter* anIterWrite = aString; *anIterRead != 0; ++anIterRead)
|
|
{
|
|
anIterWrite = anIterRead.GetUtf(anIterWrite);
|
|
}
|
|
aString[theLength] = 0;
|
|
return aString;
|
|
}
|
|
|
|
//! Use memcpy() conversion when size is the same (e.g. on Windows).
|
|
template <>
|
|
inline Standard_ExtCharacter* Standard_UNUSED
|
|
fromWideString<sizeof(Standard_ExtCharacter)>(const Standard_WideChar* theUtfString,
|
|
Standard_Integer& theLength)
|
|
{
|
|
for (theLength = 0; theUtfString[theLength] != 0; ++theLength)
|
|
{
|
|
}
|
|
if (theLength == 0)
|
|
{
|
|
return THE_DEFAULT_EXT_CHAR_STRING;
|
|
}
|
|
const Standard_Size aRoundSize = (((theLength + 1) * sizeof(Standard_ExtCharacter)) + 3) & ~0x3;
|
|
Standard_ExtCharacter* aString =
|
|
static_cast<Standard_PExtCharacter>(Standard::AllocateOptimal(aRoundSize));
|
|
const Standard_Integer aSize = theLength * sizeof(Standard_ExtCharacter);
|
|
memcpy(aString, theUtfString, aSize);
|
|
aString[theLength] = 0;
|
|
return aString;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Create an empty ExtendedString
|
|
// ----------------------------------------------------------------------------
|
|
TCollection_ExtendedString::TCollection_ExtendedString()
|
|
{
|
|
allocate(0);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Create an ExtendedString from a Standard_CString
|
|
//----------------------------------------------------------------------------
|
|
TCollection_ExtendedString::TCollection_ExtendedString(const Standard_CString theString,
|
|
const Standard_Boolean isMultiByte)
|
|
{
|
|
if (theString == NULL)
|
|
{
|
|
throw Standard_NullObject("TCollection_ExtendedString : null parameter ");
|
|
}
|
|
|
|
if (isMultiByte)
|
|
{
|
|
allocate(nbSymbols(theString));
|
|
mystring[mylength] = 0;
|
|
if (ConvertToUnicode(theString))
|
|
{
|
|
return;
|
|
}
|
|
reallocate((int)strlen(theString));
|
|
}
|
|
else
|
|
{
|
|
allocate((int)strlen(theString));
|
|
}
|
|
for (int aCharIter = 0; aCharIter < mylength; ++aCharIter)
|
|
{
|
|
mystring[aCharIter] = ToExtCharacter(theString[aCharIter]);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Create an ExtendedString from an ExtString
|
|
//--------------------------------------------------------------------------
|
|
TCollection_ExtendedString::TCollection_ExtendedString(const Standard_ExtString theString)
|
|
{
|
|
if (theString == NULL)
|
|
{
|
|
throw Standard_NullObject("TCollection_ExtendedString : null parameter ");
|
|
}
|
|
|
|
for (mylength = 0; theString[mylength] != 0; ++mylength)
|
|
{
|
|
}
|
|
allocate(mylength);
|
|
memcpy(mystring, theString, mylength * sizeof(Standard_ExtCharacter));
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// TCollection_ExtendedString
|
|
// ----------------------------------------------------------------------------
|
|
TCollection_ExtendedString::TCollection_ExtendedString(const Standard_WideChar* theStringUtf)
|
|
{
|
|
if (theStringUtf == NULL)
|
|
{
|
|
throw Standard_NullObject("TCollection_ExtendedString : null parameter ");
|
|
}
|
|
|
|
mystring = fromWideString<sizeof(Standard_WideChar)>(theStringUtf, mylength);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Create an asciistring from a Standard_Character
|
|
// ----------------------------------------------------------------------------
|
|
TCollection_ExtendedString::TCollection_ExtendedString(const Standard_Character aChar)
|
|
{
|
|
if (aChar != '\0')
|
|
{
|
|
allocate(1);
|
|
mystring[0] = ToExtCharacter(aChar);
|
|
}
|
|
else
|
|
{
|
|
allocate(0);
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Create a string from a ExtCharacter
|
|
// ----------------------------------------------------------------------------
|
|
TCollection_ExtendedString::TCollection_ExtendedString(const Standard_ExtCharacter aChar)
|
|
{
|
|
allocate(1);
|
|
mystring[0] = aChar;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Create an AsciiString from a filler
|
|
// ----------------------------------------------------------------------------
|
|
TCollection_ExtendedString::TCollection_ExtendedString(const Standard_Integer length,
|
|
const Standard_ExtCharacter filler)
|
|
{
|
|
allocate(length);
|
|
for (int i = 0; i < length; i++)
|
|
mystring[i] = filler;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Create a String from an Integer
|
|
// ----------------------------------------------------------------------------
|
|
TCollection_ExtendedString::TCollection_ExtendedString(const Standard_Integer aValue)
|
|
{
|
|
union {
|
|
int bid;
|
|
char t[13];
|
|
} CHN{};
|
|
|
|
Sprintf(&CHN.t[0], "%d", aValue);
|
|
allocate((int)strlen(CHN.t));
|
|
for (int i = 0; i < mylength; i++)
|
|
mystring[i] = ToExtCharacter(CHN.t[i]);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Create a String from a real
|
|
// ----------------------------------------------------------------------------
|
|
TCollection_ExtendedString::TCollection_ExtendedString(const Standard_Real aValue)
|
|
{
|
|
union {
|
|
int bid;
|
|
char t[50];
|
|
} CHN{};
|
|
|
|
Sprintf(&CHN.t[0], "%g", aValue);
|
|
allocate((int)strlen(CHN.t));
|
|
for (int i = 0; i < mylength; i++)
|
|
mystring[i] = ToExtCharacter(CHN.t[i]);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// create an extendedstring from an extendedstring
|
|
// ----------------------------------------------------------------------------
|
|
TCollection_ExtendedString::TCollection_ExtendedString(const TCollection_ExtendedString& theOther)
|
|
{
|
|
allocate(theOther.mylength);
|
|
memcpy(mystring, theOther.mystring, mylength * sizeof(Standard_ExtCharacter));
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
TCollection_ExtendedString::TCollection_ExtendedString(
|
|
TCollection_ExtendedString&& theOther) noexcept
|
|
{
|
|
if (theOther.mystring == THE_DEFAULT_EXT_CHAR_STRING)
|
|
{
|
|
allocate(0);
|
|
}
|
|
else
|
|
{
|
|
mystring = theOther.mystring;
|
|
mylength = theOther.mylength;
|
|
}
|
|
theOther.mystring = THE_DEFAULT_EXT_CHAR_STRING;
|
|
theOther.mylength = 0;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
// Create an extendedstring from an AsciiString
|
|
//---------------------------------------------------------------------------
|
|
TCollection_ExtendedString::TCollection_ExtendedString(const TCollection_AsciiString& theString,
|
|
const Standard_Boolean isMultiByte)
|
|
{
|
|
allocate(nbSymbols(theString.ToCString()));
|
|
if (isMultiByte && ConvertToUnicode(theString.ToCString()))
|
|
{
|
|
return;
|
|
}
|
|
reallocate(theString.Length());
|
|
Standard_CString aCString = theString.ToCString();
|
|
for (Standard_Integer aCharIter = 0; aCharIter <= mylength; ++aCharIter)
|
|
{
|
|
mystring[aCharIter] = ToExtCharacter(aCString[aCharIter]);
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// AssignCat
|
|
// ----------------------------------------------------------------------------
|
|
void TCollection_ExtendedString::AssignCat(const TCollection_ExtendedString& theOther)
|
|
{
|
|
if (theOther.mylength == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const Standard_Integer anOtherLength = theOther.mylength;
|
|
const Standard_Integer anOldLength = mylength;
|
|
reallocate(mylength + anOtherLength);
|
|
memcpy(mystring + anOldLength, theOther.mystring, anOtherLength * sizeof(Standard_ExtCharacter));
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// AssignCat
|
|
// ----------------------------------------------------------------------------
|
|
void TCollection_ExtendedString::AssignCat(const Standard_Utf16Char theChar)
|
|
{
|
|
if (theChar != '\0')
|
|
{
|
|
reallocate(mylength + 1);
|
|
mystring[mylength - 1] = theChar;
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Cat
|
|
// ----------------------------------------------------------------------------
|
|
TCollection_ExtendedString TCollection_ExtendedString::Cat(
|
|
const TCollection_ExtendedString& other) const
|
|
{
|
|
TCollection_ExtendedString res(mylength + other.mylength, 0);
|
|
if (mylength > 0)
|
|
memcpy(res.mystring, mystring, mylength * sizeof(Standard_ExtCharacter));
|
|
if (other.mylength > 0)
|
|
memcpy(res.mystring + mylength, other.mystring, other.mylength * sizeof(Standard_ExtCharacter));
|
|
return res;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// ChangeAll
|
|
// ----------------------------------------------------------------------------
|
|
void TCollection_ExtendedString::ChangeAll(const Standard_ExtCharacter aChar,
|
|
const Standard_ExtCharacter NewChar)
|
|
{
|
|
for (int i = 0; i < mylength; i++)
|
|
if (mystring[i] == aChar)
|
|
mystring[i] = NewChar;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Clear
|
|
// ----------------------------------------------------------------------------
|
|
void TCollection_ExtendedString::Clear()
|
|
{
|
|
deallocate();
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Copy
|
|
// ----------------------------------------------------------------------------
|
|
void TCollection_ExtendedString::Copy(const TCollection_ExtendedString& fromwhere)
|
|
{
|
|
if (&fromwhere == this)
|
|
{
|
|
return;
|
|
}
|
|
if (fromwhere.mystring && fromwhere.mylength > 0)
|
|
{
|
|
reallocate(fromwhere.mylength);
|
|
memcpy(mystring, fromwhere.mystring, mylength * sizeof(Standard_ExtCharacter));
|
|
}
|
|
else if (mystring != THE_DEFAULT_EXT_CHAR_STRING)
|
|
{
|
|
mylength = 0;
|
|
mystring[mylength] = 0;
|
|
}
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
void TCollection_ExtendedString::Move(TCollection_ExtendedString&& theOther)
|
|
{
|
|
if (&theOther == this)
|
|
{
|
|
return;
|
|
}
|
|
if (theOther.mystring == THE_DEFAULT_EXT_CHAR_STRING)
|
|
{
|
|
reallocate(0);
|
|
}
|
|
else
|
|
{
|
|
if (mystring != THE_DEFAULT_EXT_CHAR_STRING)
|
|
{
|
|
Standard::Free(mystring);
|
|
}
|
|
mystring = theOther.mystring;
|
|
mylength = theOther.mylength;
|
|
}
|
|
theOther.mystring = THE_DEFAULT_EXT_CHAR_STRING;
|
|
theOther.mylength = 0;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Swap
|
|
// ----------------------------------------------------------------------------
|
|
void TCollection_ExtendedString::Swap(TCollection_ExtendedString& theOther)
|
|
{
|
|
if (&theOther == this)
|
|
{
|
|
return;
|
|
}
|
|
std::swap(mystring, theOther.mystring);
|
|
std::swap(mylength, theOther.mylength);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Destroy
|
|
// ----------------------------------------------------------------------------
|
|
TCollection_ExtendedString::~TCollection_ExtendedString()
|
|
{
|
|
deallocate();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Insert a character before 'where'th character
|
|
// ----------------------------------------------------------------------------
|
|
void TCollection_ExtendedString::Insert(const Standard_Integer where,
|
|
const Standard_ExtCharacter what)
|
|
{
|
|
if (where > mylength + 1)
|
|
throw Standard_OutOfRange("TCollection_ExtendedString::Insert : "
|
|
"Parameter where is too big");
|
|
if (where < 0)
|
|
throw Standard_OutOfRange("TCollection_ExtendedString::Insert : "
|
|
"Parameter where is negative");
|
|
reallocate(mylength + 1);
|
|
if (where != mylength)
|
|
{
|
|
for (int i = mylength - 2; i >= where - 1; i--)
|
|
mystring[i + 1] = mystring[i];
|
|
}
|
|
mystring[where - 1] = what;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Insert
|
|
// ----------------------------------------------------------------------------
|
|
void TCollection_ExtendedString::Insert(const Standard_Integer where,
|
|
const TCollection_ExtendedString& what)
|
|
{
|
|
Standard_ExtString swhat = what.mystring;
|
|
if (where <= mylength + 1)
|
|
{
|
|
Standard_Integer whatlength = what.mylength;
|
|
if (whatlength)
|
|
{
|
|
const int anOldLength = mylength;
|
|
reallocate(mylength + whatlength);
|
|
if (where != anOldLength + 1)
|
|
{
|
|
for (int i = anOldLength - 1; i >= where - 1; i--)
|
|
mystring[i + whatlength] = mystring[i];
|
|
}
|
|
for (int i = 0; i < whatlength; i++)
|
|
mystring[where - 1 + i] = swhat[i];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
throw Standard_OutOfRange("TCollection_ExtendedString::Insert : "
|
|
"Parameter where is too big");
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// ExtStrCmp: strcmp for 16-bit chars
|
|
// ----------------------------------------------------------------------------
|
|
static int ExtStrCmp(const Standard_ExtString theStr1, const Standard_ExtString theStr2)
|
|
{
|
|
const Standard_ExtCharacter* aStr1 = theStr1;
|
|
const Standard_ExtCharacter* aStr2 = theStr2;
|
|
while (*aStr1 != 0 && *aStr1 == *aStr2)
|
|
{
|
|
aStr1++;
|
|
aStr2++;
|
|
}
|
|
// Standard_ExtCharacter is char16_t which is 2-byte unsigned int, it will be promoted
|
|
// to plain 4-byte int for calculation
|
|
return *aStr1 - *aStr2;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// IsEqual
|
|
// ----------------------------------------------------------------------------
|
|
Standard_Boolean TCollection_ExtendedString::IsEqual(const Standard_ExtString other) const
|
|
{
|
|
return ExtStrCmp(mystring, other) == 0;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// IsEqual
|
|
// ----------------------------------------------------------------------------
|
|
Standard_Boolean TCollection_ExtendedString::IsEqual(const TCollection_ExtendedString& other) const
|
|
{
|
|
return mylength == other.mylength
|
|
&& memcmp(mystring, other.mystring, (mylength + 1) * sizeof(Standard_ExtCharacter)) == 0;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// IsDifferent
|
|
// ----------------------------------------------------------------------------
|
|
Standard_Boolean TCollection_ExtendedString::IsDifferent(const Standard_ExtString other) const
|
|
{
|
|
return ExtStrCmp(mystring, other) != 0;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// IsDifferent
|
|
// ----------------------------------------------------------------------------
|
|
Standard_Boolean TCollection_ExtendedString::IsDifferent(
|
|
const TCollection_ExtendedString& other) const
|
|
{
|
|
return mylength != other.mylength
|
|
|| memcmp(mystring, other.mystring, (mylength + 1) * sizeof(Standard_ExtCharacter)) != 0;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// IsLess
|
|
// ----------------------------------------------------------------------------
|
|
Standard_Boolean TCollection_ExtendedString::IsLess(const Standard_ExtString other) const
|
|
{
|
|
return ExtStrCmp(mystring, other) < 0;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// IsLess
|
|
// ----------------------------------------------------------------------------
|
|
Standard_Boolean TCollection_ExtendedString::IsLess(const TCollection_ExtendedString& other) const
|
|
{
|
|
return ExtStrCmp(mystring, other.mystring) < 0;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// IsGreater
|
|
// ----------------------------------------------------------------------------
|
|
Standard_Boolean TCollection_ExtendedString::IsGreater(const Standard_ExtString other) const
|
|
{
|
|
return ExtStrCmp(mystring, other) > 0;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// IsGreater
|
|
// ----------------------------------------------------------------------------
|
|
Standard_Boolean TCollection_ExtendedString::IsGreater(
|
|
const TCollection_ExtendedString& other) const
|
|
{
|
|
return ExtStrCmp(mystring, other.mystring) > 0;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// StartsWith
|
|
// ----------------------------------------------------------------------------
|
|
Standard_Boolean TCollection_ExtendedString::StartsWith(
|
|
const TCollection_ExtendedString& theStartString) const
|
|
{
|
|
if (this == &theStartString)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return mylength >= theStartString.mylength
|
|
&& memcmp(theStartString.mystring,
|
|
mystring,
|
|
theStartString.mylength * sizeof(Standard_ExtCharacter))
|
|
== 0;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// EndsWith
|
|
// ----------------------------------------------------------------------------
|
|
Standard_Boolean TCollection_ExtendedString::EndsWith(
|
|
const TCollection_ExtendedString& theEndString) const
|
|
{
|
|
if (this == &theEndString)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return mylength >= theEndString.mylength
|
|
&& memcmp(theEndString.mystring,
|
|
mystring + mylength - theEndString.mylength,
|
|
theEndString.mylength * sizeof(Standard_ExtCharacter))
|
|
== 0;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// IsAscii
|
|
// ----------------------------------------------------------------------------
|
|
Standard_Boolean TCollection_ExtendedString::IsAscii() const
|
|
{
|
|
for (Standard_Integer i = 0; i < mylength; i++)
|
|
if (!IsAnAscii(mystring[i]))
|
|
return Standard_False;
|
|
return Standard_True;
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
// Length
|
|
// ----------------------------------------------------------------------------
|
|
Standard_Integer TCollection_ExtendedString::Length() const
|
|
{
|
|
return mylength;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Print
|
|
// ----------------------------------------------------------------------------
|
|
void TCollection_ExtendedString::Print(Standard_OStream& theStream) const
|
|
{
|
|
if (mylength > 0)
|
|
{
|
|
const TCollection_AsciiString aUtf8(mystring);
|
|
theStream << aUtf8;
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
Standard_OStream& operator<<(Standard_OStream& astream, const TCollection_ExtendedString& astring)
|
|
{
|
|
astring.Print(astream);
|
|
return astream;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// RemoveAll
|
|
// ----------------------------------------------------------------------------
|
|
void TCollection_ExtendedString::RemoveAll(const Standard_ExtCharacter what)
|
|
|
|
{
|
|
if (mylength == 0)
|
|
return;
|
|
int c = 0;
|
|
for (int i = 0; i < mylength; i++)
|
|
if (mystring[i] != what)
|
|
mystring[c++] = mystring[i];
|
|
mylength = c;
|
|
mystring[mylength] = '\0';
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Remove
|
|
// ----------------------------------------------------------------------------
|
|
void TCollection_ExtendedString::Remove(const Standard_Integer where,
|
|
const Standard_Integer ahowmany)
|
|
{
|
|
if (where + ahowmany <= mylength + 1)
|
|
{
|
|
int i, j;
|
|
for (i = where + ahowmany - 1, j = where - 1; i < mylength; i++, j++)
|
|
mystring[j] = mystring[i];
|
|
mylength -= ahowmany;
|
|
mystring[mylength] = '\0';
|
|
}
|
|
else
|
|
throw Standard_OutOfRange("TCollection_ExtendedString::Remove: "
|
|
"Too many characters to erase or "
|
|
"invalid starting value.");
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Search
|
|
// ----------------------------------------------------------------------------
|
|
Standard_Integer TCollection_ExtendedString::Search(const TCollection_ExtendedString& what) const
|
|
{
|
|
Standard_Integer size = what.mylength;
|
|
Standard_ExtString swhat = what.mystring;
|
|
if (size)
|
|
{
|
|
int k, j;
|
|
int i = 0;
|
|
Standard_Boolean find = Standard_False;
|
|
while (i < mylength - size + 1 && !find)
|
|
{
|
|
k = i++;
|
|
j = 0;
|
|
while (j < size && mystring[k++] == swhat[j++])
|
|
if (j == size)
|
|
find = Standard_True;
|
|
}
|
|
if (find)
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// SearchFromEnd
|
|
// ----------------------------------------------------------------------------
|
|
Standard_Integer TCollection_ExtendedString::SearchFromEnd(
|
|
const TCollection_ExtendedString& what) const
|
|
{
|
|
Standard_Integer size = what.mylength;
|
|
if (size)
|
|
{
|
|
Standard_ExtString swhat = what.mystring;
|
|
int k, j;
|
|
int i = mylength - 1;
|
|
Standard_Boolean find = Standard_False;
|
|
while (i >= size - 1 && !find)
|
|
{
|
|
k = i--;
|
|
j = size - 1;
|
|
while (j >= 0 && mystring[k--] == swhat[j--])
|
|
if (j == -1)
|
|
find = Standard_True;
|
|
}
|
|
if (find)
|
|
return i - size + 3;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// SetValue
|
|
// ----------------------------------------------------------------------------
|
|
void TCollection_ExtendedString::SetValue(const Standard_Integer where,
|
|
const Standard_ExtCharacter what)
|
|
{
|
|
if (where > 0 && where <= mylength)
|
|
{
|
|
mystring[where - 1] = what;
|
|
}
|
|
else
|
|
{
|
|
throw Standard_OutOfRange("TCollection_ExtendedString::SetValue : parameter where");
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// SetValue
|
|
// ----------------------------------------------------------------------------
|
|
void TCollection_ExtendedString::SetValue(const Standard_Integer where,
|
|
const TCollection_ExtendedString& what)
|
|
{
|
|
if (where > 0 && where <= mylength + 1)
|
|
{
|
|
Standard_Integer size = what.mylength;
|
|
Standard_ExtString swhat = what.mystring;
|
|
size += (where - 1);
|
|
if (size >= mylength)
|
|
{
|
|
reallocate(size);
|
|
}
|
|
for (int i = where - 1; i < size; i++)
|
|
mystring[i] = swhat[i - (where - 1)];
|
|
}
|
|
else
|
|
throw Standard_OutOfRange("TCollection_ExtendedString::SetValue : "
|
|
"parameter where");
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Split
|
|
// ----------------------------------------------------------------------------
|
|
TCollection_ExtendedString TCollection_ExtendedString::Split(const Standard_Integer where)
|
|
{
|
|
if (where >= 0 && where < mylength)
|
|
{
|
|
TCollection_ExtendedString res(&mystring[where]);
|
|
Trunc(where);
|
|
return res;
|
|
}
|
|
throw Standard_OutOfRange("TCollection_ExtendedString::Split index");
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Token
|
|
// ----------------------------------------------------------------------------
|
|
TCollection_ExtendedString TCollection_ExtendedString::Token(const Standard_ExtString separators,
|
|
const Standard_Integer whichone) const
|
|
{
|
|
if (mylength == 0)
|
|
{
|
|
return TCollection_ExtendedString();
|
|
}
|
|
TCollection_ExtendedString res(mylength, 0);
|
|
if (!separators)
|
|
throw Standard_NullObject("TCollection_ExtendedString::Token : "
|
|
"parameter 'separators'");
|
|
|
|
int i, j, k, l;
|
|
Standard_PExtCharacter buftmp = res.mystring;
|
|
Standard_ExtCharacter aSep;
|
|
|
|
Standard_Boolean isSepFound = Standard_False, otherSepFound;
|
|
|
|
j = 0;
|
|
|
|
for (i = 0; i < whichone && j < mylength; i++)
|
|
{
|
|
isSepFound = Standard_False;
|
|
k = 0;
|
|
buftmp[0] = 0;
|
|
|
|
// Avant de commencer il faut virer les saloperies devant
|
|
//
|
|
otherSepFound = Standard_True;
|
|
while (j < mylength && otherSepFound)
|
|
{
|
|
l = 0;
|
|
otherSepFound = Standard_False;
|
|
aSep = separators[l];
|
|
while (aSep != 0)
|
|
{
|
|
if (aSep == mystring[j])
|
|
{
|
|
aSep = 0;
|
|
otherSepFound = Standard_True;
|
|
}
|
|
else
|
|
{
|
|
aSep = separators[l++];
|
|
}
|
|
}
|
|
if (otherSepFound)
|
|
j++;
|
|
}
|
|
|
|
while (!isSepFound && k < mylength && j < mylength)
|
|
{
|
|
l = 0;
|
|
aSep = separators[l];
|
|
|
|
while (aSep != 0 && !isSepFound)
|
|
{
|
|
if (aSep == mystring[j])
|
|
{
|
|
buftmp[k] = 0;
|
|
isSepFound = Standard_True;
|
|
}
|
|
else
|
|
{
|
|
buftmp[k] = mystring[j];
|
|
}
|
|
l++;
|
|
aSep = separators[l];
|
|
}
|
|
j++;
|
|
k++;
|
|
if (j == mylength)
|
|
buftmp[k] = 0;
|
|
}
|
|
}
|
|
|
|
if (i < whichone)
|
|
{
|
|
res.mylength = 0;
|
|
res.mystring[0] = 0;
|
|
}
|
|
else
|
|
{
|
|
for (res.mylength = 0; buftmp[res.mylength]; ++res.mylength)
|
|
;
|
|
res.mystring[res.mylength] = '\0';
|
|
}
|
|
return res;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// ToExtString
|
|
// ----------------------------------------------------------------------------
|
|
Standard_ExtString TCollection_ExtendedString::ToExtString() const
|
|
{
|
|
return mystring;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Trunc
|
|
// ----------------------------------------------------------------------------
|
|
void TCollection_ExtendedString::Trunc(const Standard_Integer ahowmany)
|
|
{
|
|
if (ahowmany < 0 || ahowmany > mylength)
|
|
throw Standard_OutOfRange("TCollection_ExtendedString::Trunc : "
|
|
"parameter 'ahowmany'");
|
|
mylength = ahowmany;
|
|
mystring[mylength] = '\0';
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// Value
|
|
// ----------------------------------------------------------------------------
|
|
Standard_ExtCharacter TCollection_ExtendedString::Value(const Standard_Integer where) const
|
|
{
|
|
if (where > 0 && where <= mylength)
|
|
{
|
|
if (mystring)
|
|
return mystring[where - 1];
|
|
else
|
|
return 0;
|
|
}
|
|
throw Standard_OutOfRange("TCollection_ExtendedString::Value : "
|
|
"parameter where");
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Convert CString (including multibyte case) to UniCode representation
|
|
//----------------------------------------------------------------------------
|
|
Standard_Boolean TCollection_ExtendedString::ConvertToUnicode(const Standard_CString theStringUtf)
|
|
{
|
|
NCollection_Utf8Iter anIterRead(theStringUtf);
|
|
Standard_ExtCharacter* anIterWrite = mystring;
|
|
if (*anIterRead == 0)
|
|
{
|
|
*anIterWrite = '\0';
|
|
return Standard_True;
|
|
}
|
|
|
|
for (; *anIterRead != 0; ++anIterRead)
|
|
{
|
|
if (!anIterRead.IsValid())
|
|
{
|
|
return Standard_False;
|
|
}
|
|
|
|
anIterWrite = anIterRead.GetUtf(anIterWrite);
|
|
}
|
|
return Standard_True;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Returns expected CString length in UTF8 coding.
|
|
//----------------------------------------------------------------------------
|
|
Standard_Integer TCollection_ExtendedString::LengthOfCString() const
|
|
{
|
|
Standard_Integer aSizeBytes = 0;
|
|
for (NCollection_Utf16Iter anIter(mystring); *anIter != 0; ++anIter)
|
|
{
|
|
aSizeBytes += anIter.AdvanceBytesUtf8();
|
|
}
|
|
return aSizeBytes;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
// Converts the internal <mystring> to UTF8 coding and returns length of the
|
|
// out CString.
|
|
//----------------------------------------------------------------------------
|
|
Standard_Integer TCollection_ExtendedString::ToUTF8CString(Standard_PCharacter& theCString) const
|
|
{
|
|
NCollection_Utf16Iter anIterRead(mystring);
|
|
Standard_Utf8Char* anIterWrite = theCString;
|
|
if (*anIterRead == 0)
|
|
{
|
|
*anIterWrite = '\0';
|
|
return 0;
|
|
}
|
|
|
|
for (; *anIterRead != 0; ++anIterRead)
|
|
{
|
|
anIterWrite = anIterRead.GetUtf(anIterWrite);
|
|
}
|
|
*anIterWrite = '\0';
|
|
return Standard_Integer(anIterWrite - theCString);
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
void TCollection_ExtendedString::allocate(const int theLength)
|
|
{
|
|
mylength = theLength;
|
|
if (theLength == 0)
|
|
{
|
|
mystring = THE_DEFAULT_EXT_CHAR_STRING;
|
|
}
|
|
else
|
|
{
|
|
const Standard_Size aRoundSize = (((theLength + 1) * sizeof(Standard_ExtCharacter)) + 3) & ~0x3;
|
|
mystring = static_cast<Standard_PExtCharacter>(Standard::AllocateOptimal(aRoundSize));
|
|
mystring[mylength] = '\0';
|
|
}
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
void TCollection_ExtendedString::reallocate(const int theLength)
|
|
{
|
|
if (theLength != 0)
|
|
{
|
|
if (mystring == THE_DEFAULT_EXT_CHAR_STRING)
|
|
{
|
|
const Standard_Size aRoundSize =
|
|
(((theLength + 1) * sizeof(Standard_ExtCharacter)) + 3) & ~0x3;
|
|
mystring = static_cast<Standard_PExtCharacter>(Standard::AllocateOptimal(aRoundSize));
|
|
}
|
|
else
|
|
{
|
|
mystring = static_cast<Standard_PExtCharacter>(
|
|
Standard::Reallocate(mystring, (theLength + 1) * sizeof(Standard_ExtCharacter)));
|
|
}
|
|
mystring[theLength] = 0;
|
|
}
|
|
if (mystring != THE_DEFAULT_EXT_CHAR_STRING)
|
|
{
|
|
mystring[theLength] = 0;
|
|
}
|
|
mylength = theLength;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
void TCollection_ExtendedString::deallocate()
|
|
{
|
|
if (mystring != THE_DEFAULT_EXT_CHAR_STRING)
|
|
{
|
|
Standard::Free(mystring);
|
|
}
|
|
mylength = 0;
|
|
mystring = THE_DEFAULT_EXT_CHAR_STRING;
|
|
}
|