public static int GetSamplingRate(this Span <char> span)
{
Span <char> sampleS = new Span <char>();
for (int i = 1; i < span.Length; i++)
{
var l = i;
for (int j = 0; j < l; j++)
{
sampleS.Fill('1');
}
for (int j = 0; j < l; j++)
{
sampleS.Fill('0');
}
for (int j = 0; j < l; j++)
{
sampleS.Fill('1');
}
if (MemoryExtensions.Contains(span, sampleS, StringComparison.Ordinal))
{
return(i);
}
}
return(0);
}
public static void PartialEquals_ReturnsPrefixLength_ValueType()
{
int[] arr1 = new int[] { 1, 2, 3 };
int[] arr2 = new int[] { 1, 2, 6 };
Assert.Equal(2, MemoryExtensions.CommonPrefixLength((ReadOnlySpan <int>)arr1, arr2));
Assert.Equal(2, MemoryExtensions.CommonPrefixLength((ReadOnlySpan <int>)arr1, arr2, null));
Assert.Equal(2, MemoryExtensions.CommonPrefixLength((ReadOnlySpan <int>)arr1, arr2, EqualityComparer <int> .Default));
Assert.Equal(2, MemoryExtensions.CommonPrefixLength((ReadOnlySpan <int>)arr1, arr2, NonDefaultEqualityComparer <int> .Instance));
Assert.Equal(2, MemoryExtensions.CommonPrefixLength((Span <int>)arr1, arr2));
Assert.Equal(2, MemoryExtensions.CommonPrefixLength((Span <int>)arr1, arr2, null));
Assert.Equal(2, MemoryExtensions.CommonPrefixLength((Span <int>)arr1, arr2, EqualityComparer <int> .Default));
Assert.Equal(2, MemoryExtensions.CommonPrefixLength((Span <int>)arr1, arr2, NonDefaultEqualityComparer <int> .Instance));
// Vectorized code path
arr1 = new int[] { 1, 2, 3, 4, 5 };
arr2 = new int[] { 1, 2, 3, 6, 7 };
Assert.Equal(3, MemoryExtensions.CommonPrefixLength((ReadOnlySpan <int>)arr1, arr2));
Assert.Equal(3, MemoryExtensions.CommonPrefixLength((ReadOnlySpan <int>)arr1, arr2, null));
Assert.Equal(3, MemoryExtensions.CommonPrefixLength((ReadOnlySpan <int>)arr1, arr2, EqualityComparer <int> .Default));
Assert.Equal(3, MemoryExtensions.CommonPrefixLength((ReadOnlySpan <int>)arr1, arr2, NonDefaultEqualityComparer <int> .Instance));
Assert.Equal(3, MemoryExtensions.CommonPrefixLength((Span <int>)arr1, arr2));
Assert.Equal(3, MemoryExtensions.CommonPrefixLength((Span <int>)arr1, arr2, null));
Assert.Equal(3, MemoryExtensions.CommonPrefixLength((Span <int>)arr1, arr2, EqualityComparer <int> .Default));
Assert.Equal(3, MemoryExtensions.CommonPrefixLength((Span <int>)arr1, arr2, NonDefaultEqualityComparer <int> .Instance));
}
public void AppendFormatted_ReadOnlySpanChar()
{
var expected = new StringBuilder();
MemoryExtensions.TryWriteInterpolatedStringHandler actual = new MemoryExtensions.TryWriteInterpolatedStringHandler(0, 0, _largeBuffer, out _);
foreach (string s in new[] { "", "a", "bc", "def", "this is a longer string", "!" })
{
// span
expected.Append(s);
actual.AppendFormatted((ReadOnlySpan <char>)s);
// span, format
expected.AppendFormat("{0:X2}", s);
actual.AppendFormatted((ReadOnlySpan <char>)s, format: "X2");
foreach (int alignment in new[] { 0, 3, -3 })
{
// span, alignment
expected.AppendFormat("{0," + alignment.ToString(CultureInfo.InvariantCulture) + "}", s);
actual.AppendFormatted((ReadOnlySpan <char>)s, alignment);
// span, alignment, format
expected.AppendFormat("{0," + alignment.ToString(CultureInfo.InvariantCulture) + ":X2}", s);
actual.AppendFormatted((ReadOnlySpan <char>)s, alignment, "X2");
}
}
Assert.True(MemoryExtensions.TryWrite(_largeBuffer, ref actual, out int charsWritten));
Assert.Equal(expected.ToString(), _largeBuffer.AsSpan(0, charsWritten).ToString());
}
/// <summary>
/// Flushes the rest of the PCM data in this buffer to VoiceNext packet queue.
/// </summary>
// Token: 0x060000C5 RID: 197 RVA: 0x00003DEC File Offset: 0x00001FEC
public unsafe override void Flush()
{
Span <byte> span = this.PcmMemory.Span;
Helpers.ZeroFill(span.Slice(this.PcmBufferLength));
Span <short> pcmData = MemoryMarshal.Cast <byte, short>(span);
List <IVoiceFilter> filters = this.Filters;
lock (filters)
{
if (this.Filters.Any <IVoiceFilter>())
{
foreach (IVoiceFilter voiceFilter in this.Filters)
{
voiceFilter.Transform(pcmData, this.Connection.AudioFormat, this.SampleDuration);
}
}
}
if (this.VolumeModifier != 1.0)
{
for (int i = 0; i < pcmData.Length; i++)
{
*pcmData[i] = (short)((double)(*pcmData[i]) * this.VolumeModifier);
}
}
Memory <byte> memory = MemoryExtensions.AsMemory <byte>(new byte[span.Length]);
this.Connection.PreparePacket(span, ref memory);
this.Connection.EnqueuePacket(new VoicePacket(memory, this.PcmBufferDuration, false));
}
public static void PartialEquals_ReturnsPrefixLength_Byte()
{
byte[] arr1 = new byte[] { 1, 2, 3, 4, 5 };
byte[] arr2 = new byte[] { 1, 2, 3, 6, 7 };
Assert.Equal(3, MemoryExtensions.CommonPrefixLength((ReadOnlySpan <byte>)arr1, arr2));
Assert.Equal(3, MemoryExtensions.CommonPrefixLength((ReadOnlySpan <byte>)arr1, arr2, null));
Assert.Equal(3, MemoryExtensions.CommonPrefixLength((ReadOnlySpan <byte>)arr1, arr2, EqualityComparer <byte> .Default));
Assert.Equal(3, MemoryExtensions.CommonPrefixLength((ReadOnlySpan <byte>)arr1, arr2, NonDefaultEqualityComparer <byte> .Instance));
Assert.Equal(3, MemoryExtensions.CommonPrefixLength((Span <byte>)arr1, arr2));
Assert.Equal(3, MemoryExtensions.CommonPrefixLength((Span <byte>)arr1, arr2, null));
Assert.Equal(3, MemoryExtensions.CommonPrefixLength((Span <byte>)arr1, arr2, EqualityComparer <byte> .Default));
Assert.Equal(3, MemoryExtensions.CommonPrefixLength((Span <byte>)arr1, arr2, NonDefaultEqualityComparer <byte> .Instance));
// Vectorized code path
arr1 = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 };
arr2 = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 42, 15, 16, 17 };
Assert.Equal(13, MemoryExtensions.CommonPrefixLength((ReadOnlySpan <byte>)arr1, arr2));
Assert.Equal(13, MemoryExtensions.CommonPrefixLength((ReadOnlySpan <byte>)arr1, arr2, null));
Assert.Equal(13, MemoryExtensions.CommonPrefixLength((ReadOnlySpan <byte>)arr1, arr2, EqualityComparer <byte> .Default));
Assert.Equal(13, MemoryExtensions.CommonPrefixLength((ReadOnlySpan <byte>)arr1, arr2, NonDefaultEqualityComparer <byte> .Instance));
Assert.Equal(13, MemoryExtensions.CommonPrefixLength((Span <byte>)arr1, arr2));
Assert.Equal(13, MemoryExtensions.CommonPrefixLength((Span <byte>)arr1, arr2, null));
Assert.Equal(13, MemoryExtensions.CommonPrefixLength((Span <byte>)arr1, arr2, EqualityComparer <byte> .Default));
Assert.Equal(13, MemoryExtensions.CommonPrefixLength((Span <byte>)arr1, arr2, NonDefaultEqualityComparer <byte> .Instance));
}
public override bool Equals(object obj)
{
if (!(obj is HashesMessage other))
{
return(false);
}
if (Hashes.Count != other.Hashes.Count)
{
return(false);
}
for (int i = 0; i < Hashes.Count; i++)
{
if (!MemoryExtensions.SequenceEqual(Hashes[i].Span, other.Hashes[i].Span))
{
return(false);
}
}
return(MemoryExtensions.SequenceEqual(PiecesRoot.Span, other.PiecesRoot.Span) &&
BaseLayer == other.BaseLayer &&
Index == other.Index &&
Length == other.Length &&
ProofLayers == other.ProofLayers);
}
public static bool AttributeNamesEqual(string attributeName1, string attributeName2)
{
ReadOnlySpan <char> name1 = attributeName1.EndsWith("Attribute") ? attributeName1.AsSpan(0, attributeName1.Length - 9) : attributeName1.AsSpan();
ReadOnlySpan <char> name2 = attributeName2.EndsWith("Attribute") ? attributeName2.AsSpan(0, attributeName2.Length - 9) : attributeName2.AsSpan();
return(MemoryExtensions.Equals(name1, name2, StringComparison.Ordinal));
}
public bool RepeatedSubstringPattern(string s)
{
if (s.Length <= 1)
{
return(false);
}
for (int len = 1; len <= s.Length / 2; len++)
{
if (s.Length % len == 0)
{
ReadOnlySpan <char> sample = s.AsSpan(0, len);
for (int i = len; i < s.Length; i += len)
{
ReadOnlySpan <char> test = s.AsSpan(i, len);
if (!MemoryExtensions.Equals(sample, test, StringComparison.Ordinal))
{
goto next_length;
}
}
return(true);
next_length:
;
}
}
return(false);
}
/// <summary> /// Returns a value that indicates whether this instance and another <see cref="AnimationNode"/> are equal. /// </summary> /// <param name="other">The other <see cref="AnimationNode"/>.</param> /// <returns><see langword="true"/> if the two animation nodes are equals; otherwise, <see langword="false"/>.</returns> public bool Equals(AnimationNode other) => _hashcode == other._hashcode && PostState == other.PostState && PreState == other.PreState && MemoryExtensions.SequenceEqual(PositionKeys, other.PositionKeys) && MemoryExtensions.SequenceEqual(RotationKeys, other.RotationKeys) && MemoryExtensions.SequenceEqual(ScalingKeys, other.ScalingKeys);
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
if (value is string s1)
{
var span = s1.AsSpan();
var s = span.Trim();
if (MemoryExtensions.Equals(s, SvgUnitCollection.None.AsSpan(), StringComparison.OrdinalIgnoreCase))
{
return(new SvgUnitCollection
{
StringForEmptyValue = SvgUnitCollection.None
});
}
else if (MemoryExtensions.Equals(s, SvgUnitCollection.Inherit.AsSpan(), StringComparison.OrdinalIgnoreCase))
{
return(new SvgUnitCollection
{
StringForEmptyValue = SvgUnitCollection.Inherit
});
}
return(SvgUnitCollectionConverter.Parse(span));
}
return(base.ConvertFrom(context, culture, value));
}
public int Compare(byte[] key)
{
int minLen = Math.Min(key.Length, m_key.Length);
var cut = key.AsSpan().Slice(0, minLen);
return(MemoryExtensions.SequenceCompareTo <byte>(m_key, cut));
}
/// <summary>Gets the ID string, i.e. a 'normalized' <see cref="String"/> representation.
/// </summary>
/// <param name="rawString">The (raw) string.</param>
/// <param name="ignorCommentCharacter">A value indicating whether all character which comes next to <see cref="IdentifierString.IgnoringStartCharacter"/> will be ignored.</param>
/// <returns>A 'normalized' representation of <paramref name="rawString"/>, especially without white spaces.
/// </returns>
internal static string GetIDString(string rawString, bool ignorCommentCharacter = true)
{
var rawStringSpan = MemoryExtensions.AsSpan(rawString);
if (ignorCommentCharacter == true)
{
int splitIndex = rawString.IndexOf(IgnoringStartCharacter);
if (splitIndex >= 0)
{
rawStringSpan = rawStringSpan.Slice(0, splitIndex); // 'rawString = rawString.Remove(splitIndex)'
}
}
int k = 0;
var identifierAsArray = new char[rawStringSpan.Length];
for (int i = 0; i < rawStringSpan.Length; i++)
{
char c = rawStringSpan[i];
if (Char.IsWhiteSpace(c) == false)
{
identifierAsArray[k] = Char.ToLower(c);
k++;
}
}
return(new string(identifierAsArray, startIndex : 0, length : k));
}
public void AppendFormatted_BufferTooSmall_CustomFormatter()
{
var buffer = new char[100];
var provider = new ConstFormatter(" ");
{
MemoryExtensions.TryWriteInterpolatedStringHandler b = new MemoryExtensions.TryWriteInterpolatedStringHandler(0, 0, buffer.AsSpan(0, 0), provider, out bool shouldAppend);
Assert.True(shouldAppend);
// don't use custom formatter
Assert.True(b.AppendLiteral(""));
Assert.True(b.AppendFormatted("".AsSpan()));
Assert.True(b.AppendFormatted("".AsSpan(), alignment: 0, format: "X2"));
// do use custom formatter
Assert.False(b.AppendFormatted((object)"", alignment: 0, format: "X2"));
Assert.False(b.AppendFormatted(null));
Assert.False(b.AppendFormatted(""));
Assert.False(b.AppendFormatted("", alignment: 0, format: "X2"));
Assert.False(b.AppendFormatted <string>(""));
Assert.False(b.AppendFormatted <string>("", alignment: 0));
Assert.False(b.AppendFormatted <string>("", format: "X2"));
Assert.False(b.AppendFormatted <string>("", alignment: 0, format: "X2"));
Assert.False(MemoryExtensions.TryWrite(buffer.AsSpan(0, 0), ref b, out int charsWritten));
Assert.Equal(0, charsWritten);
}
}
public void MemoryExtensionsToUpper()
{
var _resultString = new Span <char>();
MemoryExtensions.ToUpper(_baseString.AsSpan(), _resultString, CultureInfo.InvariantCulture);
CheckResult(this._resultString);
}
public void AppendFormatted_ReferenceTypes()
{
var expected = new StringBuilder();
MemoryExtensions.TryWriteInterpolatedStringHandler actual = new MemoryExtensions.TryWriteInterpolatedStringHandler(0, 0, _largeBuffer, out _);
foreach (string rawInput in new[] { null, "", "a", "bc", "def", "this is a longer string", "!" })
{
foreach (object o in new object[]
{
rawInput, // raw string directly; ToString will return itself
new StringWrapper(rawInput), // wrapper object that returns string from ToString
new FormattableStringWrapper(rawInput), // IFormattable wrapper around string
new SpanFormattableStringWrapper(rawInput) // ISpanFormattable wrapper around string
})
{
// object
expected.AppendFormat("{0}", o);
actual.AppendFormatted(o);
if (o is IHasToStringState tss1)
{
Assert.True(string.IsNullOrEmpty(tss1.ToStringState.LastFormat));
AssertModeMatchesType(tss1);
}
// object, format
expected.AppendFormat("{0:X2}", o);
actual.AppendFormatted(o, "X2");
if (o is IHasToStringState tss2)
{
Assert.Equal("X2", tss2.ToStringState.LastFormat);
AssertModeMatchesType(tss2);
}
foreach (int alignment in new[] { 0, 3, -3 })
{
// object, alignment
expected.AppendFormat("{0," + alignment.ToString(CultureInfo.InvariantCulture) + "}", o);
actual.AppendFormatted(o, alignment);
if (o is IHasToStringState tss3)
{
Assert.True(string.IsNullOrEmpty(tss3.ToStringState.LastFormat));
AssertModeMatchesType(tss3);
}
// object, alignment, format
expected.AppendFormat("{0," + alignment.ToString(CultureInfo.InvariantCulture) + ":X2}", o);
actual.AppendFormatted(o, alignment, "X2");
if (o is IHasToStringState tss4)
{
Assert.Equal("X2", tss4.ToStringState.LastFormat);
AssertModeMatchesType(tss4);
}
}
}
}
Assert.True(MemoryExtensions.TryWrite(_largeBuffer, ref actual, out int charsWritten));
Assert.Equal(expected.ToString(), _largeBuffer.AsSpan(0, charsWritten).ToString());
}
public void AppendFormatted_String_ICustomFormatter()
{
var provider = new ConcatFormatter();
var expected = new StringBuilder();
MemoryExtensions.TryWriteInterpolatedStringHandler actual = new MemoryExtensions.TryWriteInterpolatedStringHandler(0, 0, _largeBuffer, provider, out _);
foreach (string s in new[] { null, "", "a" })
{
// string
expected.AppendFormat(provider, "{0}", s);
actual.AppendFormatted(s);
// string, format
expected.AppendFormat(provider, "{0:X2}", s);
actual.AppendFormatted(s, "X2");
// string, alignment
expected.AppendFormat(provider, "{0,3}", s);
actual.AppendFormatted(s, 3);
// string, alignment, format
expected.AppendFormat(provider, "{0,-3:X2}", s);
actual.AppendFormatted(s, -3, "X2");
}
Assert.True(MemoryExtensions.TryWrite(_largeBuffer, ref actual, out int charsWritten));
Assert.Equal(expected.ToString(), _largeBuffer.AsSpan(0, charsWritten).ToString());
}
private static void HeapSortAndAssert(Span <byte> array)
{
MemoryExtensions.HeapSort(array, IntComparison, 0, array.Length - 1);
for (var i = 1; i < array.Length; i++)
{
Assert.True(array[i - 1] <= array[i]);
}
}
// Token: 0x060000BF RID: 191 RVA: 0x00003B10 File Offset: 0x00001D10
internal VoiceTransmitStream(VoiceNextConnection vnc, int pcmBufferDuration)
{
this.Connection = vnc;
this.PcmBufferDuration = pcmBufferDuration;
this.PcmBuffer = new byte[vnc.AudioFormat.CalculateSampleSize(pcmBufferDuration)];
this.PcmMemory = MemoryExtensions.AsMemory <byte>(this.PcmBuffer);
this.PcmBufferLength = 0;
this.Filters = new List <IVoiceFilter>();
}
// Token: 0x06000184 RID: 388 RVA: 0x00004FC8 File Offset: 0x000031C8
public void GenerateNonce(Span <byte> target)
{
if (target.Length != Interop.SodiumNonceSize)
{
throw new ArgumentException(string.Format("Invalid nonce buffer size. Target buffer for the nonce needs to have a capacity of {0} bytes.", Interop.SodiumNonceSize), "target");
}
this.CSPRNG.GetBytes(this.Buffer);
MemoryExtensions.AsSpan <byte>(this.Buffer).CopyTo(target);
}
public bool Equals(NSymbol255 other)
{
if (Len != other.Len)
{
return(false);
}
return(MemoryExtensions.SequenceEqual(AsSpan(), other.AsSpan()));
}
public int Compare(ProblemString x, ProblemString y)
{
var xStringPart = x.RawString.AsSpan(x.PointIndex + 1);
var yStringPart = y.RawString.AsSpan(y.PointIndex + 1);
var stringPartCompareResult = MemoryExtensions.CompareTo(xStringPart, yStringPart, StringComparison.Ordinal);
return(stringPartCompareResult == 0
? x.Number - y.Number
: stringPartCompareResult);
}
public bool Find(ReadOnlySpan <char> key, out T val)
{
for (int i = 0; i < SlotsUsed; i++)
{
ref var e = ref Slots[i];
if (MemoryExtensions.Equals(e.Key, key, StringComparison.Ordinal))
{
val = e.Value;
return(true);
}
}
private static bool MatchHeader(HeaderMatchMode matchMode, string requestHeaderValue, string metadataHeaderValue, bool isCaseSensitive)
{
var comparison = isCaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;
return(matchMode switch
{
HeaderMatchMode.ExactHeader => MemoryExtensions.Equals(requestHeaderValue, metadataHeaderValue, comparison),
HeaderMatchMode.HeaderPrefix => requestHeaderValue != null && metadataHeaderValue != null &&
MemoryExtensions.StartsWith(requestHeaderValue, metadataHeaderValue, comparison),
_ => throw new NotImplementedException(matchMode.ToString()),
});
public bool Equals(StorageKey other)
{
if (other is null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(Id == other.Id && MemoryExtensions.SequenceEqual <byte>(Key, other.Key));
}
private static void ValidateWithDefaultValues <T>(int length1, int length2, IEqualityComparer <T> customComparer, int expected)
{
Assert.Equal(expected, MemoryExtensions.CommonPrefixLength((ReadOnlySpan <T>) new T[length1], new T[length2]));
Assert.Equal(expected, MemoryExtensions.CommonPrefixLength((ReadOnlySpan <T>) new T[length1], new T[length2], null));
Assert.Equal(expected, MemoryExtensions.CommonPrefixLength((ReadOnlySpan <T>) new T[length1], new T[length2], EqualityComparer <T> .Default));
Assert.Equal(expected, MemoryExtensions.CommonPrefixLength((ReadOnlySpan <T>) new T[length1], new T[length2], customComparer));
Assert.Equal(expected, MemoryExtensions.CommonPrefixLength((Span <T>) new T[length1], new T[length2]));
Assert.Equal(expected, MemoryExtensions.CommonPrefixLength((Span <T>) new T[length1], new T[length2], null));
Assert.Equal(expected, MemoryExtensions.CommonPrefixLength((Span <T>) new T[length1], new T[length2], EqualityComparer <T> .Default));
Assert.Equal(expected, MemoryExtensions.CommonPrefixLength((Span <T>) new T[length1], new T[length2], customComparer));
}
public static bool Equal <T>(ReadOnlyMemorySlice <T>?lhs, ReadOnlyMemorySlice <T>?rhs)
where T : IEquatable <T>
{
if (lhs == null && rhs == null)
{
return(true);
}
if (lhs == null || rhs == null)
{
return(false);
}
return(MemoryExtensions.SequenceEqual(lhs.Value.Span, rhs.Value.Span));
}
public static StringsFolderLookupOverlay?TypicalFactory(string referenceModPath, StringsReadParameters?instructions, ModKey modKey)
{
var ret = new StringsFolderLookupOverlay();
var stringsFolderPath = instructions?.StringsFolderOverride;
var dir = Path.GetDirectoryName(referenceModPath);
if (stringsFolderPath == null)
{
stringsFolderPath = Path.Combine(dir, "Strings");
}
if (stringsFolderPath.Value.Exists)
{
foreach (var file in stringsFolderPath.Value.Info.EnumerateFiles($"{modKey.Name}*{StringsUtility.StringsFileExtension}"))
{
if (!StringsUtility.TryRetrieveInfoFromString(file.Name, out var type, out var lang, out _))
{
continue;
}
var dict = ret.Get(type);
dict[lang] = new Lazy <IStringsLookup>(() => new StringsLookupOverlay(file.FullName, type), LazyThreadSafetyMode.ExecutionAndPublication);
}
}
foreach (var bsaFile in Directory.EnumerateFiles(dir, "*.bsa"))
{
var bsaReader = BSAReader.Load(new AbsolutePath(bsaFile, skipValidation: true));
foreach (var item in bsaReader.Files)
{
if (!StringsUtility.TryRetrieveInfoFromString(Path.GetFileName(item.Path.ToString()), out var type, out var lang, out var modName))
{
continue;
}
if (!MemoryExtensions.Equals(modKey.Name, modName, StringComparison.OrdinalIgnoreCase))
{
continue;
}
var dict = ret.Get(type);
if (dict.ContainsKey(lang))
{
continue;
}
dict[lang] = new Lazy <IStringsLookup>(() =>
{
byte[] bytes = new byte[item.Size];
using var stream = new MemoryStream(bytes);
item.CopyDataTo(stream).AsTask().Wait();
return(new StringsLookupOverlay(bytes, type));
}, LazyThreadSafetyMode.ExecutionAndPublication);
}
}
return(ret);
}
public void AppendFormatted_BufferTooSmall(int bufferLength)
{
var buffer = new char[bufferLength];
for (int i = 0; i <= 29; i++)
{
MemoryExtensions.TryWriteInterpolatedStringHandler b = new MemoryExtensions.TryWriteInterpolatedStringHandler(0, 0, buffer, out bool shouldAppend);
Assert.True(shouldAppend);
Assert.True(b.AppendLiteral(new string('s', bufferLength)));
bool result = i switch
{
0 => b.AppendLiteral(" "),
1 => b.AppendFormatted((object)" ", alignment: 0, format: "X2"),
2 => b.AppendFormatted(" "),
3 => b.AppendFormatted(" ", alignment: 0, format: "X2"),
4 => b.AppendFormatted <string>(" "),
5 => b.AppendFormatted <string>(" ", alignment: 0),
6 => b.AppendFormatted <string>(" ", format: "X2"),
7 => b.AppendFormatted <string>(" ", alignment: 0, format: "X2"),
8 => b.AppendFormatted(" ".AsSpan()),
9 => b.AppendFormatted(" ".AsSpan(), alignment: 0, format: "X2"),
10 => b.AppendFormatted(new FormattableStringWrapper(" ")),
11 => b.AppendFormatted(new FormattableStringWrapper(" "), alignment: 0),
12 => b.AppendFormatted(new FormattableStringWrapper(" "), format: "X2"),
13 => b.AppendFormatted(new FormattableStringWrapper(" "), alignment: 0, format: "X2"),
14 => b.AppendFormatted(new SpanFormattableStringWrapper(" ")),
15 => b.AppendFormatted(new SpanFormattableStringWrapper(" "), alignment: 0),
16 => b.AppendFormatted(new SpanFormattableStringWrapper(" "), format: "X2"),
17 => b.AppendFormatted(new SpanFormattableStringWrapper(" "), alignment: 0, format: "X2"),
18 => b.AppendFormatted(new FormattableInt32Wrapper(1)),
19 => b.AppendFormatted(new FormattableInt32Wrapper(1), alignment: 0),
20 => b.AppendFormatted(new FormattableInt32Wrapper(1), format: "X2"),
21 => b.AppendFormatted(new FormattableInt32Wrapper(1), alignment: 0, format: "X2"),
22 => b.AppendFormatted(new SpanFormattableInt32Wrapper(1)),
23 => b.AppendFormatted(new SpanFormattableInt32Wrapper(1), alignment: 0),
24 => b.AppendFormatted(new SpanFormattableInt32Wrapper(1), format: "X2"),
25 => b.AppendFormatted(new SpanFormattableInt32Wrapper(1), alignment: 0, format: "X2"),
26 => b.AppendFormatted <string>("", alignment: 1),
27 => b.AppendFormatted <string>("", alignment: -1),
28 => b.AppendFormatted <string>(" ", alignment: 1, format: "X2"),
29 => b.AppendFormatted <string>(" ", alignment: -1, format: "X2"),
_ => throw new Exception(),
};
Assert.False(result);
Assert.False(MemoryExtensions.TryWrite(buffer.AsSpan(0, 0), ref b, out int charsWritten));
Assert.Equal(0, charsWritten);
}
}
/// <summary>
/// Try to read everything up to the given <paramref name="delimiter"/>.
/// </summary>
/// <param name="span">The read data, if any.</param>
/// <param name="delimiter">The delimiter to look for.</param>
/// <param name="advancePastDelimiter">True to move past the <paramref name="delimiter"/> if found.</param>
/// <returns>True if the <paramref name="delimiter"/> was found.</returns>
public bool TryReadTo(out ReadOnlySpan <T> span, T delimiter, bool advancePastDelimiter = true)
{
ReadOnlySpan <T> remaining = UnreadSpan;
int index = MemoryExtensions.IndexOf(remaining, delimiter);
if (index != -1)
{
span = index == 0 ? default : remaining.Slice(0, index);
Advance(index + (advancePastDelimiter ? 1 : 0));
return(true);
}
return(TryReadToSlow(out span, delimiter, remaining.Length, advancePastDelimiter));
}
/// <summary>
/// Checks if two spans are equal in a case-insensitive manner. Utilizes <see cref="StringComparison.OrdinalIgnoreCase" />.
/// </summary>
/// <param name="text">The text.</param>
/// <param name="otherText">The other text.</param>
/// <returns><c>true</c> if strings are both null or both equal regardless of casing, <c>false</c> otherwise.</returns>
public static bool EqualsCaseInvariant(this ReadOnlySpan <char> text, ReadOnlySpan <char> otherText)
{
if (text.IsEmpty && otherText.IsEmpty)
{
return(true);
}
if (text == otherText)
{
return(true);
}
return(MemoryExtensions.Equals(text, otherText, StringComparison.OrdinalIgnoreCase));
}
