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)); } }