private static Boolean TryParse(ReadOnlySpan <char> s, NumberStyles style, NumberFormatInfo info, out Single result)
{
bool success = Number.TryParseSingle(s, style, info, out result);
if (!success)
{
ReadOnlySpan <char> sTrim = s.Trim();
if (StringSpanHelpers.Equals(sTrim, info.PositiveInfinitySymbol))
{
result = PositiveInfinity;
}
else if (StringSpanHelpers.Equals(sTrim, info.NegativeInfinitySymbol))
{
result = NegativeInfinity;
}
else if (StringSpanHelpers.Equals(sTrim, info.NaNSymbol))
{
result = NaN;
}
else
{
return(false); // We really failed
}
}
return(true);
}
internal unsafe static double ParseDouble(ReadOnlySpan <char> value, NumberStyles options, NumberFormatInfo numfmt)
{
NumberBuffer number = default;
double d = 0;
if (!TryStringToNumber(value, options, ref number, numfmt, false))
{
//If we failed TryStringToNumber, it may be from one of our special strings.
//Check the three with which we're concerned and rethrow if it's not one of
//those strings.
ReadOnlySpan <char> sTrim = value.Trim();
if (StringSpanHelpers.Equals(sTrim, numfmt.PositiveInfinitySymbol))
{
return(double.PositiveInfinity);
}
if (StringSpanHelpers.Equals(sTrim, numfmt.NegativeInfinitySymbol))
{
return(double.NegativeInfinity);
}
if (StringSpanHelpers.Equals(sTrim, numfmt.NaNSymbol))
{
return(double.NaN);
}
throw new FormatException(SR.Format_InvalidString);
}
if (!NumberBufferToDouble(ref number, ref d))
{
throw new OverflowException(SR.Overflow_Double);
}
return(d);
}
/// <summary>
/// Determines whether the end of the span matches the specified value when compared using the specified comparison option.
/// </summary>
public static bool EndsWith(this ReadOnlySpan <char> span, ReadOnlySpan <char> value, StringComparison comparisonType)
{
if (value.Length == 0)
{
StringSpanHelpers.CheckStringComparison(comparisonType);
return(true);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(EndsWithCultureHelper(span, value));
case StringComparison.CurrentCultureIgnoreCase:
return(EndsWithCultureIgnoreCaseHelper(span, value));
case StringComparison.InvariantCulture:
return(EndsWithCultureHelper(span, value, invariantCulture: true));
case StringComparison.InvariantCultureIgnoreCase:
return(EndsWithCultureIgnoreCaseHelper(span, value, invariantCulture: true));
case StringComparison.Ordinal:
return(EndsWithOrdinalHelper(span, value));
case StringComparison.OrdinalIgnoreCase:
return(EndsWithOrdinalIgnoreCaseHelper(span, value));
default:
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
}
public static int CompareTo(this ReadOnlySpan <char> span, ReadOnlySpan <char> value, StringComparison comparisonType)
{
StringSpanHelpers.CheckStringComparison(comparisonType);
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(span, value, CompareOptions.None));
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(span, value, CompareOptions.IgnoreCase));
case StringComparison.InvariantCulture:
return(CompareInfo.Invariant.Compare(span, value, CompareOptions.None));
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.Compare(span, value, CompareOptions.IgnoreCase));
case StringComparison.Ordinal:
if (span.Length == 0 || value.Length == 0)
{
return(span.Length - value.Length);
}
return(string.CompareOrdinal(span, value));
case StringComparison.OrdinalIgnoreCase:
return(CompareInfo.CompareOrdinalIgnoreCase(span, value));
}
Debug.Fail("StringComparison outside range");
return(0);
}
/// <summary>
/// Determines whether the beginning of the <paramref name="span"/> matches the specified <paramref name="value"/> when compared using the specified <paramref name="comparisonType"/> option.
/// </summary>
/// <param name="span">The source span.</param>
/// <param name="value">The sequence to compare to the beginning of the source span.</param>
/// <param name="comparisonType">One of the enumeration values that determines how the <paramref name="span"/> and <paramref name="value"/> are compared.</param>
public static bool StartsWith(this ReadOnlySpan <char> span, ReadOnlySpan <char> value, StringComparison comparisonType)
{
if (value.Length == 0)
{
StringSpanHelpers.CheckStringComparison(comparisonType);
return(true);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(SpanHelpers.StartsWithCultureHelper(span, value, CultureInfo.CurrentCulture.CompareInfo));
case StringComparison.CurrentCultureIgnoreCase:
return(SpanHelpers.StartsWithCultureIgnoreCaseHelper(span, value, CultureInfo.CurrentCulture.CompareInfo));
case StringComparison.InvariantCulture:
return(SpanHelpers.StartsWithCultureHelper(span, value, CompareInfo.Invariant));
case StringComparison.InvariantCultureIgnoreCase:
return(SpanHelpers.StartsWithCultureIgnoreCaseHelper(span, value, CompareInfo.Invariant));
case StringComparison.Ordinal:
return(span.StartsWith(value)); //TODO: Optimize - https://github.com/dotnet/corefx/issues/27487
case StringComparison.OrdinalIgnoreCase:
return(SpanHelpers.StartsWithOrdinalIgnoreCaseHelper(span, value));
default:
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
}
// Provides a more flexible function for string comparision. See StringComparison
// for meaning of different comparisonType.
public static int Compare(String strA, String strB, StringComparison comparisonType)
{
if (object.ReferenceEquals(strA, strB))
{
StringSpanHelpers.CheckStringComparison(comparisonType);
return(0);
}
// They can't both be null at this point.
if (strA == null)
{
StringSpanHelpers.CheckStringComparison(comparisonType);
return(-1);
}
if (strB == null)
{
StringSpanHelpers.CheckStringComparison(comparisonType);
return(1);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(strA, strB, CompareOptions.None));
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(strA, strB, CompareOptions.IgnoreCase));
case StringComparison.InvariantCulture:
return(CompareInfo.Invariant.Compare(strA, strB, CompareOptions.None));
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.Compare(strA, strB, CompareOptions.IgnoreCase));
case StringComparison.Ordinal:
// Most common case: first character is different.
// Returns false for empty strings.
if (strA._firstChar != strB._firstChar)
{
return(strA._firstChar - strB._firstChar);
}
return(CompareOrdinalHelper(strA, strB));
case StringComparison.OrdinalIgnoreCase:
// If both strings are ASCII strings, we can take the fast path.
if (strA.IsAscii() && strB.IsAscii())
{
return(CompareOrdinalIgnoreCaseHelper(strA, strB));
}
return(CompareInfo.CompareOrdinalIgnoreCase(strA, 0, strA.Length, strB, 0, strB.Length));
default:
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
}
public static bool Equals(String a, String b, StringComparison comparisonType)
{
if ((Object)a == (Object)b)
{
StringSpanHelpers.CheckStringComparison(comparisonType);
return(true);
}
if ((Object)a == null || (Object)b == null)
{
StringSpanHelpers.CheckStringComparison(comparisonType);
return(false);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(a, b, CompareOptions.None) == 0);
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(a, b, CompareOptions.IgnoreCase) == 0);
case StringComparison.InvariantCulture:
return(CompareInfo.Invariant.Compare(a, b, CompareOptions.None) == 0);
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.Compare(a, b, CompareOptions.IgnoreCase) == 0);
case StringComparison.Ordinal:
if (a.Length != b.Length)
{
return(false);
}
return(EqualsHelper(a, b));
case StringComparison.OrdinalIgnoreCase:
if (a.Length != b.Length)
{
return(false);
}
else
{
// If both strings are ASCII strings, we can take the fast path.
if (a.IsAscii() && b.IsAscii())
{
return(EqualsIgnoreCaseAsciiHelper(a, b));
}
// Take the slow path.
return(CompareInfo.CompareOrdinalIgnoreCase(a, 0, a.Length, b, 0, b.Length) == 0);
}
default:
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
}
public Boolean StartsWith(String value, StringComparison comparisonType)
{
if ((Object)value == null)
{
throw new ArgumentNullException(nameof(value));
}
if ((Object)this == (Object)value)
{
StringSpanHelpers.CheckStringComparison(comparisonType);
return(true);
}
if (value.Length == 0)
{
StringSpanHelpers.CheckStringComparison(comparisonType);
return(true);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.IsPrefix(this, value, CompareOptions.None));
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.IsPrefix(this, value, CompareOptions.IgnoreCase));
case StringComparison.Ordinal:
if (this.Length < value.Length || _firstChar != value._firstChar)
{
return(false);
}
return((value.Length == 1) ?
true : // First char is the same and thats all there is to compare
StartsWithOrdinalHelper(this, value));
case StringComparison.OrdinalIgnoreCase:
if (this.Length < value.Length)
{
return(false);
}
return(CompareInfo.CompareOrdinalIgnoreCase(this, 0, value.Length, value, 0, value.Length) == 0);
case StringComparison.InvariantCulture:
return(CompareInfo.Invariant.IsPrefix(this, value, CompareOptions.None));
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.IsPrefix(this, value, CompareOptions.IgnoreCase));
default:
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
}
public bool Equals(String value, StringComparison comparisonType)
{
if ((Object)this == (Object)value)
{
StringSpanHelpers.CheckStringComparison(comparisonType);
return(true);
}
if ((Object)value == null)
{
StringSpanHelpers.CheckStringComparison(comparisonType);
return(false);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(this, value, CompareOptions.None) == 0);
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(this, value, CompareOptions.IgnoreCase) == 0);
case StringComparison.InvariantCulture:
return(CompareInfo.Invariant.Compare(this, value, CompareOptions.None) == 0);
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.Compare(this, value, CompareOptions.IgnoreCase) == 0);
case StringComparison.Ordinal:
if (this.Length != value.Length)
{
return(false);
}
return(EqualsHelper(this, value));
case StringComparison.OrdinalIgnoreCase:
if (this.Length != value.Length)
{
return(false);
}
// If both strings are ASCII strings, we can take the fast path.
if (this.IsAscii() && value.IsAscii())
{
return(EqualsIgnoreCaseAsciiHelper(this, value));
}
return(CompareInfo.CompareOrdinalIgnoreCase(this, 0, this.Length, value, 0, value.Length) == 0);
default:
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
}
public static bool Equals(String a, String b, StringComparison comparisonType)
{
if ((Object)a == (Object)b)
{
StringSpanHelpers.CheckStringComparison(comparisonType);
return(true);
}
if ((Object)a == null || (Object)b == null)
{
StringSpanHelpers.CheckStringComparison(comparisonType);
return(false);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(a, 0, a.Length, b, 0, b.Length, CompareOptions.None) == 0);
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(a, 0, a.Length, b, 0, b.Length, CompareOptions.IgnoreCase) == 0);
case StringComparison.Ordinal:
if (a.Length != b.Length)
{
return(false);
}
return(EqualsHelper(a, b));
case StringComparison.OrdinalIgnoreCase:
if (a.Length != b.Length)
{
return(false);
}
else
{
return(CompareInfo.CompareOrdinalIgnoreCase(a, 0, a.Length, b, 0, b.Length) == 0);
}
case StringComparison.InvariantCulture:
return(CompareInfo.Invariant.Compare(a, b, CompareOptions.None) == 0);
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.Compare(a, b, CompareOptions.IgnoreCase) == 0);
default:
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
}
public static bool Equals(this ReadOnlySpan <char> span, ReadOnlySpan <char> value, StringComparison comparisonType)
{
StringSpanHelpers.CheckStringComparison(comparisonType);
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(span, value, CompareOptions.None) == 0);
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(span, value, CompareOptions.IgnoreCase) == 0);
case StringComparison.InvariantCulture:
return(CompareInfo.Invariant.Compare(span, value, CompareOptions.None) == 0);
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.Compare(span, value, CompareOptions.IgnoreCase) == 0);
case StringComparison.Ordinal:
if (span.Length != value.Length)
{
return(false);
}
if (value.Length == 0) // span.Length == value.Length == 0
{
return(true);
}
return(OrdinalHelper(span, value, value.Length));
case StringComparison.OrdinalIgnoreCase:
if (span.Length != value.Length)
{
return(false);
}
if (value.Length == 0) // span.Length == value.Length == 0
{
return(true);
}
return(CompareInfo.CompareOrdinalIgnoreCase(span, value) == 0);
}
Debug.Fail("StringComparison outside range");
return(false);
}
/// <summary>
/// Determines whether this <paramref name="span"/> and the specified <paramref name="value"/> span have the same characters
/// when compared using the specified <paramref name="comparisonType"/> option.
/// <param name="span">The source span.</param>
/// <param name="value">The value to compare with the source span.</param>
/// <param name="comparisonType">One of the enumeration values that determines how the <paramref name="span"/> and <paramref name="value"/> are compared.</param>
/// </summary>
public static bool Equals(this ReadOnlySpan <char> span, ReadOnlySpan <char> value, StringComparison comparisonType)
{
StringSpanHelpers.CheckStringComparison(comparisonType);
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(span, value, CompareOptions.None) == 0);
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(span, value, CompareOptions.IgnoreCase) == 0);
case StringComparison.InvariantCulture:
return(CompareInfo.Invariant.Compare(span, value, CompareOptions.None) == 0);
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.Compare(span, value, CompareOptions.IgnoreCase) == 0);
case StringComparison.Ordinal:
if (span.Length != value.Length)
{
return(false);
}
if (value.Length == 0) // span.Length == value.Length == 0
{
return(true);
}
return(span.SequenceEqual(value)); //TODO: Optimize - https://github.com/dotnet/corefx/issues/27487
case StringComparison.OrdinalIgnoreCase:
if (span.Length != value.Length)
{
return(false);
}
if (value.Length == 0) // span.Length == value.Length == 0
{
return(true);
}
return(CompareInfo.CompareOrdinalIgnoreCase(span, value) == 0);
}
Debug.Fail("StringComparison outside range");
return(false);
}
public Boolean EndsWith(String value, StringComparison comparisonType)
{
if ((Object)value == null)
{
throw new ArgumentNullException(nameof(value));
}
if ((Object)this == (Object)value)
{
StringSpanHelpers.CheckStringComparison(comparisonType);
return(true);
}
if (value.Length == 0)
{
StringSpanHelpers.CheckStringComparison(comparisonType);
return(true);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.IsSuffix(this, value, CompareOptions.None));
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.IsSuffix(this, value, CompareOptions.IgnoreCase));
case StringComparison.Ordinal:
return(this.Length < value.Length ? false : (CompareOrdinalHelper(this, this.Length - value.Length, value.Length, value, 0, value.Length) == 0));
case StringComparison.OrdinalIgnoreCase:
return(this.Length < value.Length ? false : (CompareInfo.CompareOrdinalIgnoreCase(this, this.Length - value.Length, value.Length, value, 0, value.Length) == 0));
case StringComparison.InvariantCulture:
return(CompareInfo.Invariant.IsSuffix(this, value, CompareOptions.None));
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.IsSuffix(this, value, CompareOptions.IgnoreCase));
default:
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
}
public static int IndexOf(this ReadOnlySpan <char> span, ReadOnlySpan <char> value, StringComparison comparisonType)
{
StringSpanHelpers.CheckStringComparison(comparisonType);
if (value.Length == 0)
{
return(0);
}
if (span.Length == 0)
{
return(-1);
}
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(IndexOfCultureHelper(span, value, CultureInfo.CurrentCulture.CompareInfo));
case StringComparison.CurrentCultureIgnoreCase:
return(IndexOfCultureIgnoreCaseHelper(span, value, CultureInfo.CurrentCulture.CompareInfo));
case StringComparison.InvariantCulture:
return(IndexOfCultureHelper(span, value, CompareInfo.Invariant));
case StringComparison.InvariantCultureIgnoreCase:
return(IndexOfCultureIgnoreCaseHelper(span, value, CompareInfo.Invariant));
case StringComparison.Ordinal:
return(IndexOfOrdinalHelper(span, value, ignoreCase: false));
case StringComparison.OrdinalIgnoreCase:
return(IndexOfOrdinalHelper(span, value, ignoreCase: true));
}
Debug.Fail("StringComparison outside range");
return(-1);
}
public static bool TryParse(ReadOnlySpan <char> value, out bool result)
{
ReadOnlySpan <char> trueSpan = TrueLiteral.AsReadOnlySpan();
if (StringSpanHelpers.Equals(trueSpan, value, StringComparison.OrdinalIgnoreCase))
{
result = true;
return(true);
}
ReadOnlySpan <char> falseSpan = FalseLiteral.AsReadOnlySpan();
if (StringSpanHelpers.Equals(falseSpan, value, StringComparison.OrdinalIgnoreCase))
{
result = false;
return(true);
}
// Special case: Trim whitespace as well as null characters.
value = TrimWhiteSpaceAndNull(value);
if (StringSpanHelpers.Equals(trueSpan, value, StringComparison.OrdinalIgnoreCase))
{
result = true;
return(true);
}
if (StringSpanHelpers.Equals(falseSpan, value, StringComparison.OrdinalIgnoreCase))
{
result = false;
return(true);
}
result = false;
return(false);
}
public static int Compare(String strA, int indexA, String strB, int indexB, int length, StringComparison comparisonType)
{
StringSpanHelpers.CheckStringComparison(comparisonType);
if (strA == null || strB == null)
{
if (object.ReferenceEquals(strA, strB))
{
// They're both null
return(0);
}
return(strA == null ? -1 : 1);
}
// @TODO: Spec#: Figure out what to do here with the return statement above.
if (length < 0)
{
throw new ArgumentOutOfRangeException(nameof(length), SR.ArgumentOutOfRange_NegativeLength);
}
if (indexA < 0 || indexB < 0)
{
string paramName = indexA < 0 ? nameof(indexA) : nameof(indexB);
throw new ArgumentOutOfRangeException(paramName, SR.ArgumentOutOfRange_Index);
}
if (strA.Length - indexA < 0 || strB.Length - indexB < 0)
{
string paramName = strA.Length - indexA < 0 ? nameof(indexA) : nameof(indexB);
throw new ArgumentOutOfRangeException(paramName, SR.ArgumentOutOfRange_Index);
}
if (length == 0 || (object.ReferenceEquals(strA, strB) && indexA == indexB))
{
return(0);
}
int lengthA = Math.Min(length, strA.Length - indexA);
int lengthB = Math.Min(length, strB.Length - indexB);
switch (comparisonType)
{
case StringComparison.CurrentCulture:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(strA, indexA, lengthA, strB, indexB, lengthB, CompareOptions.None));
case StringComparison.CurrentCultureIgnoreCase:
return(CultureInfo.CurrentCulture.CompareInfo.Compare(strA, indexA, lengthA, strB, indexB, lengthB, CompareOptions.IgnoreCase));
case StringComparison.Ordinal:
return(CompareOrdinalHelper(strA, indexA, lengthA, strB, indexB, lengthB));
case StringComparison.OrdinalIgnoreCase:
return(CompareInfo.CompareOrdinalIgnoreCase(strA, indexA, lengthA, strB, indexB, lengthB));
case StringComparison.InvariantCulture:
return(CompareInfo.Invariant.Compare(strA, indexA, lengthA, strB, indexB, lengthB, CompareOptions.None));
case StringComparison.InvariantCultureIgnoreCase:
return(CompareInfo.Invariant.Compare(strA, indexA, lengthA, strB, indexB, lengthB, CompareOptions.IgnoreCase));
default:
throw new ArgumentException(SR.NotSupported_StringComparison, nameof(comparisonType));
}
}
