public static double Parse(String s, IFormatProvider provider) { if (s == null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s); } return(Number.ParseDouble(s.AsSpan(), NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.GetInstance(provider))); }
// Converts a string to a Decimal. The string must consist of an optional // minus sign ("-") followed by a sequence of digits ("0" - "9"). The // sequence of digits may optionally contain a single decimal point (".") // character. Leading and trailing whitespace characters are allowed. // Parse also allows a currency symbol, a trailing negative sign, and // parentheses in the number. // public static Decimal Parse(String s) { if (s == null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s); } return(Number.ParseDecimal(s.AsSpan(), NumberStyles.Number, NumberFormatInfo.CurrentInfo)); }
public static Decimal Parse(String s, IFormatProvider provider) { if (s == null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s); } return(Number.ParseDecimal(s.AsSpan(), NumberStyles.Number, provider)); }
public static short Parse(String s) { if (s == null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s); } return(Parse(s.AsSpan(), NumberStyles.Integer, NumberFormatInfo.CurrentInfo)); }
private static sbyte Parse(String s, NumberStyles style, NumberFormatInfo info) { if (s == null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s); } return(Parse(s.AsSpan(), style, info)); }
public static Boolean TryParse(String s, out Decimal result) { if (s == null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s); } return(Number.TryParseDecimal(s.AsSpan(), NumberStyles.Number, null, out result)); }
// // Static Methods // // Determines whether a String represents true or false. // public static Boolean Parse(String value) { if (value == null) { throw new ArgumentNullException(nameof(value)); } return(Parse(value.AsSpan())); }
public static double Parse(String s) { if (s == null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s); } return(Number.ParseDouble(s.AsSpan(), NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.CurrentInfo)); }
public static short Parse(String s, IFormatProvider provider) { if (s == null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s); } return(Parse(s.AsSpan(), NumberStyles.Integer, NumberFormatInfo.GetInstance(provider))); }
public static short Parse(String s, NumberStyles style, IFormatProvider provider) { NumberFormatInfo.ValidateParseStyleInteger(style); if (s == null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s); } return(Parse(s.AsSpan(), style, NumberFormatInfo.GetInstance(provider))); }
public static Decimal Parse(String s, NumberStyles style, IFormatProvider provider) { NumberFormatInfo.ValidateParseStyleFloatingPoint(style); if (s == null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s); } return(Number.ParseDecimal(s.AsSpan(), style, NumberFormatInfo.GetInstance(provider))); }
public static double Parse(String s, NumberStyles style) { NumberFormatInfo.ValidateParseStyleFloatingPoint(style); if (s == null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s); } return(Number.ParseDouble(s.AsSpan(), style, NumberFormatInfo.CurrentInfo)); }
public static uint Parse(String s, NumberStyles style) { NumberFormatInfo.ValidateParseStyleInteger(style); if (s == null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s); } return(Number.ParseUInt32(s.AsSpan(), style, NumberFormatInfo.CurrentInfo)); }
public static Boolean TryParse(String s, NumberStyles style, IFormatProvider provider, out Decimal result) { ValidateParseStyleFloatingPoint(style); if (s == null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s); } return(Number.TryParseDecimal(s.AsSpan(), style, provider, out result)); }
public static Decimal Parse(String s, NumberStyles style) { ValidateParseStyleFloatingPoint(style); if (s == null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s); } return(Number.ParseDecimal(s.AsSpan(), style, null)); }
public static Boolean TryParse(String s, out Decimal result) { if (s == null) { result = 0; return(false); } return(Number.TryParseDecimal(s.AsSpan(), NumberStyles.Number, NumberFormatInfo.CurrentInfo, out result)); }
// Determines whether a String represents true or false. // public static Boolean TryParse(String value, out Boolean result) { if (value == null) { result = false; return(false); } return(TryParse(value.AsSpan(), out result)); }
public static bool TryParse(String s, out double result) { if (s == null) { result = 0; return(false); } return(TryParse(s.AsSpan(), NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.CurrentInfo, out result)); }
public static bool TryParse(String s, out Int16 result) { if (s == null) { result = 0; return(false); } return(TryParse(s.AsSpan(), NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result)); }
public static bool TryParse(String s, NumberStyles style, IFormatProvider provider, out Int16 result) { NumberFormatInfo.ValidateParseStyleInteger(style); if (s == null) { result = 0; return(false); } return(TryParse(s.AsSpan(), style, NumberFormatInfo.GetInstance(provider), out result)); }
public static Boolean TryParse(String s, NumberStyles style, IFormatProvider provider, out Decimal result) { NumberFormatInfo.ValidateParseStyleFloatingPoint(style); if (s == null) { result = 0; return(false); } return(Number.TryParseDecimal(s.AsSpan(), style, NumberFormatInfo.GetInstance(provider), out result)); }
public static bool TryParse(ReadOnlySpan <char> value, out bool result) { ReadOnlySpan <char> trueSpan = TrueLiteral.AsSpan(); if (StringSpanHelpers.Equals(trueSpan, value, StringComparison.OrdinalIgnoreCase)) { result = true; return(true); } ReadOnlySpan <char> falseSpan = FalseLiteral.AsSpan(); 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 virtual int BinarySearchLookup(System.String key) { // this special case is the reason that Arrays.binarySearch() isn't useful. if (key == null) { return(0); } int low = 1; int high = lookup.Length - 1; byte[] arr = null; Span <byte> stringAsBytes = stackalloc byte[0]; // relax the compiler var stringAsSpan = key.AsSpan(); var size = (ushort)Encoding.UTF8.GetByteCount(stringAsSpan); if (size <= 256) // allocate on the stack { stringAsBytes = stackalloc byte[size]; } else { var pooledSize = BitUtil.NextHighestPowerOfTwo(size); arr = ArrayPool <byte> .Shared.Rent(pooledSize); stringAsBytes = new Span <byte>(arr, 0, size); } try { Encoding.UTF8.GetBytes(stringAsSpan, stringAsBytes); while (low <= high) { int mid = Number.URShift((low + high), 1); int cmp = UnmanagedStringArray.UnmanagedString.CompareOrdinal(lookup[mid], stringAsBytes); if (cmp < 0) { low = mid + 1; } else if (cmp > 0) { high = mid - 1; } else { return(mid); // key found } } return(-(low + 1)); // key not found. } finally { if (arr != null) { ArrayPool <byte> .Shared.Return(arr); } } }
/// <summary> /// Postpends the elements onto this object, one by one. /// </summary> /// <param name="collection">This collection.</param> /// <param name="elements">The elements to postpend.</param> public static void Postpend(this IPostpend <Char> collection, String elements) => Postpend(collection, elements.AsSpan());
/// <summary> /// Determines whether this string and a specified <see cref="ReadOnlySpan{T}"/> of <see cref="Char"/> object have the same value. A parameter specifies the culture, case, and sort rules used in the comparison. /// </summary> /// <param name="string">The <see cref="String"/> instance.</param> /// <param name="span">The <see cref="ReadOnlySpan{T}"/> of <see cref="Char"/> to compare to this instance.</param> /// <param name="comparisonType">One of the enumeration values that specifies how the strings will be compared.</param> /// <returns><c>true</c> if the value of the <paramref name="other"/> parameter is the same as this string; otherwise, <c>false</c>.</returns> public static Boolean Equals(this String @string, ReadOnlySpan <Char> span, StringComparison comparisonType) => @string?.AsSpan().Equals(span, comparisonType) ?? false;