818 lines
33 KiB
C#
818 lines
33 KiB
C#
|
|
//------------------------------------------------------------------------------
|
|
// <auto-generated>
|
|
// This code was generated by a tool.
|
|
//
|
|
// TextTransform Samples/Packages/com.unity.collections/Unity.Collections/HeapString.tt
|
|
//
|
|
// Changes to this file may cause incorrect behavior and will be lost if
|
|
// the code is regenerated.
|
|
// </auto-generated>
|
|
//------------------------------------------------------------------------------
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Runtime.InteropServices;
|
|
using System.Runtime.CompilerServices;
|
|
using Unity.Collections.LowLevel.Unsafe;
|
|
using UnityEngine.Internal;
|
|
#if UNITY_PROPERTIES_EXISTS
|
|
using Unity.Properties;
|
|
#endif
|
|
|
|
|
|
|
|
namespace Unity.Collections
|
|
{
|
|
/// <summary>
|
|
/// An unmanaged, allocated, mutable, resizable UTF-8 string.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The string is always null-terminated, meaning a zero byte always immediately follows the last character.
|
|
/// </remarks>
|
|
[BurstCompatible]
|
|
[Obsolete("HeapString has been removed and replaced with NativeText (RemovedAfter 2021-07-21) (UnityUpgradable) -> NativeText", false)]
|
|
public partial struct HeapString
|
|
: INativeList<byte>
|
|
, IDisposable
|
|
, IUTF8Bytes
|
|
, IComparable<String>
|
|
, IEquatable<String>
|
|
, IComparable<HeapString>
|
|
, IEquatable<HeapString>
|
|
, IComparable<FixedString32Bytes>
|
|
, IEquatable<FixedString32Bytes>
|
|
, IComparable<FixedString64Bytes>
|
|
, IEquatable<FixedString64Bytes>
|
|
, IComparable<FixedString128Bytes>
|
|
, IEquatable<FixedString128Bytes>
|
|
, IComparable<FixedString512Bytes>
|
|
, IEquatable<FixedString512Bytes>
|
|
, IComparable<FixedString4096Bytes>
|
|
, IEquatable<FixedString4096Bytes>
|
|
{
|
|
// NOTE! This Length is always > 0, because we have a null terminating byte.
|
|
// We hide this byte from HeapString users.
|
|
private NativeList<byte> m_Data;
|
|
|
|
/// <summary>
|
|
/// The current length in bytes of this string.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The length does not include the null terminator byte.
|
|
/// </remarks>
|
|
/// <value>The current length in bytes of the UTF-8 encoded string.</value>
|
|
public int Length
|
|
{
|
|
get {
|
|
return m_Data.Length - 1;
|
|
}
|
|
set {
|
|
m_Data.Resize(value + 1, NativeArrayOptions.UninitializedMemory);
|
|
m_Data[value] = 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The current capacity of this string.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The null-terminator byte is not included in the Capacity, so the string's character buffer is `Capacity + 1` in size.
|
|
/// </remarks>
|
|
/// <value>The current capacity of the string.</value>
|
|
public int Capacity
|
|
{
|
|
get {
|
|
return m_Data.Capacity - 1;
|
|
}
|
|
set {
|
|
m_Data.Capacity = value + 1;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Attempt to set the length in bytes of this string.
|
|
/// </summary>
|
|
/// <param name="newLength">The new length in bytes of the string.</param>
|
|
/// <param name="clearOptions">Whether any bytes added should be zeroed out.</param>
|
|
/// <returns>Always true.</returns>
|
|
public bool TryResize(int newLength, NativeArrayOptions clearOptions = NativeArrayOptions.ClearMemory)
|
|
{
|
|
// this can't ever fail, because if we can't resize malloc will abort
|
|
Length = newLength;
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Whether this string has no characters.
|
|
/// </summary>
|
|
/// <value>True if this string has no characters.</value>
|
|
public bool IsEmpty => m_Data.Length == 1;
|
|
|
|
/// <summary>
|
|
/// Whether this string's character buffer has been allocated and not yet deallocated.
|
|
/// </summary>
|
|
/// <value>Whether this string's character buffer has been allocated and not yet deallocated.</value>
|
|
public bool IsCreated => m_Data.IsCreated;
|
|
|
|
/// <summary>
|
|
/// Returns a pointer to this string's character buffer.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The pointer is made invalid by operations that reallocate the character buffer, such as setting <see cref="Capacity"/>.
|
|
/// </remarks>
|
|
/// <returns>A pointer to this string's character buffer.</returns>
|
|
public unsafe byte* GetUnsafePtr()
|
|
{
|
|
return (byte*) m_Data.GetUnsafePtr();
|
|
}
|
|
|
|
/// <summary>
|
|
/// The byte at an index.
|
|
/// </summary>
|
|
/// <param name="index">A zero-based byte index.</param>
|
|
/// <value>The byte at the index.</value>
|
|
/// <exception cref="IndexOutOfRangeException">Thrown if the index is out of bounds.</exception>
|
|
public byte this[int index]
|
|
{
|
|
get {
|
|
CheckIndexInRange(index);
|
|
return m_Data[index];
|
|
}
|
|
set {
|
|
CheckIndexInRange(index);
|
|
m_Data[index] = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the reference to the byte (not character) at an index.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Deallocating or reallocating this string's character buffer makes the reference invalid.
|
|
/// </remarks>
|
|
/// <param name="index">A byte index.</param>
|
|
/// <returns>A reference to the byte at the index.</returns>
|
|
/// <exception cref="IndexOutOfRangeException">Thrown if the index is out of bounds.</exception>
|
|
public ref byte ElementAt(int index)
|
|
{
|
|
CheckIndexInRange(index);
|
|
return ref m_Data.ElementAt(index);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the length to 0.
|
|
/// </summary>
|
|
public void Clear()
|
|
{
|
|
Length = 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Appends a byte.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// A zero byte will always follow the newly appended byte.
|
|
///
|
|
/// No validation is performed: it is your responsibility for the bytes of the string to form valid UTF-8 when you're done appending bytes.
|
|
/// </remarks>
|
|
/// <param name="value">A byte to append.</param>
|
|
public void Add(in byte value)
|
|
{
|
|
this[Length++] = value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the lexicographical sort order of this string relative to another.
|
|
/// </summary>
|
|
/// <param name="other">Another string to compare with.</param>
|
|
/// <returns>A number denoting the lexicographical sort order of this string relative to the other string:
|
|
///
|
|
/// 0 denotes both strings have the same sort position.<br/>
|
|
/// -1 denotes that this string should be sorted to precede the other.<br/>
|
|
/// +1 denotes that this string should be sorted to follow the other.<br/>
|
|
/// </returns>
|
|
public int CompareTo(HeapString other)
|
|
{
|
|
return FixedStringMethods.CompareTo(ref this, other);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if this string and another are equal.
|
|
/// </summary>
|
|
/// <remarks>Two strings are equal if they have equal length and all their characters match.</remarks>
|
|
/// <param name="other">Another string to compare with.</param>
|
|
/// <returns>True if the two strings are equal.</returns>
|
|
public bool Equals(HeapString other)
|
|
{
|
|
return FixedStringMethods.Equals(ref this, other);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Releases all resources (memory and safety handles).
|
|
/// </summary>
|
|
public void Dispose()
|
|
{
|
|
m_Data.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// A copy of this string as a managed string.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// For internal use only. Use <see cref="ToString"/> instead.
|
|
/// </remarks>
|
|
/// <value>A copy of this string as a managed string.</value>
|
|
[CreateProperty]
|
|
[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
|
|
[NotBurstCompatible]
|
|
public string Value => ToString();
|
|
|
|
/// <summary>
|
|
/// An enumerator over the characters (not bytes) of a HeapString.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// In an enumerator's initial state, its index is invalid. The first <see cref="MoveNext"/> call advances the enumerator's index to the first character.
|
|
/// </remarks>
|
|
public struct Enumerator : IEnumerator<Unicode.Rune>
|
|
{
|
|
HeapString target;
|
|
int offset;
|
|
Unicode.Rune current;
|
|
|
|
/// <summary>
|
|
/// Initializes and returns an instance of HeapString.Enumerator.
|
|
/// </summary>
|
|
/// <param name="source">A HeapString for which to create an enumerator.</param>
|
|
public Enumerator(HeapString source)
|
|
{
|
|
target = source;
|
|
offset = 0;
|
|
current = default;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Does nothing.
|
|
/// </summary>
|
|
public void Dispose()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Advances the enumerator to the next character, returning true if <see cref="Current"/> is valid to read afterwards.
|
|
/// </summary>
|
|
/// <returns>True if <see cref="Current"/> is valid to read after the call.</returns>
|
|
public bool MoveNext()
|
|
{
|
|
if (offset >= target.Length)
|
|
return false;
|
|
|
|
unsafe
|
|
{
|
|
Unicode.Utf8ToUcs(out current, target.GetUnsafePtr(), ref offset, target.Length);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resets the enumerator to its initial state.
|
|
/// </summary>
|
|
public void Reset()
|
|
{
|
|
offset = 0;
|
|
current = default;
|
|
}
|
|
|
|
object IEnumerator.Current => Current;
|
|
|
|
/// <summary>
|
|
/// The current character.
|
|
/// </summary>
|
|
/// <value>The current character.</value>
|
|
public Unicode.Rune Current => current;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns an enumerator for iterating over the characters of the HeapString.
|
|
/// </summary>
|
|
/// <returns>An enumerator for iterating over the characters of the HeapString.</returns>
|
|
public Enumerator GetEnumerator()
|
|
{
|
|
return new Enumerator(this);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the lexicographical sort order of this string relative to another.
|
|
/// </summary>
|
|
/// <param name="other">Another string to compare with.</param>
|
|
/// <returns>A number denoting the lexicographical sort order of this string relative to the other string:
|
|
///
|
|
/// 0 denotes both strings have the same sort position.<br/>
|
|
/// -1 denotes that this string should be sorted to precede the other.<br/>
|
|
/// +1 denotes that this string should be sorted to follow the other.<br/>
|
|
/// </returns>
|
|
[NotBurstCompatible]
|
|
public int CompareTo(String other)
|
|
{
|
|
return ToString().CompareTo(other);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if this string and another are equal.
|
|
/// </summary>
|
|
/// <remarks>Two strings are equal if they have equal length and all their characters match.</remarks>
|
|
/// <param name="other">Another string to compare with.</param>
|
|
/// <returns>True if the two strings are equal.</returns>
|
|
[NotBurstCompatible]
|
|
public bool Equals(String other)
|
|
{
|
|
return ToString().Equals(other);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes and returns an instance of HeapString with the characters copied from another string.
|
|
/// </summary>
|
|
/// <param name="source">A string to copy characters from.</param>
|
|
/// <param name="allocator">The allocator to use.</param>
|
|
[NotBurstCompatible]
|
|
public HeapString(String source, Allocator allocator)
|
|
{
|
|
m_Data = new NativeList<byte>(source.Length * 2 + 1, allocator);
|
|
Length = source.Length * 2; // maximum possible
|
|
unsafe
|
|
{
|
|
fixed (char* sourceptr = source)
|
|
{
|
|
var error = UTF8ArrayUnsafeUtility.Copy(GetUnsafePtr(), out var actualBytes, Capacity, sourceptr, source.Length);
|
|
if (error != CopyError.None)
|
|
{
|
|
m_Data.Dispose();
|
|
m_Data = default;
|
|
ThrowCopyError(error, source);
|
|
}
|
|
this.Length = actualBytes;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes and returns an instance of HeapString with a specified initial capacity.
|
|
/// </summary>
|
|
/// <param name="capacity">The initial capacity in bytes.</param>
|
|
/// <param name="allocator">The allocator to use.</param>
|
|
public HeapString(int capacity, Allocator allocator)
|
|
{
|
|
m_Data = new NativeList<byte>(capacity + 1, allocator);
|
|
this.Length = 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes and returns an instance of HeapString with an initial capacity of 128 bytes.
|
|
/// </summary>
|
|
/// <param name="allocator">The allocator to use.</param>
|
|
public HeapString(Allocator allocator)
|
|
{
|
|
m_Data = new NativeList<byte>(128 + 1, allocator);
|
|
this.Length = 0;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Returns the lexicographical sort order of this string relative to another.
|
|
/// </summary>
|
|
/// <param name="other">Another string to compare with.</param>
|
|
/// <returns>A number denoting the lexicographical sort order of this string relative to the other string:
|
|
///
|
|
/// 0 denotes both strings have the same sort position.<br/>
|
|
/// -1 denotes that this string should be sorted to precede the other.<br/>
|
|
/// +1 denotes that this string should be sorted to follow the other.<br/>
|
|
/// </returns>
|
|
public int CompareTo(FixedString32Bytes other)
|
|
{
|
|
return FixedStringMethods.CompareTo(ref this, other);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Initializes and returns an instance of HeapString with the characters copied from another string.
|
|
/// </summary>
|
|
/// <param name="source">A string to copy characters from.</param>
|
|
/// <param name="allocator">The allocator to use.</param>
|
|
public HeapString(in FixedString32Bytes source, Allocator allocator)
|
|
{
|
|
m_Data = new NativeList<byte>(source.utf8LengthInBytes + 1, allocator);
|
|
Length = source.utf8LengthInBytes;
|
|
|
|
unsafe {
|
|
byte* sbytes = (byte*) UnsafeUtilityExtensions.AddressOf(source.bytes);
|
|
byte* dbytes = (byte*) m_Data.GetUnsafePtr();
|
|
UnsafeUtility.MemCpy(dbytes, sbytes, source.utf8LengthInBytes);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if two strings are equal.
|
|
/// </summary>
|
|
/// <remarks>Two strings are equal if they have equal length and all their characters match.</remarks>
|
|
/// <param name="a">A string to compare.</param>
|
|
/// <param name="b">Another string to compare.</param>
|
|
/// <returns>True if the two strings are equal.</returns>
|
|
public static bool operator ==(in HeapString a, in FixedString32Bytes b)
|
|
{
|
|
unsafe {
|
|
var aref = UnsafeUtilityExtensions.AsRef(a);
|
|
int alen = aref.Length;
|
|
int blen = b.utf8LengthInBytes;
|
|
byte* aptr = (byte*) aref.GetUnsafePtr();
|
|
byte* bptr = (byte*) UnsafeUtilityExtensions.AddressOf(b.bytes);
|
|
return UTF8ArrayUnsafeUtility.EqualsUTF8Bytes(aptr, alen, bptr, blen);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if two strings are unequal.
|
|
/// </summary>
|
|
/// <remarks>Two strings are equal if they have equal length and all their characters match.</remarks>
|
|
/// <param name="a">A string to compare.</param>
|
|
/// <param name="b">Another string to compare.</param>
|
|
/// <returns>True if the two strings are unequal.</returns>
|
|
public static bool operator !=(in HeapString a, in FixedString32Bytes b)
|
|
{
|
|
return !(a == b);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if this string and another are equal.
|
|
/// </summary>
|
|
/// <remarks>Two strings are equal if they have equal length and all their characters match.</remarks>
|
|
/// <param name="other">Another string to compare with.</param>
|
|
/// <returns>True if the two strings are equal.</returns>
|
|
public bool Equals(FixedString32Bytes other)
|
|
{
|
|
return this == other;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the lexicographical sort order of this string relative to another.
|
|
/// </summary>
|
|
/// <param name="other">Another string to compare with.</param>
|
|
/// <returns>A number denoting the lexicographical sort order of this string relative to the other string:
|
|
///
|
|
/// 0 denotes both strings have the same sort position.<br/>
|
|
/// -1 denotes that this string should be sorted to precede the other.<br/>
|
|
/// +1 denotes that this string should be sorted to follow the other.<br/>
|
|
/// </returns>
|
|
public int CompareTo(FixedString64Bytes other)
|
|
{
|
|
return FixedStringMethods.CompareTo(ref this, other);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Initializes and returns an instance of HeapString with the characters copied from another string.
|
|
/// </summary>
|
|
/// <param name="source">A string to copy characters from.</param>
|
|
/// <param name="allocator">The allocator to use.</param>
|
|
public HeapString(in FixedString64Bytes source, Allocator allocator)
|
|
{
|
|
m_Data = new NativeList<byte>(source.utf8LengthInBytes + 1, allocator);
|
|
Length = source.utf8LengthInBytes;
|
|
|
|
unsafe {
|
|
byte* sbytes = (byte*) UnsafeUtilityExtensions.AddressOf(source.bytes);
|
|
byte* dbytes = (byte*) m_Data.GetUnsafePtr();
|
|
UnsafeUtility.MemCpy(dbytes, sbytes, source.utf8LengthInBytes);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if two strings are equal.
|
|
/// </summary>
|
|
/// <remarks>Two strings are equal if they have equal length and all their characters match.</remarks>
|
|
/// <param name="a">A string to compare.</param>
|
|
/// <param name="b">Another string to compare.</param>
|
|
/// <returns>True if the two strings are equal.</returns>
|
|
public static bool operator ==(in HeapString a, in FixedString64Bytes b)
|
|
{
|
|
unsafe {
|
|
var aref = UnsafeUtilityExtensions.AsRef(a);
|
|
int alen = aref.Length;
|
|
int blen = b.utf8LengthInBytes;
|
|
byte* aptr = (byte*) aref.GetUnsafePtr();
|
|
byte* bptr = (byte*) UnsafeUtilityExtensions.AddressOf(b.bytes);
|
|
return UTF8ArrayUnsafeUtility.EqualsUTF8Bytes(aptr, alen, bptr, blen);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if two strings are unequal.
|
|
/// </summary>
|
|
/// <remarks>Two strings are equal if they have equal length and all their characters match.</remarks>
|
|
/// <param name="a">A string to compare.</param>
|
|
/// <param name="b">Another string to compare.</param>
|
|
/// <returns>True if the two strings are unequal.</returns>
|
|
public static bool operator !=(in HeapString a, in FixedString64Bytes b)
|
|
{
|
|
return !(a == b);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if this string and another are equal.
|
|
/// </summary>
|
|
/// <remarks>Two strings are equal if they have equal length and all their characters match.</remarks>
|
|
/// <param name="other">Another string to compare with.</param>
|
|
/// <returns>True if the two strings are equal.</returns>
|
|
public bool Equals(FixedString64Bytes other)
|
|
{
|
|
return this == other;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the lexicographical sort order of this string relative to another.
|
|
/// </summary>
|
|
/// <param name="other">Another string to compare with.</param>
|
|
/// <returns>A number denoting the lexicographical sort order of this string relative to the other string:
|
|
///
|
|
/// 0 denotes both strings have the same sort position.<br/>
|
|
/// -1 denotes that this string should be sorted to precede the other.<br/>
|
|
/// +1 denotes that this string should be sorted to follow the other.<br/>
|
|
/// </returns>
|
|
public int CompareTo(FixedString128Bytes other)
|
|
{
|
|
return FixedStringMethods.CompareTo(ref this, other);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Initializes and returns an instance of HeapString with the characters copied from another string.
|
|
/// </summary>
|
|
/// <param name="source">A string to copy characters from.</param>
|
|
/// <param name="allocator">The allocator to use.</param>
|
|
public HeapString(in FixedString128Bytes source, Allocator allocator)
|
|
{
|
|
m_Data = new NativeList<byte>(source.utf8LengthInBytes + 1, allocator);
|
|
Length = source.utf8LengthInBytes;
|
|
|
|
unsafe {
|
|
byte* sbytes = (byte*) UnsafeUtilityExtensions.AddressOf(source.bytes);
|
|
byte* dbytes = (byte*) m_Data.GetUnsafePtr();
|
|
UnsafeUtility.MemCpy(dbytes, sbytes, source.utf8LengthInBytes);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if two strings are equal.
|
|
/// </summary>
|
|
/// <remarks>Two strings are equal if they have equal length and all their characters match.</remarks>
|
|
/// <param name="a">A string to compare.</param>
|
|
/// <param name="b">Another string to compare.</param>
|
|
/// <returns>True if the two strings are equal.</returns>
|
|
public static bool operator ==(in HeapString a, in FixedString128Bytes b)
|
|
{
|
|
unsafe {
|
|
var aref = UnsafeUtilityExtensions.AsRef(a);
|
|
int alen = aref.Length;
|
|
int blen = b.utf8LengthInBytes;
|
|
byte* aptr = (byte*) aref.GetUnsafePtr();
|
|
byte* bptr = (byte*) UnsafeUtilityExtensions.AddressOf(b.bytes);
|
|
return UTF8ArrayUnsafeUtility.EqualsUTF8Bytes(aptr, alen, bptr, blen);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if two strings are unequal.
|
|
/// </summary>
|
|
/// <remarks>Two strings are equal if they have equal length and all their characters match.</remarks>
|
|
/// <param name="a">A string to compare.</param>
|
|
/// <param name="b">Another string to compare.</param>
|
|
/// <returns>True if the two strings are unequal.</returns>
|
|
public static bool operator !=(in HeapString a, in FixedString128Bytes b)
|
|
{
|
|
return !(a == b);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if this string and another are equal.
|
|
/// </summary>
|
|
/// <remarks>Two strings are equal if they have equal length and all their characters match.</remarks>
|
|
/// <param name="other">Another string to compare with.</param>
|
|
/// <returns>True if the two strings are equal.</returns>
|
|
public bool Equals(FixedString128Bytes other)
|
|
{
|
|
return this == other;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the lexicographical sort order of this string relative to another.
|
|
/// </summary>
|
|
/// <param name="other">Another string to compare with.</param>
|
|
/// <returns>A number denoting the lexicographical sort order of this string relative to the other string:
|
|
///
|
|
/// 0 denotes both strings have the same sort position.<br/>
|
|
/// -1 denotes that this string should be sorted to precede the other.<br/>
|
|
/// +1 denotes that this string should be sorted to follow the other.<br/>
|
|
/// </returns>
|
|
public int CompareTo(FixedString512Bytes other)
|
|
{
|
|
return FixedStringMethods.CompareTo(ref this, other);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Initializes and returns an instance of HeapString with the characters copied from another string.
|
|
/// </summary>
|
|
/// <param name="source">A string to copy characters from.</param>
|
|
/// <param name="allocator">The allocator to use.</param>
|
|
public HeapString(in FixedString512Bytes source, Allocator allocator)
|
|
{
|
|
m_Data = new NativeList<byte>(source.utf8LengthInBytes + 1, allocator);
|
|
Length = source.utf8LengthInBytes;
|
|
|
|
unsafe {
|
|
byte* sbytes = (byte*) UnsafeUtilityExtensions.AddressOf(source.bytes);
|
|
byte* dbytes = (byte*) m_Data.GetUnsafePtr();
|
|
UnsafeUtility.MemCpy(dbytes, sbytes, source.utf8LengthInBytes);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if two strings are equal.
|
|
/// </summary>
|
|
/// <remarks>Two strings are equal if they have equal length and all their characters match.</remarks>
|
|
/// <param name="a">A string to compare.</param>
|
|
/// <param name="b">Another string to compare.</param>
|
|
/// <returns>True if the two strings are equal.</returns>
|
|
public static bool operator ==(in HeapString a, in FixedString512Bytes b)
|
|
{
|
|
unsafe {
|
|
var aref = UnsafeUtilityExtensions.AsRef(a);
|
|
int alen = aref.Length;
|
|
int blen = b.utf8LengthInBytes;
|
|
byte* aptr = (byte*) aref.GetUnsafePtr();
|
|
byte* bptr = (byte*) UnsafeUtilityExtensions.AddressOf(b.bytes);
|
|
return UTF8ArrayUnsafeUtility.EqualsUTF8Bytes(aptr, alen, bptr, blen);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if two strings are unequal.
|
|
/// </summary>
|
|
/// <remarks>Two strings are equal if they have equal length and all their characters match.</remarks>
|
|
/// <param name="a">A string to compare.</param>
|
|
/// <param name="b">Another string to compare.</param>
|
|
/// <returns>True if the two strings are unequal.</returns>
|
|
public static bool operator !=(in HeapString a, in FixedString512Bytes b)
|
|
{
|
|
return !(a == b);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if this string and another are equal.
|
|
/// </summary>
|
|
/// <remarks>Two strings are equal if they have equal length and all their characters match.</remarks>
|
|
/// <param name="other">Another string to compare with.</param>
|
|
/// <returns>True if the two strings are equal.</returns>
|
|
public bool Equals(FixedString512Bytes other)
|
|
{
|
|
return this == other;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the lexicographical sort order of this string relative to another.
|
|
/// </summary>
|
|
/// <param name="other">Another string to compare with.</param>
|
|
/// <returns>A number denoting the lexicographical sort order of this string relative to the other string:
|
|
///
|
|
/// 0 denotes both strings have the same sort position.<br/>
|
|
/// -1 denotes that this string should be sorted to precede the other.<br/>
|
|
/// +1 denotes that this string should be sorted to follow the other.<br/>
|
|
/// </returns>
|
|
public int CompareTo(FixedString4096Bytes other)
|
|
{
|
|
return FixedStringMethods.CompareTo(ref this, other);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Initializes and returns an instance of HeapString with the characters copied from another string.
|
|
/// </summary>
|
|
/// <param name="source">A string to copy characters from.</param>
|
|
/// <param name="allocator">The allocator to use.</param>
|
|
public HeapString(in FixedString4096Bytes source, Allocator allocator)
|
|
{
|
|
m_Data = new NativeList<byte>(source.utf8LengthInBytes + 1, allocator);
|
|
Length = source.utf8LengthInBytes;
|
|
|
|
unsafe {
|
|
byte* sbytes = (byte*) UnsafeUtilityExtensions.AddressOf(source.bytes);
|
|
byte* dbytes = (byte*) m_Data.GetUnsafePtr();
|
|
UnsafeUtility.MemCpy(dbytes, sbytes, source.utf8LengthInBytes);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if two strings are equal.
|
|
/// </summary>
|
|
/// <remarks>Two strings are equal if they have equal length and all their characters match.</remarks>
|
|
/// <param name="a">A string to compare.</param>
|
|
/// <param name="b">Another string to compare.</param>
|
|
/// <returns>True if the two strings are equal.</returns>
|
|
public static bool operator ==(in HeapString a, in FixedString4096Bytes b)
|
|
{
|
|
unsafe {
|
|
var aref = UnsafeUtilityExtensions.AsRef(a);
|
|
int alen = aref.Length;
|
|
int blen = b.utf8LengthInBytes;
|
|
byte* aptr = (byte*) aref.GetUnsafePtr();
|
|
byte* bptr = (byte*) UnsafeUtilityExtensions.AddressOf(b.bytes);
|
|
return UTF8ArrayUnsafeUtility.EqualsUTF8Bytes(aptr, alen, bptr, blen);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if two strings are unequal.
|
|
/// </summary>
|
|
/// <remarks>Two strings are equal if they have equal length and all their characters match.</remarks>
|
|
/// <param name="a">A string to compare.</param>
|
|
/// <param name="b">Another string to compare.</param>
|
|
/// <returns>True if the two strings are unequal.</returns>
|
|
public static bool operator !=(in HeapString a, in FixedString4096Bytes b)
|
|
{
|
|
return !(a == b);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if this string and another are equal.
|
|
/// </summary>
|
|
/// <remarks>Two strings are equal if they have equal length and all their characters match.</remarks>
|
|
/// <param name="other">Another string to compare with.</param>
|
|
/// <returns>True if the two strings are equal.</returns>
|
|
public bool Equals(FixedString4096Bytes other)
|
|
{
|
|
return this == other;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a managed string copy of this string.
|
|
/// </summary>
|
|
/// <returns>A managed string copy of this string.</returns>>
|
|
[NotBurstCompatible]
|
|
public override String ToString()
|
|
{
|
|
if (!m_Data.IsCreated)
|
|
return "";
|
|
return this.ConvertToString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a hash code of this string.
|
|
/// </summary>
|
|
/// <remarks>The hash code is an integer that is always the same for two equal strings but (very likely) different for two unequal strings.</remarks>
|
|
/// <returns>A hash code of this string.</returns>
|
|
public override int GetHashCode()
|
|
{
|
|
return this.ComputeHashCode();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns true if this string and another object are equal.
|
|
/// </summary>
|
|
/// <remarks>For the object to be equal, it must itself be a managed string, HeapString, or FixedString*N*Bytes.
|
|
///
|
|
/// Two strings are equal if they have equal length and all their characters match.</remarks>
|
|
/// <param name="other">Another string to compare with.</param>
|
|
/// <returns>True if this string and the object are equal.</returns>
|
|
[NotBurstCompatible]
|
|
public override bool Equals(object other)
|
|
{
|
|
if(ReferenceEquals(null, other)) return false;
|
|
if(other is String aString) return Equals(aString);
|
|
if(other is HeapString aHeapString) return Equals(aHeapString);
|
|
if(other is FixedString32Bytes a32) return Equals(a32);
|
|
if(other is FixedString64Bytes a64) return Equals(a64);
|
|
if(other is FixedString128Bytes a128) return Equals(a128);
|
|
if(other is FixedString512Bytes a512) return Equals(a512);
|
|
if(other is FixedString4096Bytes a4096) return Equals(a4096);
|
|
return false;
|
|
}
|
|
|
|
[Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]
|
|
void CheckIndexInRange(int index)
|
|
{
|
|
if (index < 0)
|
|
throw new IndexOutOfRangeException($"Index {index} must be positive.");
|
|
if (index >= Length)
|
|
throw new IndexOutOfRangeException($"Index {index} is out of range in HeapString of {Length} length.");
|
|
}
|
|
|
|
[Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]
|
|
void ThrowCopyError(CopyError error, String source)
|
|
{
|
|
throw new ArgumentException($"HeapString: {error} while copying \"{source}\"");
|
|
}
|
|
}
|
|
}
|