|
|
|
/**
|
|
|
|
* Acedia's base text class. It implements all of the methods for
|
|
|
|
* immutable `Text`, but by itself does not give a guarantee of immutability,
|
|
|
|
* since `MutableText` is one of its child classes.
|
|
|
|
* Copyright 2020 - 2022 Anton Tarasenko
|
|
|
|
*------------------------------------------------------------------------------
|
|
|
|
* This file is part of Acedia.
|
|
|
|
*
|
|
|
|
* Acedia is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* Acedia 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 General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with Acedia. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
class BaseText extends AcediaObject
|
|
|
|
abstract;
|
|
|
|
|
|
|
|
// Enumeration that describes how should we treat `BaseText`s that
|
|
|
|
// differ in case only.
|
|
|
|
// By default we would consider them unequal.
|
|
|
|
enum CaseSensitivity
|
|
|
|
{
|
|
|
|
SCASE_SENSITIVE,
|
|
|
|
SCASE_INSENSITIVE
|
|
|
|
};
|
|
|
|
|
|
|
|
// Enumeration that describes how should we treat `BaseText`s that
|
|
|
|
// differ only in their formatting.
|
|
|
|
// By default we would consider them unequal.
|
|
|
|
enum FormatSensitivity
|
|
|
|
{
|
|
|
|
SFORM_INSENSITIVE,
|
|
|
|
SFORM_SENSITIVE
|
|
|
|
};
|
|
|
|
|
|
|
|
// Describes text formatting, can be applied per-character.
|
|
|
|
struct Formatting
|
|
|
|
{
|
|
|
|
// Whether this formatting describes a color of the text
|
|
|
|
var bool isColored;
|
|
|
|
// Color of the text, used only when `isColored == true`
|
|
|
|
var Color color;
|
|
|
|
};
|
|
|
|
|
|
|
|
// Represents one character, together with it's formatting
|
|
|
|
struct Character
|
|
|
|
{
|
|
|
|
var int codePoint;
|
|
|
|
var Formatting formatting;
|
|
|
|
};
|
|
|
|
|
|
|
|
// Actual content of the `BaseText` is stored as a sequence of
|
|
|
|
// Unicode code points.
|
|
|
|
var private array<int> codePoints;
|
|
|
|
// Structure for inner use, describes a change of formatting to `formatting`,
|
|
|
|
// starting from index `startIndex`
|
|
|
|
struct FormattingChunk
|
|
|
|
{
|
|
|
|
var private int startIndex;
|
|
|
|
var private Formatting formatting;
|
|
|
|
};
|
|
|
|
// Series of `FormattingChunk` that defines formatting over characters,
|
|
|
|
// defined by `codePoints`.
|
|
|
|
// This array is sorted by `startIndex` of it's elements and
|
|
|
|
// formatting for character at <index> is defined by the `FormattingChunk`
|
|
|
|
// with the largest `startIndex <= <index>`.
|
|
|
|
var private array<FormattingChunk> formattingChunks;
|
|
|
|
// To optimize look up of formatting for characters we remember index of
|
|
|
|
// the last used `FormattingChunk` to attempt to start the next lookup
|
|
|
|
// from that point.
|
|
|
|
// This improves performance when several lookups are done in order.
|
|
|
|
var private int formattingIndexCache;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In the base class we implement `AppendCodePoint()` and
|
|
|
|
* `AppendManyCodePoints()` methods that allow to add code points 1-by-1.
|
|
|
|
* To reduce the amount of checks, formatting is set not per-code point,
|
|
|
|
* but separately by `SetFormatting()`: to append a group of code points with
|
|
|
|
* a certain formatting one has to first set their formatting,
|
|
|
|
* then just add code points.
|
|
|
|
*/
|
|
|
|
// Formatting to use for the next code point
|
|
|
|
var private Formatting nextFormatting;
|
|
|
|
// `true` if the next code point will have a different formatting from
|
|
|
|
// the last added one.
|
|
|
|
var private bool formattingUpdated;
|
|
|
|
|
|
|
|
// Escape code point is used to change output's color and is used in
|
|
|
|
// Unreal Engine's `string`s.
|
|
|
|
var protected const int CODEPOINT_ESCAPE;
|
|
|
|
// Opening and closing symbols for colored blocks in formatted strings.
|
|
|
|
var protected const int CODEPOINT_OPEN_FORMAT;
|
|
|
|
var protected const int CODEPOINT_CLOSE_FORMAT;
|
|
|
|
var protected const string STRING_OPEN_FORMAT;
|
|
|
|
var protected const string STRING_CLOSE_FORMAT;
|
|
|
|
// Symbol for separating opening formatting block from it's contents
|
|
|
|
var protected const string STRING_SEPARATOR_FORMAT;
|
|
|
|
// Symbol to escape any character in formatted strings,
|
|
|
|
// including above mentioned opening and closing symbols.
|
|
|
|
var protected const int CODEPOINT_FORMAT_ESCAPE;
|
|
|
|
var protected const string STRING_FORMAT_ESCAPE;
|
|
|
|
|
|
|
|
// Simply free all used memory.
|
|
|
|
protected function Finalizer()
|
|
|
|
{
|
|
|
|
codePoints.length = 0;
|
|
|
|
formattingChunks.length = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Auxiliary method that changes formatting of the whole `BaseText` to
|
|
|
|
* a specified one (`newFormatting`). This method is faster than calling
|
|
|
|
* `ReformatRange`.
|
|
|
|
*
|
|
|
|
* @param newFormatting Formatting to set to the whole `BaseText`.
|
|
|
|
*/
|
|
|
|
protected final function ReformatWhole(Formatting newFormatting)
|
|
|
|
{
|
|
|
|
local FormattingChunk newChunk;
|
|
|
|
formattingChunks.length = 0;
|
|
|
|
newChunk.startIndex = 0;
|
|
|
|
newChunk.formatting = newFormatting;
|
|
|
|
formattingChunks[0] = newChunk;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Auxiliary method that changes formatting of the characters with indices in
|
|
|
|
* range `[start; end]` to a specified one (`newFormatting`).
|
|
|
|
*
|
|
|
|
* This method assumes, but does not check that:
|
|
|
|
* 1. `start <= end`;
|
|
|
|
* 2. `start` and `end` parameters belong to the range of valid indices
|
|
|
|
* `[0; GetLength() - 1]`
|
|
|
|
*
|
|
|
|
* @param start First character to change formatting of.
|
|
|
|
* @param end Last character to change formatting of.
|
|
|
|
* @param newFormatting Formatting to set to the specified characters.
|
|
|
|
*/
|
|
|
|
protected final function ReformatRange(
|
|
|
|
int start,
|
|
|
|
int end,
|
|
|
|
Formatting newFormatting)
|
|
|
|
{
|
|
|
|
local int i;
|
|
|
|
local Formatting formattingAfterChangedSegment;
|
|
|
|
local FormattingChunk newChunk;
|
|
|
|
local array<FormattingChunk> newFormattingChunks;
|
|
|
|
start = Max(start, 0);
|
|
|
|
end = Min(GetLength() - 1, end);
|
|
|
|
// Formatting right after `end`, the end of re-formatted segment
|
|
|
|
formattingAfterChangedSegment = GetFormatting(end + 1);
|
|
|
|
// 1. Copy old formatting before `start`
|
|
|
|
for (i = 0; i < formattingChunks.length; i += 1)
|
|
|
|
{
|
|
|
|
if (start <= formattingChunks[i].startIndex) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
newFormattingChunks[newFormattingChunks.length] = formattingChunks[i];
|
|
|
|
}
|
|
|
|
newChunk.formatting = newFormatting;
|
|
|
|
newChunk.startIndex = start;
|
|
|
|
newFormattingChunks[newFormattingChunks.length] = newChunk;
|
|
|
|
if (end == GetLength() - 1)
|
|
|
|
{
|
|
|
|
formattingChunks = newFormattingChunks;
|
|
|
|
// We have inserted `FormattingChunk` without checking if it actually
|
|
|
|
// changes formatting. It might be excessive, so do a normalization.
|
|
|
|
NormalizeFormatting();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
// 2. Drop old formatting overwritten by `newFormatting`
|
|
|
|
while (i < formattingChunks.length)
|
|
|
|
{
|
|
|
|
if (end < formattingChunks[i].startIndex) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
i += 1;
|
|
|
|
}
|
|
|
|
// 3. Copy old formatting after `end`
|
|
|
|
newChunk.formatting = formattingAfterChangedSegment;
|
|
|
|
newChunk.startIndex = end + 1; // end < GetLength() - 1
|
|
|
|
newFormattingChunks[newFormattingChunks.length] = newChunk;
|
|
|
|
while (i < formattingChunks.length)
|
|
|
|
{
|
|
|
|
newFormattingChunks[newFormattingChunks.length] = formattingChunks[i];
|
|
|
|
i += 1;
|
|
|
|
}
|
|
|
|
formattingChunks = newFormattingChunks;
|
|
|
|
// We have inserted `FormattingChunk` without checking if it actually
|
|
|
|
// changes formatting. It might be excessive, so do a normalization.
|
|
|
|
NormalizeFormatting();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Makes an immutable copy (`class'Text'`) of the caller `BaseText`.
|
|
|
|
*
|
|
|
|
* Copies characters in the range `[startIndex; startIndex + maxLength - 1]`
|
|
|
|
* If provided parameters `startIndex` and `maxLength` define a range that
|
|
|
|
* goes beyond `[0; self.GetLength() - 1]`, then intersection with a valid
|
|
|
|
* range will be used.
|
|
|
|
*
|
|
|
|
* @param startIndex Position of the first character to copy.
|
|
|
|
* By default `0`, corresponding to the very first character.
|
|
|
|
* @param maxLength Max length of the extracted string. By default `0`,
|
|
|
|
* - that and all negative values mean that method should extract all
|
|
|
|
* characters to the right of `startIndex`.
|
|
|
|
* @return Immutable copy of the caller `BaseText` instance.
|
|
|
|
* Guaranteed to be not `none` and have class `Text`.
|
|
|
|
*/
|
|
|
|
public final function Text Copy(
|
|
|
|
optional int startIndex,
|
|
|
|
optional int maxLength)
|
|
|
|
{
|
|
|
|
// `startIndex` is inclusive and `endIndex` is not
|
|
|
|
local int i, endIndex;
|
|
|
|
local Text copy;
|
|
|
|
local Character nextCharacter;
|
|
|
|
if (maxLength <= 0) {
|
|
|
|
maxLength = codePoints.length - startIndex;
|
|
|
|
}
|
|
|
|
endIndex = startIndex + maxLength;
|
|
|
|
copy = Text(_.memory.Allocate(class'Text'));
|
|
|
|
// Edge cases
|
|
|
|
if (endIndex <= 0) {
|
|
|
|
return copy;
|
|
|
|
}
|
|
|
|
if (startIndex <= 0 && startIndex + maxLength >= codePoints.length)
|
|
|
|
{
|
|
|
|
copy.codePoints = codePoints;
|
|
|
|
copy.formattingChunks = formattingChunks;
|
|
|
|
return copy;
|
|
|
|
}
|
|
|
|
// Substring copy
|
|
|
|
if (startIndex < 0) {
|
|
|
|
startIndex = 0;
|
|
|
|
}
|
|
|
|
endIndex = Min(endIndex, codePoints.length);
|
|
|
|
for (i = startIndex; i < endIndex; i += 1)
|
|
|
|
{
|
|
|
|
nextCharacter = GetCharacter(i);
|
|
|
|
copy.SetFormatting(nextCharacter.formatting);
|
|
|
|
copy.AppendCodePoint(nextCharacter.codePoint);
|
|
|
|
}
|
|
|
|
return copy;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Makes a mutable copy (`class'MutableText'`) of the caller
|
|
|
|
* `BaseText` instance.
|
|
|
|
*
|
|
|
|
* If provided parameters `startIndex` and `maxLength` define a range that
|
|
|
|
* goes beyond `[0; self.GetLength() - 1]`, then intersection with a valid
|
|
|
|
* range will be used.
|
|
|
|
*
|
|
|
|
* @param startIndex Position of the first character to copy.
|
|
|
|
* By default `0`, corresponding to the very first character.
|
|
|
|
* @param maxLength Max length of the extracted string. By default `0`,
|
|
|
|
* - that and all negative values mean that method should extract all
|
|
|
|
* characters to the right of `startIndex`.
|
|
|
|
* @return Mutable copy of the caller `BaseText` instance.
|
|
|
|
* Guaranteed to be not `none` and have class `MutableText`.
|
|
|
|
*/
|
|
|
|
public final function MutableText MutableCopy(
|
|
|
|
optional int startIndex,
|
|
|
|
optional int maxLength)
|
|
|
|
{
|
|
|
|
// `startIndex` is inclusive and `endIndex` is not
|
|
|
|
local int i, endIndex;
|
|
|
|
local MutableText copy;
|
|
|
|
if (maxLength <= 0) {
|
|
|
|
maxLength = codePoints.length - startIndex;
|
|
|
|
}
|
|
|
|
endIndex = startIndex + maxLength;
|
|
|
|
copy = MutableText(_.memory.Allocate(class'MutableText'));
|
|
|
|
// Edge cases
|
|
|
|
if (endIndex <= 0 || startIndex >= codePoints.length) {
|
|
|
|
return copy;
|
|
|
|
}
|
|
|
|
if (startIndex <= 0 && startIndex + maxLength >= codePoints.length)
|
|
|
|
{
|
|
|
|
copy.codePoints = codePoints;
|
|
|
|
copy.formattingChunks = formattingChunks;
|
|
|
|
return copy;
|
|
|
|
}
|
|
|
|
// Substring copy
|
|
|
|
if (startIndex < 0) {
|
|
|
|
startIndex = 0;
|
|
|
|
}
|
|
|
|
endIndex = Min(endIndex, codePoints.length);
|
|
|
|
for (i = startIndex; i < endIndex; i += 1) {
|
|
|
|
copy.AppendCharacter(GetCharacter(i));
|
|
|
|
}
|
|
|
|
return copy;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Makes an immutable copy (`class'Text'`) of the caller `BaseText`
|
|
|
|
* in a lower case.
|
|
|
|
*
|
|
|
|
* If provided parameters `startPosition` and `maxLength` define a range that
|
|
|
|
* goes beyond `[0; self.GetLength() - 1]`, then intersection with a valid
|
|
|
|
* range will be used.
|
|
|
|
*
|
|
|
|
* @param startPosition Position of the first character to copy.
|
|
|
|
* By default `0`, corresponding to the very first character.
|
|
|
|
* @param maxLength Max length of the extracted string. By default `0`,
|
|
|
|
* - that and all negative values mean that method should extract all
|
|
|
|
* characters to the right of `startIndex`.
|
|
|
|
* @return Immutable copy of caller `BaseText` in a lower case.
|
|
|
|
* Guaranteed to be not `none` and have class `Text`.
|
|
|
|
*/
|
|
|
|
public final function Text LowerCopy(
|
|
|
|
optional int startIndex,
|
|
|
|
optional int maxLength)
|
|
|
|
{
|
|
|
|
local Text textCopy;
|
|
|
|
textCopy = Copy(startIndex, maxLength);
|
|
|
|
textCopy.ConvertCase(true);
|
|
|
|
return textCopy;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Makes an immutable copy (`class'Text'`) of the caller `BaseText`
|
|
|
|
* in an upper case.
|
|
|
|
*
|
|
|
|
* If provided parameters `startPosition` and `maxLength` define a range that
|
|
|
|
* goes beyond `[0; self.GetLength() - 1]`, then intersection with a valid
|
|
|
|
* range will be used.
|
|
|
|
*
|
|
|
|
* @param startPosition Position of the first character to copy.
|
|
|
|
* By default `0`, corresponding to the very first character.
|
|
|
|
* @param maxLength Max length of the extracted string. By default `0`,
|
|
|
|
* - that and all negative values mean that method should extract all
|
|
|
|
* characters to the right of `startIndex`.
|
|
|
|
* @return Immutable copy of caller `BaseText` in a upper case.
|
|
|
|
* Guaranteed to be not `none` and have class `Text`.
|
|
|
|
*/
|
|
|
|
public final function Text UpperCopy(
|
|
|
|
optional int startIndex,
|
|
|
|
optional int maxLength)
|
|
|
|
{
|
|
|
|
local Text textCopy;
|
|
|
|
textCopy = Copy(startIndex, maxLength);
|
|
|
|
textCopy.ConvertCase(false);
|
|
|
|
return textCopy;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Makes a mutable copy (`class'MutableText'`) of the caller
|
|
|
|
* `BaseText` instance in lower case.
|
|
|
|
*
|
|
|
|
* If provided parameters `startPosition` and `maxLength` define a range that
|
|
|
|
* goes beyond `[0; self.GetLength() - 1]`, then intersection with a valid
|
|
|
|
* range will be used.
|
|
|
|
*
|
|
|
|
* @param startPosition Position of the first character to copy.
|
|
|
|
* By default `0`, corresponding to the very first character.
|
|
|
|
* @param maxLength Max length of the extracted string. By default `0`,
|
|
|
|
* - that and all negative values mean that method should extract all
|
|
|
|
* characters to the right of `startIndex`.
|
|
|
|
* @return Mutable copy of caller `BaseText` instance in lower case.
|
|
|
|
* Guaranteed to be not `none` and have class `MutableText`.
|
|
|
|
*/
|
|
|
|
public final function MutableText LowerMutableCopy(
|
|
|
|
optional int startIndex,
|
|
|
|
optional int maxLength)
|
|
|
|
{
|
|
|
|
local MutableText textCopy;
|
|
|
|
textCopy = MutableCopy(startIndex, maxLength);
|
|
|
|
textCopy.ConvertCase(true);
|
|
|
|
return textCopy;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Makes a mutable copy (`class'MutableText'`) of the caller text instance
|
|
|
|
* in upper case.
|
|
|
|
*
|
|
|
|
* If provided parameters `startPosition` and `maxLength` define a range that
|
|
|
|
* goes beyond `[0; self.GetLength() - 1]`, then intersection with a valid
|
|
|
|
* range will be used.
|
|
|
|
*
|
|
|
|
* @param startPosition Position of the first character to copy.
|
|
|
|
* By default `0`, corresponding to the very first character.
|
|
|
|
* @param maxLength Max length of the extracted string. By default `0`,
|
|
|
|
* - that and all negative values mean that method should extract all
|
|
|
|
* characters to the right of `startIndex`.
|
|
|
|
* @return Mutable copy of caller `BaseText` instance in upper case.
|
|
|
|
* Guaranteed to be not `none` and have class `MutableText`.
|
|
|
|
*/
|
|
|
|
public final function MutableText UpperMutableCopy(
|
|
|
|
optional int startIndex,
|
|
|
|
optional int maxLength)
|
|
|
|
{
|
|
|
|
local MutableText textCopy;
|
|
|
|
textCopy = MutableCopy(startIndex, maxLength);
|
|
|
|
textCopy.ConvertCase(false);
|
|
|
|
return textCopy;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Checks whether all letters in the caller text is in the lower case.
|
|
|
|
*
|
|
|
|
* @return `true` if there are no characters that qualify as upper case and
|
|
|
|
* `false` otherwise.
|
|
|
|
*/
|
|
|
|
public final function bool IsLowerCase()
|
|
|
|
{
|
|
|
|
local int i;
|
|
|
|
local Character nextCharacter;
|
|
|
|
|
|
|
|
if (IsEmpty()) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
for (i = 0; i < GetLength(); i += 1)
|
|
|
|
{
|
|
|
|
nextCharacter = GetCharacter(i);
|
|
|
|
if (_.text.IsUpper(nextCharacter)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Checks whether all letters in the caller text is in the lower case.
|
|
|
|
*
|
|
|
|
* @return `true` if there are no characters that qualify as lower case and
|
|
|
|
* `false` otherwise.
|
|
|
|
*/
|
|
|
|
public final function bool IsUpperCase()
|
|
|
|
{
|
|
|
|
local int i;
|
|
|
|
local Character nextCharacter;
|
|
|
|
|
|
|
|
if (IsEmpty()) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
for (i = 0; i < GetLength(); i += 1)
|
|
|
|
{
|
|
|
|
nextCharacter = GetCharacter(i);
|
|
|
|
if (_.text.IsLower(nextCharacter)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Checks if caller `BaseText` contains a valid name object or not.
|
|
|
|
*
|
|
|
|
* Valid names are case-insensitive `BaseText`s that:
|
|
|
|
* 1. No longer than 50 characters long;
|
|
|
|
* 2. Contain only ASCII letters, digits and '.' / '_' characters;
|
|
|
|
* 3. Empty `BaseText` is not considered a valid name.
|
|
|
|
*
|
|
|
|
* @return `true` if caller `BaseText` contains a valid config object name and
|
|
|
|
* `false` otherwise.
|
|
|
|
*/
|
|
|
|
public final function bool IsValidName()
|
|
|
|
{
|
|
|
|
local int i;
|
|
|
|
local int codePoint;
|
|
|
|
local bool isValidCodePoint;
|
|
|
|
local Character nextCharacter;
|
|
|
|
|
|
|
|
if (IsEmpty()) return false;
|
|
|
|
if (GetLength() > 50) return false;
|
|
|
|
|
|
|
|
for (i = 0; i < GetLength(); i += 1)
|
|
|
|
{
|
|
|
|
nextCharacter = GetCharacter(i);
|
|
|
|
codePoint = nextCharacter.codePoint;
|
|
|
|
isValidCodePoint =
|
|
|
|
( (codePoint == 0x2E) || (codePoint == 0x5F) // '.' or '_'
|
|
|
|
|| (0x30 <= codePoint && codePoint <= 0x39) // '0' to '9'
|
|
|
|
|| (0x41 <= codePoint && codePoint <= 0x5A) // 'A' to 'Z'
|
|
|
|
|| (0x61 <= codePoint && codePoint <= 0x7A)); // 'a' to 'z'
|
|
|
|
if (!isValidCodePoint) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Auxiliary function that converts case of the caller `BaseText` object.
|
|
|
|
* As `BaseText` is supposed to be immutable, cannot be public.
|
|
|
|
*
|
|
|
|
* @param toLower `true` if caller `BaseText` must be converted to
|
|
|
|
* the lower case and `false` otherwise.
|
|
|
|
*/
|
|
|
|
protected final function ConvertCase(bool toLower)
|
|
|
|
{
|
|
|
|
local int i;
|
|
|
|
local Character nextCharacter;
|
|
|
|
for (i = 0; i < GetLength(); i += 1)
|
|
|
|
{
|
|
|
|
nextCharacter = GetCharacter(i);
|
|
|
|
if (toLower) {
|
|
|
|
nextCharacter = _.text.ToLower(nextCharacter);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
nextCharacter = _.text.ToUpper(nextCharacter);
|
|
|
|
}
|
|
|
|
codePoints[i] = nextCharacter.codePoint;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Calculates hash value of the caller `BaseText`. Hash will depend only on
|
|
|
|
* it's textual contents, without taking formatting (color information)
|
|
|
|
* into account.
|
|
|
|
*
|
|
|
|
* @return Hash, that depends on textual contents only.
|
|
|
|
*/
|
|
|
|
protected function int CalculateHashCode()
|
|
|
|
{
|
|
|
|
// We have left this method here, since only the base class has access
|
|
|
|
// to code points, which allows for more efficient implementation.
|
|
|
|
// You must overload it for mutable text child classes
|
|
|
|
// (like `MutableText`).
|
|
|
|
local int i;
|
|
|
|
local int hash;
|
|
|
|
// Manually inline `CombineHash()`, to avoid too many calls
|
|
|
|
// (and infinite loop detection) for some long text data.
|
|
|
|
hash = 5381;
|
|
|
|
for (i = 0; i < codePoints.length; i += 1)
|
|
|
|
{
|
|
|
|
// hash * 33 + codePoints[i]
|
|
|
|
hash = ((hash << 5) + hash) + codePoints[i];
|
|
|
|
}
|
|
|
|
return hash;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Checks whether contents of the caller `BaseText` are empty.
|
|
|
|
*
|
|
|
|
* @return `true` if caller `BaseText` contains no symbols.
|
|
|
|
*/
|
|
|
|
public final function bool IsEmpty()
|
|
|
|
{
|
|
|
|
return (codePoints.length == 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns current length of the caller `BaseText` in symbols.
|
|
|
|
*
|
|
|
|
* Do note that codepoint is not the same as a symbol, since one symbol
|
|
|
|
* can consist of several code points. While current implementation only
|
|
|
|
* supports symbols represented by a single code point, this might change
|
|
|
|
* in the future.
|
|
|
|
*
|
|
|
|
* @return Current length of caller `BaseText`'s contents in symbols.
|
|
|
|
*/
|
|
|
|
public final function int GetLength()
|
|
|
|
{
|
|
|
|
return codePoints.length;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Override equality check for `BaseText` to make two different
|
|
|
|
* `BaseText`s equal based on their text contents.
|
|
|
|
* Text equality check is case-sensitive and does not take formatting
|
|
|
|
* into account.
|
|
|
|
*
|
|
|
|
* `BaseText` cannot be equal to object of any class that is not
|
|
|
|
* derived from `BaseText`.
|
|
|
|
*
|
|
|
|
* @param other Object to compare to the caller.
|
|
|
|
* `none` is only equal to the `none`.
|
|
|
|
* @return `true` if `other` is considered equal to the caller `BaseText`,
|
|
|
|
* `false` otherwise.
|
|
|
|
*/
|
|
|
|
public function bool IsEqual(Object other)
|
|
|
|
{
|
|
|
|
if (self == other) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return Compare(BaseText(other));
|
|
|
|
}
|
|
|
|
|
|
|
|
// "Normalizes" code point for comparison by converting it to lower case if
|
|
|
|
// `caseSensitivity == SCASE_INSENSITIVE`.
|
|
|
|
// Otherwise returns same code point.
|
|
|
|
private final function int NormalizeCodePoint(
|
|
|
|
int codePoint,
|
|
|
|
CaseSensitivity caseSensitivity)
|
|
|
|
{
|
|
|
|
local int newCodePoint;
|
|
|
|
if (caseSensitivity == SCASE_INSENSITIVE) {
|
|
|
|
newCodePoint = class'UnicodeData'.static.ToLowerCodePoint(codePoint);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
newCodePoint = codePoint;
|
|
|
|
}
|
|
|
|
if (newCodePoint < 0) {
|
|
|
|
return codePoint;
|
|
|
|
}
|
|
|
|
return newCodePoint;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Method for checking equality between the caller and another `BaseText`
|
|
|
|
* object.
|
|
|
|
*
|
|
|
|
* This method supports comparison both sensitive and not sensitive to
|
|
|
|
* the case and difference in formatting (color of the characters).
|
|
|
|
* By default comparison is case-sensitive, but ignores
|
|
|
|
* formatting information.
|
|
|
|
*
|
|
|
|
* @param otherText `BaseText` to compare caller instance to.
|
|
|
|
* @param caseSensitivity Defines whether comparison should be
|
|
|
|
* case-sensitive. By default it is.
|
|
|
|
* @param formatSensitivity Defines whether comparison should be
|
|
|
|
* sensitive for color information. By default it is not.
|
|
|
|
* @return `true` if the caller `BaseText` is equal to the `otherText` under
|
|
|
|
* specified parameters and `false` otherwise.
|
|
|
|
*/
|
|
|
|
public final function bool Compare(
|
|
|
|
BaseText otherText,
|
|
|
|
optional CaseSensitivity caseSensitivity,
|
|
|
|
optional FormatSensitivity formatSensitivity)
|
|
|
|
{
|
|
|
|
local int i;
|
|
|
|
local array<int> otherCodePoints;
|
|
|
|
if (otherText == none) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (GetLength() != otherText.GetLength()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (formatSensitivity == SFORM_SENSITIVE && !CompareFormatting(otherText)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
// Copy once to avoid doing it each iteration
|
|
|
|
otherCodePoints = otherText.codePoints;
|
|
|
|
for (i = 0; i < codePoints.length; i += 1)
|
|
|
|
{
|
|
|
|
if ( NormalizeCodePoint(codePoints[i], caseSensitivity)
|
|
|
|
!= NormalizeCodePoint(otherCodePoints[i], caseSensitivity)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Method for checking if the caller starts with another `BaseText` object.
|
|
|
|
*
|
|
|
|
* This method supports comparison both sensitive and not sensitive to
|
|
|
|
* the case and difference in formatting (color of the characters).
|
|
|
|
* By default comparison is case-sensitive, but ignores
|
|
|
|
* formatting information.
|
|
|
|
*
|
|
|
|
* @param otherText `BaseText` that caller is checked to start with.
|
|
|
|
* @param caseSensitivity Defines whether comparison should be
|
|
|
|
* case-sensitive. By default it is.
|
|
|
|
* @param formatSensitivity Defines whether comparison should be
|
|
|
|
* sensitive for color information. By default it is not.
|
|
|
|
* @return `true` if the caller `BaseText` starts with `otherText` under
|
|
|
|
* specified parameters and `false` otherwise.
|
|
|
|
*/
|
|
|
|
public final function bool StartsWith(
|
|
|
|
BaseText otherText,
|
|
|
|
optional CaseSensitivity caseSensitivity,
|
|
|
|
optional FormatSensitivity formatSensitivity)
|
|
|
|
{
|
|
|
|
local int i;
|
|
|
|
local Character char1, char2;
|
|
|
|
if (otherText == none) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (GetLength() < otherText.GetLength()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
for (i = 0; i < otherText.GetLength(); i += 1)
|
|
|
|
{
|
|
|
|
char1 = GetCharacter(i);
|
|
|
|
char2 = otherText.GetCharacter(i);
|
|
|
|
if ( NormalizeCodePoint(char1.codePoint, caseSensitivity)
|
|
|
|
!= NormalizeCodePoint(char2.codePoint, caseSensitivity)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if ( formatSensitivity == SFORM_SENSITIVE
|
|
|
|
&& !_.text.IsFormattingEqual(char1.formatting, char2.formatting)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Method for checking if the caller starts with another `string`.
|
|
|
|
*
|
|
|
|
* This method supports comparison both sensitive and not sensitive to
|
|
|
|
* the case. By default comparison is case-sensitive.
|
|
|
|
*
|
|
|
|
* @param otherString `string` that caller is checked to start with.
|
|
|
|
* @param caseSensitivity Defines whether comparison should be
|
|
|
|
* case-sensitive. By default it is.
|
|
|
|
* @return `true` if the caller `BaseText` starts with `otherString` under
|
|
|
|
* specified parameters and `false` otherwise.
|
|
|
|
*/
|
|
|
|
public final function bool StartsWithS(
|
|
|
|
string otherString,
|
|
|
|
optional CaseSensitivity caseSensitivity)
|
|
|
|
{
|
|
|
|
local bool result;
|
|
|
|
local MutableText otherText;
|
|
|
|
otherText = _.text.FromStringM(otherString);
|
|
|
|
result = StartsWith(otherText, caseSensitivity);
|
|
|
|
_.memory.Free(otherText);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Method for checking if the caller ends with another `BaseText` object.
|
|
|
|
*
|
|
|
|
* This method supports comparison both sensitive and not sensitive to
|
|
|
|
* the case and difference in formatting (color of the characters).
|
|
|
|
* By default comparison is case-sensitive, but ignores
|
|
|
|
* formatting information.
|
|
|
|
*
|
|
|
|
* @param otherText `BaseText` that caller is checked to end with.
|
|
|
|
* @param caseSensitivity Defines whether comparison should be
|
|
|
|
* case-sensitive. By default it is.
|
|
|
|
* @param formatSensitivity Defines whether comparison should be
|
|
|
|
* sensitive for color information. By default it is not.
|
|
|
|
* @return `true` if the caller `BaseText` ends with `otherText` under
|
|
|
|
* specified parameters and `false` otherwise.
|
|
|
|
*/
|
|
|
|
public final function bool EndsWith(
|
|
|
|
BaseText otherText,
|
|
|
|
optional CaseSensitivity caseSensitivity,
|
|
|
|
optional FormatSensitivity formatSensitivity)
|
|
|
|
{
|
|
|
|
local int index, otherIndex;
|
|
|
|
local Character char1, char2;
|
|
|
|
if (otherText == none) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (GetLength() < otherText.GetLength()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
index = GetLength() - 1;
|
|
|
|
otherIndex = otherText.GetLength() - 1;
|
|
|
|
while (otherIndex >= 0)
|
|
|
|
{
|
|
|
|
char1 = GetCharacter(index);
|
|
|
|
char2 = otherText.GetCharacter(otherIndex);
|
|
|
|
if ( NormalizeCodePoint(char1.codePoint, caseSensitivity)
|
|
|
|
!= NormalizeCodePoint(char2.codePoint, caseSensitivity)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if ( formatSensitivity == SFORM_SENSITIVE
|
|
|
|
&& !_.text.IsFormattingEqual(char1.formatting, char2.formatting)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
index -= 1;
|
|
|
|
otherIndex -= 1;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Method for checking if the caller ends with another `string`.
|
|
|
|
*
|
|
|
|
* This method supports comparison both sensitive and not sensitive to
|
|
|
|
* the case. By default comparison is case-sensitive.
|
|
|
|
*
|
|
|
|
* @param otherString `string` that caller is checked to end with.
|
|
|
|
* @param caseSensitivity Defines whether comparison should be
|
|
|
|
* case-sensitive. By default it is.
|
|
|
|
* @return `true` if the caller `BaseText` ends with `otherString` under
|
|
|
|
* specified parameters and `false` otherwise.
|
|
|
|
*/
|
|
|
|
public final function bool EndsWithS(
|
|
|
|
string otherString,
|
|
|
|
optional CaseSensitivity caseSensitivity)
|
|
|
|
{
|
|
|
|
local bool result;
|
|
|
|
local MutableText otherText;
|
|
|
|
otherText = _.text.FromStringM(otherString);
|
|
|
|
result = EndsWith(otherText, caseSensitivity);
|
|
|
|
_.memory.Free(otherText);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Helper method for comparing formatting data of the caller `BaseText`
|
|
|
|
// and `otherText`.
|
|
|
|
private final function bool CompareFormatting(BaseText otherText)
|
|
|
|
{
|
|
|
|
local int i;
|
|
|
|
local TextAPI api;
|
|
|
|
local array<FormattingChunk> rightChunks;
|
|
|
|
rightChunks = otherText.formattingChunks;
|
|
|
|
if (formattingChunks.length != rightChunks.length) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
api = _.text;
|
|
|
|
for (i = 0; i < formattingChunks.length; i += 1)
|
|
|
|
{
|
|
|
|
if (formattingChunks[i].startIndex != rightChunks[i].startIndex) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (!api.IsFormattingEqual( formattingChunks[i].formatting,
|
|
|
|
rightChunks[i].formatting))
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Method for checking equality between the caller `BaseText` and
|
|
|
|
* a (plain) `string`.
|
|
|
|
*
|
|
|
|
* This method supports comparison both sensitive and not sensitive to
|
|
|
|
* the case and difference in formatting (color of the characters).
|
|
|
|
* By default comparison is case-sensitive, but ignores
|
|
|
|
* formatting information.
|
|
|
|
*
|
|
|
|
* @param otherText Plain `string` to compare caller `BaseText` to.
|
|
|
|
* @param caseSensitivity Defines whether comparison should be
|
|
|
|
* case-sensitive. By default it is.
|
|
|
|
* @param formatSensitivity Defines whether comparison should be
|
|
|
|
* sensitive for color information. By default it is not.
|
|
|
|
* @return `true` if the caller `BaseText` is equal to the `stringToCompare`
|
|
|
|
* under specified parameters and `false` otherwise.
|
|
|
|
*/
|
|
|
|
public final function bool CompareToString(
|
|
|
|
string stringToCompare,
|
|
|
|
optional CaseSensitivity caseSensitivity,
|
|
|
|
optional FormatSensitivity formatSensitivity)
|
|
|
|
{
|
|
|
|
local MutableText builder;
|
|
|
|
local bool result;
|
|
|
|
builder = MutableText(_.memory.Allocate(class'MutableText'));
|
|
|
|
builder.AppendString(stringToCompare);
|
|
|
|
result = Compare(builder, caseSensitivity, formatSensitivity);
|
|
|
|
builder.FreeSelf();
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Method for checking equality between the caller `BaseText` and
|
|
|
|
* a (colored) `string`.
|
|
|
|
*
|
|
|
|
* This method supports comparison both sensitive and not sensitive to
|
|
|
|
* the case and difference in formatting (color of the characters).
|
|
|
|
* By default comparison is case-sensitive, but ignores
|
|
|
|
* formatting information.
|
|
|
|
*
|
|
|
|
* @param otherText Colored `string` to compare caller
|
|
|
|
* `BaseText` to.
|
|
|
|
* @param caseSensitivity Defines whether comparison should be
|
|
|
|
* case-sensitive. By default it is.
|
|
|
|
* @param formatSensitivity Defines whether comparison should be
|
|
|
|
* sensitive for color information. By default it is not.
|
|
|
|
* @return `true` if the caller `BaseText` is equal to the `stringToCompare`
|
|
|
|
* under specified parameters and `false` otherwise.
|
|
|
|
*/
|
|
|
|
public final function bool CompareToColoredString(
|
|
|
|
string stringToCompare,
|
|
|
|
optional CaseSensitivity caseSensitivity,
|
|
|
|
optional FormatSensitivity formatSensitivity)
|
|
|
|
{
|
|
|
|
local MutableText builder;
|
|
|
|
local bool result;
|
|
|
|
builder = MutableText(_.memory.Allocate(class'MutableText'));
|
|
|
|
builder.AppendColoredString(stringToCompare);
|
|
|
|
result = Compare(builder, caseSensitivity, formatSensitivity);
|
|
|
|
builder.FreeSelf();
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Method for checking equality between the caller `BaseText` and
|
|
|
|
* a (formatted) `string`.
|
|
|
|
*
|
|
|
|
* This method supports comparison both sensitive and not sensitive to
|
|
|
|
* the case and difference in formatting (color of the characters).
|
|
|
|
* By default comparison is case-sensitive, but ignores
|
|
|
|
* formatting information.
|
|
|
|
*
|
|
|
|
* @param otherText Formatted `string` to compare caller
|
|
|
|
* `BaseText` to.
|
|
|
|
* @param caseSensitivity Defines whether comparison should be
|
|
|
|
* case-sensitive. By default it is.
|
|
|
|
* @param formatSensitivity Defines whether comparison should be
|
|
|
|
* sensitive for color information. By default it is not.
|
|
|
|
* @return `true` if the caller `BaseText` is equal to the `stringToCompare`
|
|
|
|
* under specified parameters and `false` otherwise.
|
|
|
|
*/
|
|
|
|
public final function bool CompareToFormattedString(
|
|
|
|
string stringToCompare,
|
|
|
|
optional CaseSensitivity caseSensitivity,
|
|
|
|
optional FormatSensitivity formatSensitivity)
|
|
|
|
{
|
|
|
|
local MutableText builder;
|
|
|
|
local bool result;
|
|
|
|
builder = MutableText(_.memory.Allocate(class'MutableText'));
|
|
|
|
builder.AppendFormattedString(stringToCompare);
|
|
|
|
result = Compare(builder, caseSensitivity, formatSensitivity);
|
|
|
|
builder.FreeSelf();
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns character at position given by `position`.
|
|
|
|
*
|
|
|
|
* Character is returned along with it's color information.
|
|
|
|
*
|
|
|
|
* If you do not care about color, you might want to use
|
|
|
|
* `GetRawCharacter()` method that's slightly faster.
|
|
|
|
*
|
|
|
|
* Does some optimizations to speed up lookup of the characters,
|
|
|
|
* when they are looked up in order of increasing `position`.
|
|
|
|
*
|
|
|
|
* @param position Position of the character to return.
|
|
|
|
* First character is at `0`.
|
|
|
|
* @return Character at required position. If `position` was out of bounds
|
|
|
|
* (`< 0` or `>= self.GetLength()`), returns invalid character instead.
|
|
|
|
*/
|
|
|
|
public final function Character GetCharacter(int position)
|
|
|
|
{
|
|
|
|
local Character result;
|
|
|
|
if (position < 0) return _.text.GetInvalidCharacter();
|
|
|
|
if (position >= codePoints.length) return _.text.GetInvalidCharacter();
|
|
|
|
|
|
|
|
result.codePoint = codePoints[position];
|
|
|
|
result.formatting = GetFormatting(position);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns character at position given by `position`.
|
|
|
|
*
|
|
|
|
* Character is returned without it's color information
|
|
|
|
* (guaranteed to have `.formatting.isColored == false`).
|
|
|
|
*
|
|
|
|
* Unlike `GetCharacter()` does not optimizations.
|
|
|
|
*
|
|
|
|
* @param position Position of the character to return.
|
|
|
|
* First character is at `0`.
|
|
|
|
* @return Character at required position, without any color information.
|
|
|
|
* If `position` was out of bounds (`< 0` or `>= self.GetLength()`),
|
|
|
|
* returns invalid character instead.
|
|
|
|
*/
|
|
|
|
public final function Character GetRawCharacter(int position)
|
|
|
|
{
|
|
|
|
local Character result;
|
|
|
|
if (position < 0) return _.text.GetInvalidCharacter();
|
|
|
|
if (position >= codePoints.length) return _.text.GetInvalidCharacter();
|
|
|
|
|
|
|
|
result.codePoint = codePoints[position];
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Appends new code point to the `BaseText`'s data.
|
|
|
|
* Allows to create mutable child classes.
|
|
|
|
*
|
|
|
|
* Formatting of this code point needs to be set beforehand by
|
|
|
|
* `SetFormatting()` method.
|
|
|
|
*
|
|
|
|
* @param codePoint Code point to append, does nothing for
|
|
|
|
* invalid (`< 1`) code points.
|
|
|
|
* @return Returns caller `BaseText`, to allow for method chaining.
|
|
|
|
*/
|
|
|
|
protected final function BaseText AppendCodePoint(int codePoint)
|
|
|
|
{
|
|
|
|
local FormattingChunk newChunk;
|
|
|
|
codePoints[codePoints.length] = codePoint;
|
|
|
|
if (formattingUpdated)
|
|
|
|
{
|
|
|
|
newChunk.startIndex = codePoints.length - 1;
|
|
|
|
newChunk.formatting = nextFormatting;
|
|
|
|
formattingChunks[formattingChunks.length] = newChunk;
|
|
|
|
formattingUpdated = false;
|
|
|
|
}
|
|
|
|
return self;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Appends several new code points to the `BaseText`'s data.
|
|
|
|
* Convenience method over existing `AppendCodePoint()`.
|
|
|
|
*
|
|
|
|
* Formatting of these code points needs to be set beforehand by
|
|
|
|
* `SetFormatting()` method.
|
|
|
|
*
|
|
|
|
* @return Returns caller `BaseText`, to allow for method chaining.
|
|
|
|
*/
|
|
|
|
protected final function BaseText AppendManyCodePoints(array<int> codePoints)
|
|
|
|
{
|
|
|
|
local int i;
|
|
|
|
for (i = 0; i < codePoints.length; i += 1) {
|
|
|
|
AppendCodePoint(codePoints[i]);
|
|
|
|
}
|
|
|
|
return self;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Drops all of the code points in the caller `BaseText`.
|
|
|
|
* Allows to easier create mutable child classes.
|
|
|
|
*
|
|
|
|
* @return Returns caller `BaseText`, to allow for method chaining.
|
|
|
|
*/
|
|
|
|
protected final function BaseText DropCodePoints() {
|
|
|
|
codePoints.length = 0;
|
|
|
|
formattingChunks.length = 0;
|
|
|
|
return self;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets `newFormatting` for every non-formatted character in
|
|
|
|
* the caller `BaseText`.
|
|
|
|
* Allows to create mutable child classes.
|
|
|
|
*
|
|
|
|
* @param newFormatting Formatting to use for all non-formatted character in
|
|
|
|
* the caller `BaseText`. If `newFormatting` is not colored itself -
|
|
|
|
* method does nothing.
|
|
|
|
* @return Returns caller `BaseText`, to allow for method chaining.
|
|
|
|
*/
|
|
|
|
protected final function BaseText _changeDefaultFormatting(
|
|
|
|
Formatting newFormatting)
|
|
|
|
{
|
|
|
|
local int i;
|
|
|
|
local FormattingChunk newFormattingChunk;
|
|
|
|
local array<FormattingChunk> newFormattingChunks;
|
|
|
|
if (!newFormatting.isColored) {
|
|
|
|
return self;
|
|
|
|
}
|
|
|
|
newFormattingChunk.formatting = newFormatting;
|
|
|
|
if ( formattingChunks.length <= 0
|
|
|
|
|| formattingChunks[0].startIndex > 0)
|
|
|
|
{
|
|
|
|
newFormattingChunks[0] = newFormattingChunk;
|
|
|
|
}
|
|
|
|
while (i < formattingChunks.length)
|
|
|
|
{
|
|
|
|
if (formattingChunks[i].formatting.isColored)
|
|
|
|
{
|
|
|
|
newFormattingChunks[newFormattingChunks.length] =
|
|
|
|
formattingChunks[i];
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
newFormattingChunk.startIndex = formattingChunks[i].startIndex;
|
|
|
|
newFormattingChunks[newFormattingChunks.length] =
|
|
|
|
newFormattingChunk;
|
|
|
|
}
|
|
|
|
i += 1;
|
|
|
|
}
|
|
|
|
formattingChunks = newFormattingChunks;
|
|
|
|
NormalizeFormatting();
|
|
|
|
return self;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets formatting for the next code point(s) to be added by
|
|
|
|
* `AppendCodePoint()` / `AppendManyCodePoints()`.
|
|
|
|
* Allows to create mutable child classes.
|
|
|
|
*
|
|
|
|
* Formatting is not reset by `Append...` calls, i.e. if you are adding
|
|
|
|
* several code points with the same formatting in a row, you only need to
|
|
|
|
* call `SetFormatting()` once.
|
|
|
|
*
|
|
|
|
* @param newFormatting Formatting to use for next code points,
|
|
|
|
* added via `AppendCodePoint()` / `AppendManyCodePoints()` methods.
|
|
|
|
* @return Returns caller `BaseText`, to allow for method chaining.
|
|
|
|
*/
|
|
|
|
protected final function BaseText SetFormatting(
|
|
|
|
optional Formatting newFormatting)
|
|
|
|
{
|
|
|
|
local Formatting lastFormatting;
|
|
|
|
nextFormatting = newFormatting;
|
|
|
|
if (formattingChunks.length > 0)
|
|
|
|
{
|
|
|
|
lastFormatting =
|
|
|
|
formattingChunks[formattingChunks.length - 1].formatting;
|
|
|
|
}
|
|
|
|
formattingUpdated = !_.text.IsFormattingEqual( lastFormatting,
|
|
|
|
nextFormatting);
|
|
|
|
return self;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Checks whether formatting has changed at character at position `position`
|
|
|
|
* (different from formatting of a character before it).
|
|
|
|
*
|
|
|
|
* Helps to compose `string`s from caller `BaseText`.
|
|
|
|
*
|
|
|
|
* If this method is called for the first character (`position == 0`),
|
|
|
|
* then method checks whether that character has any formatting setup
|
|
|
|
* (has a defined color).
|
|
|
|
*
|
|
|
|
* @param position Position of the character to check. Starts from `0`.
|
|
|
|
* @return `true` if formatting of specified character is different from
|
|
|
|
* the previous one (for the first character - if it has a defined color).
|
|
|
|
* `false` if formatting is the same or specified `position` is
|
|
|
|
* out-of-bounds (`< 0` or `>= self.GetLength()`)
|
|
|
|
*/
|
|
|
|
protected final function bool IsFormattingChangedAt(int position)
|
|
|
|
{
|
|
|
|
local int i;
|
|
|
|
UpdateFormattingCacheFor(position);
|
|
|
|
for (i = formattingIndexCache; i < formattingChunks.length; i += 1)
|
|
|
|
{
|
|
|
|
if (formattingChunks[i].startIndex > position) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (formattingChunks[i].startIndex == position) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns formatting information of character at position `position`.
|
|
|
|
*
|
|
|
|
* Does some optimizations to speed up lookup of the formatting,
|
|
|
|
* when they are looked up in order of increasing `position`.
|
|
|
|
*
|
|
|
|
* @param position Position of the character to get formatting for.
|
|
|
|
* Starts from `0`.
|
|
|
|
* @return Formatting of requested character. Default formatting with
|
|
|
|
* undefined color, if `position is out-of-bounds
|
|
|
|
* (`< 0` or `>= self.GetLength()`).
|
|
|
|
*/
|
|
|
|
public final function Formatting GetFormatting(int position)
|
|
|
|
{
|
|
|
|
local int i;
|
|
|
|
local Formatting result;
|
|
|
|
UpdateFormattingCacheFor(position);
|
|
|
|
for (i = formattingIndexCache; i < formattingChunks.length; i += 1)
|
|
|
|
{
|
|
|
|
if (formattingChunks[i].startIndex > position) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
i -= 1;
|
|
|
|
if (i < 0) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
return formattingChunks[i].formatting;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Verifies that current `formattingIndexCache` can be used as a starting
|
|
|
|
// position to look up for formatting of symbol at `index`.
|
|
|
|
// If it cannot - resets it to zero.
|
|
|
|
private final function UpdateFormattingCacheFor(int index)
|
|
|
|
{
|
|
|
|
if ( formattingIndexCache < 0
|
|
|
|
|| formattingIndexCache >= formattingChunks.length) {
|
|
|
|
formattingIndexCache = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (formattingChunks[formattingIndexCache].startIndex > index) {
|
|
|
|
formattingIndexCache = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Removes possible unnecessary chunks from `formattingChunks`:
|
|
|
|
// if there is a chunk that tells us to have red color after index `3` and
|
|
|
|
// next one tells us to have red color after index `5` - the second chunk is
|
|
|
|
// unnecessary.
|
|
|
|
private final function NormalizeFormatting()
|
|
|
|
{
|
|
|
|
local int i;
|
|
|
|
while (i < formattingChunks.length - 1)
|
|
|
|
{
|
|
|
|
if (_.text.IsFormattingEqual( formattingChunks[i].formatting,
|
|
|
|
formattingChunks[i + 1].formatting))
|
|
|
|
{
|
|
|
|
formattingChunks.Remove(i + 1, 1);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
i += 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Converts data from the caller `BaseText` instance into a plain `string`.
|
|
|
|
* Can be used to extract only substrings.
|
|
|
|
*
|
|
|
|
* If provided parameters `startIndex` and `maxLength` define a range that
|
|
|
|
* goes beyond `[0; self.GetLength() - 1]`, then intersection with a valid
|
|
|
|
* range will be used.
|
|
|
|
*
|
|
|
|
* @param startIndex Position of the first symbol to extract into a
|
|
|
|
* plain `string`. By default `0`, corresponding to the first symbol.
|
|
|
|
* @param maxLength Max length of the extracted string. By default `0`,
|
|
|
|
* - that and all negative values are replaces by `MaxInt`,
|
|
|
|
* effectively extracting as much of a `string` as possible.
|
|
|
|
* @return Plain `string` representation of the caller `BaseText`,
|
|
|
|
* i.e. `string` without any color information inside.
|
|
|
|
*/
|
|
|
|
public final function string ToString(
|
|
|
|
optional int startIndex,
|
|
|
|
optional int maxLength)
|
|
|
|
{
|
|
|
|
local int i;
|
|
|
|
local string result;
|
|
|
|
if (maxLength <= 0) {
|
|
|
|
maxLength = MaxInt;
|
|
|
|
}
|
|
|
|
else if (startIndex < 0) {
|
|
|
|
maxLength += startIndex;
|
|
|
|
}
|
|
|
|
startIndex = Max(0, startIndex);
|
|
|
|
for (i = startIndex; i < codePoints.length; i += 1)
|
|
|
|
{
|
|
|
|
if (maxLength <= 0) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
maxLength -= 1;
|
|
|
|
result $= Chr(codePoints[i]);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Converts data from the caller `BaseText` instance into a colored `string`.
|
|
|
|
* Can be used to extract only substrings.
|
|
|
|
*
|
|
|
|
* Guaranteed to add a color tag (possibly of `defaultColor`parameter)
|
|
|
|
* at the beginning of the returned `string`.
|
|
|
|
*
|
|
|
|
* If provided parameters `startIndex` and `maxLength` define a range that
|
|
|
|
* goes beyond `[0; self.GetLength() - 1]`, then intersection with a valid
|
|
|
|
* range will be used.
|
|
|
|
*
|
|
|
|
* @param startIndex Position of the first symbol to extract into a
|
|
|
|
* colored `string`. By default `0`, corresponding to the first symbol.
|
|
|
|
* @param maxLength Max length of the extracted string. By default `0`,
|
|
|
|
* - that and all negative values are replaces by `MaxInt`,
|
|
|
|
* effectively extracting as much of a `string` as possible.
|
|
|
|
* NOTE: this parameter only counts actual visible symbols, ignoring
|
|
|
|
* 4-byte color code sequences, so method `Len()`, applied to
|
|
|
|
* the result of `ToColoredString()`, will return a bigger value
|
|
|
|
* than `maxLength`.
|
|
|
|
* @param defaultColor Color to be applied to the parts of the string that
|
|
|
|
* do not have any specified color.
|
|
|
|
* This is necessary, since 4-byte color sequences cannot unset the color.
|
|
|
|
* @return Colored `string` representation of the caller `BaseText`,
|
|
|
|
* i.e. `string` without any color information inside.
|
|
|
|
*/
|
|
|
|
public final function string ToColoredString(
|
|
|
|
optional int startIndex,
|
|
|
|
optional int maxLength,
|
|
|
|
optional Color defaultColor)
|
|
|
|
{
|
|
|
|
local int i;
|
|
|
|
local Formatting newFormatting;
|
|
|
|
local Color nextColor, appliedColor;
|
|
|
|
local string result;
|
|
|
|
if (maxLength <= 0) {
|
|
|
|
maxLength = MaxInt;
|
|
|
|
}
|
|
|
|
else if (startIndex < 0) {
|
|
|
|
maxLength += startIndex;
|
|
|
|
}
|
|
|
|
startIndex = Max(0, startIndex);
|
|
|
|
// `appliedColor` will contain perfect black and so,
|
|
|
|
// guaranteed to be different from any actually used color
|
|
|
|
defaultColor = _.color.FixColor(defaultColor);
|
|
|
|
for (i = startIndex; i < codePoints.length; i += 1)
|
|
|
|
{
|
|
|
|
if (maxLength <= 0) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
maxLength -= 1;
|
|
|
|
if (IsFormattingChangedAt(i) || i == startIndex)
|
|
|
|
{
|
|
|
|
newFormatting = GetFormatting(i);
|
|
|
|
if (newFormatting.isColored) {
|
|
|
|
nextColor = _.color.FixColor(newFormatting.color);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
nextColor = defaultColor;
|
|
|
|
}
|
|
|
|
// Colors are already fixed (and will be different from
|
|
|
|
// `appliedColor` before we initialize it)
|
|
|
|
if (!_.color.AreEqual(nextColor, appliedColor))
|
|
|
|
{
|
|
|
|
result $= Chr(CODEPOINT_ESCAPE);
|
|
|
|
result $= Chr(nextColor.r);
|
|
|
|
result $= Chr(nextColor.g);
|
|
|
|
result $= Chr(nextColor.b);
|
|
|
|
appliedColor = nextColor;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
result $= Chr(codePoints[i]);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Converts data from the caller `BaseText` instance into a `Text` containing
|
|
|
|
* formatted `string`.
|
|
|
|
* Can be used to extract only substrings.
|
|
|
|
*
|
|
|
|
* If provided parameters `startIndex` and `maxLength` define a range that
|
|
|
|
* goes beyond `[0; self.GetLength() - 1]`, then intersection with a valid
|
|
|
|
* range will be used.
|
|
|
|
*
|
|
|
|
* @param startIndex Position of the first symbol to extract into a
|
|
|
|
* formatted `string`. By default `0`, corresponding to the first symbol.
|
|
|
|
* @param maxLength Max length of the extracted `string`.
|
|
|
|
* By default `0` - that and all negative values are replaces by `MaxInt`,
|
|
|
|
* effectively extracting as much of a `string` as possible.
|
|
|
|
* NOTE: this parameter only counts actual visible symbols,
|
|
|
|
* ignoring formatting blocks ('{<color> }')
|
|
|
|
* or escape sequences (i.e. '&{' is one character),
|
|
|
|
* so method `Len()`, applied to the result of
|
|
|
|
* `ToFormattedString()`, will return a bigger value
|
|
|
|
* than `maxLength`.
|
|
|
|
* @return Formatted string representation inside `Text` of the caller
|
|
|
|
* `BaseText`.
|
|
|
|
*/
|
|
|
|
public final function Text ToFormattedText(
|
|
|
|
optional int startIndex,
|
|
|
|
optional int maxLength)
|
|
|
|
{
|
|
|
|
return ToFormattedTextM(startIndex, maxLength).IntoText();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Converts data from the caller `BaseText` instance into a `MutableText`
|
|
|
|
* containing formatted `string`.
|
|
|
|
* Can be used to extract only substrings.
|
|
|
|
*
|
|
|
|
* If provided parameters `startIndex` and `maxLength` define a range that
|
|
|
|
* goes beyond `[0; self.GetLength() - 1]`, then intersection with a valid
|
|
|
|
* range will be used.
|
|
|
|
*
|
|
|
|
* @param startIndex Position of the first symbol to extract into a
|
|
|
|
* formatted `string`. By default `0`, corresponding to the first symbol.
|
|
|
|
* @param maxLength Max length of the extracted `string`.
|
|
|
|
* By default `0` - that and all negative values are replaces by `MaxInt`,
|
|
|
|
* effectively extracting as much of a `string` as possible.
|
|
|
|
* NOTE: this parameter only counts actual visible symbols,
|
|
|
|
* ignoring formatting blocks ('{<color> }')
|
|
|
|
* or escape sequences (i.e. '&{' is one character),
|
|
|
|
* so method `Len()`, applied to the result of
|
|
|
|
* `ToFormattedString()`, will return a bigger value
|
|
|
|
* than `maxLength`.
|
|
|
|
* @return Formatted string representation inside `MutableText` of the caller
|
|
|
|
* `BaseText`.
|
|
|
|
*/
|
|
|
|
public final function MutableText ToFormattedTextM(
|
|
|
|
optional int startIndex,
|
|
|
|
optional int maxLength)
|
|
|
|
{
|
|
|
|
local int i;
|
|
|
|
local bool isInsideBlock;
|
|
|
|
local MutableText result;
|
|
|
|
local Formatting newFormatting;
|
|
|
|
|
|
|
|
if (maxLength <= 0) {
|
|
|
|
maxLength = MaxInt;
|
|
|
|
}
|
|
|
|
else if (startIndex < 0) {
|
|
|
|
maxLength += startIndex;
|
|
|
|
}
|
|
|
|
startIndex = Max(0, startIndex);
|
|
|
|
result = _.text.Empty();
|
|
|
|
for (i = startIndex; i < codePoints.length; i += 1)
|
|
|
|
{
|
|
|
|
if (maxLength <= 0) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
maxLength -= 1;
|
|
|
|
if (IsFormattingChangedAt(i) || i == startIndex)
|
|
|
|
{
|
|
|
|
newFormatting = GetFormatting(i);
|
|
|
|
if (isInsideBlock && i != startIndex)
|
|
|
|
{
|
|
|
|
result.AppendString(STRING_CLOSE_FORMAT);
|
|
|
|
isInsideBlock = false;
|
|
|
|
}
|
|
|
|
if (newFormatting.isColored)
|
|
|
|
{
|
|
|
|
result
|
|
|
|
.AppendString(STRING_OPEN_FORMAT)
|
|
|
|
.Append(_.color.ToText(newFormatting.color))
|
|
|
|
.AppendString(STRING_SEPARATOR_FORMAT);
|
|
|
|
isInsideBlock = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ( codePoints[i] == CODEPOINT_OPEN_FORMAT
|
|
|
|
|| codePoints[i] == CODEPOINT_CLOSE_FORMAT)
|
|
|
|
{
|
|
|
|
result.AppendString(STRING_FORMAT_ESCAPE);
|
|
|
|
}
|
|
|
|
result.AppendString(Chr(codePoints[i]));
|
|
|
|
}
|
|
|
|
if (isInsideBlock) {
|
|
|
|
result.AppendString(STRING_CLOSE_FORMAT);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Converts data from the caller `BaseText` instance into a formatted `string`.
|
|
|
|
* Can be used to extract only substrings.
|
|
|
|
*
|
|
|
|
* If provided parameters `startIndex` and `maxLength` define a range that
|
|
|
|
* goes beyond `[0; self.GetLength() - 1]`, then intersection with a valid
|
|
|
|
* range will be used.
|
|
|
|
*
|
|
|
|
* @param startIndex Position of the first symbol to extract into a
|
|
|
|
* formatted `string`. By default `0`, corresponding to the first symbol.
|
|
|
|
* @param maxLength Max length of the extracted `string`.
|
|
|
|
* By default `0` - that and all negative values are replaces by `MaxInt`,
|
|
|
|
* effectively extracting as much of a `string` as possible.
|
|
|
|
* NOTE: this parameter only counts actual visible symbols,
|
|
|
|
* ignoring formatting blocks ('{<color> }')
|
|
|
|
* or escape sequences (i.e. '&{' is one character),
|
|
|
|
* so method `Len()`, applied to the result of
|
|
|
|
* `ToFormattedString()`, will return a bigger value
|
|
|
|
* than `maxLength`.
|
|
|
|
* @return Formatted `string` representation of the caller `BaseText`,
|
|
|
|
* i.e. `string` without any color information inside.
|
|
|
|
*/
|
|
|
|
public final function string ToFormattedString(
|
|
|
|
optional int startIndex,
|
|
|
|
optional int maxLength)
|
|
|
|
{
|
|
|
|
return _.text.IntoString(ToFormattedTextM(startIndex, maxLength));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Splits the string into substrings wherever `separator` occurs, and returns
|
|
|
|
* array of those strings.
|
|
|
|
*
|
|
|
|
* If `separator` does not match anywhere in the string, method returns a
|
|
|
|
* single-element array containing copy of this `Text`.
|
|
|
|
*
|
|
|
|
* @param separator Character that separates different parts of
|
|
|
|
* this `Text`. If `separator` is an invalid character, method will do
|
|
|
|
* nothing and return empty result.
|
|
|
|
* @param skipEmpty Set this to `true` to filter out empty
|
|
|
|
* `MutableText`s from the output.
|
|
|
|
* @param returnMutable Decides whether this method will return
|
|
|
|
* `Text` (`false`, by default) or `MutableText` (`true`) instances.
|
|
|
|
* @return Array of `BaseText`s (whether it's `Text` or `MutableText` depends
|
|
|
|
* on `returnMutable` parameter) that contain separated substrings.
|
|
|
|
* Always empty if `separator` is an invalid character.
|
|
|
|
*/
|
|
|
|
public final function array<BaseText> SplitByCharacter(
|
|
|
|
Character separator,
|
|
|
|
optional bool skipEmpty,
|
|
|
|
optional bool returnMutable)
|
|
|
|
{
|
|
|
|
local int i, length;
|
|
|
|
local Character nextCharacter;
|
|
|
|
local MutableText nextText;
|
|
|
|
local array<BaseText> result;
|
|
|
|
if (!_.text.IsValidCharacter(separator)) {
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
length = GetLength();
|
|
|
|
nextText = _.text.Empty();
|
|
|
|
i = 0;
|
|
|
|
while (i < length)
|
|
|
|
{
|
|
|
|
nextCharacter = GetCharacter(i);
|
|
|
|
if (_.text.AreEqual(separator, nextCharacter))
|
|
|
|
{
|
|
|
|
if (!skipEmpty || !nextText.IsEmpty())
|
|
|
|
{
|
|
|
|
if (returnMutable) {
|
|
|
|
result[result.length] = nextText;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
result[result.length] = nextText.IntoText();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
_.memory.Free(nextText);
|
|
|
|
}
|
|
|
|
nextText = _.text.Empty();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
nextText.AppendCharacter(nextCharacter);
|
|
|
|
}
|
|
|
|
i += 1;
|
|
|
|
}
|
|
|
|
if (!skipEmpty || !nextText.IsEmpty())
|
|
|
|
{
|
|
|
|
if (returnMutable) {
|
|
|
|
result[result.length] = nextText;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
result[result.length] = nextText.IntoText();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Splits the string into substrings wherever `separator` occurs, and returns
|
|
|
|
* array of those strings.
|
|
|
|
*
|
|
|
|
* If `separator` does not match anywhere in the string, method returns a
|
|
|
|
* single-element array containing copy of this `Text`.
|
|
|
|
*
|
|
|
|
* @param separatorSource `string`, first character of which will be used as
|
|
|
|
* a separator. If `separatorSource` is empty, method will do nothing and
|
|
|
|
* return empty result.
|
|
|
|
* @param skipEmpty Set this to `true` to filter out empty
|
|
|
|
* `MutableText`s from the output.
|
|
|
|
* @param returnMutable Decides whether this method will return
|
|
|
|
* `Text` (`false`, by default) or `MutableText` (`true`) instances.
|
|
|
|
* @return Array of `BaseText`s (whether it's `Text` or `MutableText` depends
|
|
|
|
* on `returnMutable` parameter) that contain separated substrings.
|
|
|
|
* Always empty if `separatorSource` is empty.
|
|
|
|
*/
|
|
|
|
public final function array<BaseText> SplitByCharacterS(
|
|
|
|
string separatorSource,
|
|
|
|
optional bool skipEmpty,
|
|
|
|
optional bool returnMutable)
|
|
|
|
{
|
|
|
|
local Character separator;
|
|
|
|
separator = _.text.GetCharacter(separatorSource, 0);
|
|
|
|
return SplitByCharacter(separator, skipEmpty, returnMutable);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the index position of the first occurrence of the `otherText` in
|
|
|
|
* the caller `BaseText`, searching forward from index position `fromIndex`.
|
|
|
|
*
|
|
|
|
* @param otherText `BaseText` data to find inside the caller
|
|
|
|
* `BaseText`.
|
|
|
|
* @param fromIndex Index from which we should start searching.
|
|
|
|
* @param caseSensitivity Defines whether comparison should be
|
|
|
|
* case-sensitive. By default it is.
|
|
|
|
* @param formatSensitivity Defines whether comparison should be
|
|
|
|
* sensitive for color information. By default it is not.
|
|
|
|
* @return `-1` if `otherText` is not found after `fromIndex`.
|
|
|
|
*/
|
|
|
|
public final function int IndexOf(
|
|
|
|
BaseText otherText,
|
|
|
|
optional int fromIndex,
|
|
|
|
optional CaseSensitivity caseSensitivity,
|
|
|
|
optional FormatSensitivity formatSensitivity)
|
|
|
|
{
|
|
|
|
local int startCandidate;
|
|
|
|
local int index, otherIndex;
|
|
|
|
local Character char1, char2;
|
|
|
|
if (otherText == none) return -1;
|
|
|
|
if (fromIndex > GetLength()) return -1;
|
|
|
|
if (GetLength() - fromIndex < otherText.GetLength()) return -1;
|
|
|
|
if (otherText.IsEmpty()) return fromIndex;
|
|
|
|
|
|
|
|
startCandidate = fromIndex;
|
|
|
|
for (index = fromIndex; index < GetLength(); index += 1)
|
|
|
|
{
|
|
|
|
char1 = GetCharacter(index);
|
|
|
|
char2 = otherText.GetCharacter(otherIndex);
|
|
|
|
if ( NormalizeCodePoint(char1.codePoint, caseSensitivity)
|
|
|
|
!= NormalizeCodePoint(char2.codePoint, caseSensitivity))
|
|
|
|
{
|
|
|
|
startCandidate = index + 1;
|
|
|
|
otherIndex = 0;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if ( formatSensitivity == SFORM_SENSITIVE
|
|
|
|
&& !_.text.IsFormattingEqual(char1.formatting, char2.formatting))
|
|
|
|
{
|
|
|
|
startCandidate = index + 1;
|
|
|
|
otherIndex = 0;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
otherIndex += 1;
|
|
|
|
if (otherIndex == otherText.GetLength()) {
|
|
|
|
return startCandidate;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the index position of the last occurrence of the `otherText` in
|
|
|
|
* the caller `BaseText`, searching backward from index position `fromIndex`,
|
|
|
|
* counted the end of the caller `BaseText`.
|
|
|
|
*
|
|
|
|
* @param otherText `BaseText` data to find inside the caller
|
|
|
|
* `BaseText`.
|
|
|
|
* @param fromIndex Index from which we should start searching, but
|
|
|
|
* it's counted from the end of the caller `BaseText`: `0` means starting
|
|
|
|
* from the last character, `1` means next to last, etc.
|
|
|
|
* @param caseSensitivity Defines whether comparison should be
|
|
|
|
* case-sensitive. By default it is.
|
|
|
|
* @param formatSensitivity Defines whether comparison should be
|
|
|
|
* sensitive for color information. By default it is not.
|
|
|
|
* @return `-1` if `otherText` is not found starting `fromIndex`
|
|
|
|
* (this index is counted from the end of the caller `BaseText`).
|
|
|
|
*/
|
|
|
|
public final function int LastIndexOf(
|
|
|
|
BaseText otherText,
|
|
|
|
optional int fromIndex,
|
|
|
|
optional CaseSensitivity caseSensitivity,
|
|
|
|
optional FormatSensitivity formatSensitivity)
|
|
|
|
{
|
|
|
|
local int startCandidate;
|
|
|
|
local int index, otherIndex;
|
|
|
|
local Character char1, char2;
|
|
|
|
if (otherText == none) return -1;
|
|
|
|
if (fromIndex > GetLength()) return -1;
|
|
|
|
if (GetLength() - fromIndex < otherText.GetLength()) return -1;
|
|
|
|
if (otherText.IsEmpty()) return fromIndex;
|
|
|
|
|
|
|
|
otherIndex = otherText.GetLength() - 1;
|
|
|
|
startCandidate = GetLength() - fromIndex - 1;
|
|
|
|
for (index = startCandidate; index >= 0; index -= 1)
|
|
|
|
{
|
|
|
|
char1 = GetCharacter(index);
|
|
|
|
char2 = otherText.GetCharacter(otherIndex);
|
|
|
|
if ( NormalizeCodePoint(char1.codePoint, caseSensitivity)
|
|
|
|
!= NormalizeCodePoint(char2.codePoint, caseSensitivity))
|
|
|
|
{
|
|
|
|
startCandidate = index - 1;
|
|
|
|
otherIndex = otherText.GetLength() - 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if ( formatSensitivity == SFORM_SENSITIVE
|
|
|
|
&& !_.text.IsFormattingEqual(char1.formatting, char2.formatting))
|
|
|
|
{
|
|
|
|
startCandidate = index - 1;
|
|
|
|
otherIndex = otherText.GetLength() - 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
otherIndex -= 1;
|
|
|
|
if (otherIndex < 0) {
|
|
|
|
return startCandidate - (otherText.GetLength() - 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This method frees caller `MutableText` and returns immutable `Text`
|
|
|
|
* copy instead.
|
|
|
|
*
|
|
|
|
* @return Immutable `Text` copy of the caller `MutableText`.
|
|
|
|
*/
|
|
|
|
public function Text IntoText()
|
|
|
|
{
|
|
|
|
return none;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This method frees caller `Text` and returns immutable `Text` copy instead.
|
|
|
|
*
|
|
|
|
* @return Immutable `Text` copy of the caller `MutableText`.
|
|
|
|
*/
|
|
|
|
public function MutableText IntoMutableText()
|
|
|
|
{
|
|
|
|
return none;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Creates `Parser` to parse caller `BaseText`.
|
|
|
|
*
|
|
|
|
* @return `Parser` that is setup to parse caller `BaseText`.
|
|
|
|
* Guaranteed to not be `none`.
|
|
|
|
*/
|
|
|
|
public final function Parser Parse()
|
|
|
|
{
|
|
|
|
return _.text.Parse(self);
|
|
|
|
}
|
|
|
|
|
|
|
|
defaultproperties
|
|
|
|
{
|
|
|
|
STRING_SEPARATOR_FORMAT = " "
|
|
|
|
STRING_OPEN_FORMAT = "{"
|
|
|
|
STRING_CLOSE_FORMAT = "}"
|
|
|
|
STRING_FORMAT_ESCAPE = "&"
|
|
|
|
CODEPOINT_ESCAPE = 27 // ASCII escape code
|
|
|
|
CODEPOINT_OPEN_FORMAT = 123 // '{'
|
|
|
|
CODEPOINT_CLOSE_FORMAT = 125 // '}'
|
|
|
|
CODEPOINT_FORMAT_ESCAPE = 38 // '&'
|
|
|
|
}
|