public static ICharSequence[] Split(ICharSequence sequence, int startIndex, params char[] delimiters) { if (sequence is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.sequence); } if (delimiters is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.delimiters); } int length = sequence.Count; uint uLength = (uint)length; if (0u >= uLength) { return(new[] { sequence }); } if ((uint)startIndex >= uLength) { ThrowHelper.ThrowIndexOutOfRangeException(); } var delimitersSpan = delimiters.AsSpan(); List <ICharSequence> result = InternalThreadLocalMap.Get().CharSequenceList(); int i = startIndex; while ((uint)i < uLength) { while ((uint)i < uLength && delimitersSpan.IndexOf(sequence[i]) >= 0) { i++; } int position = i; if ((uint)i < uLength) { if (delimitersSpan.IndexOf(sequence[position]) >= 0) { result.Add(sequence.SubSequence(position++, i + 1)); } else { ICharSequence seq = null; for (position++; position < length; position++) { if (delimitersSpan.IndexOf(sequence[position]) >= 0) { seq = sequence.SubSequence(i, position); break; } } result.Add(seq ?? sequence.SubSequence(i)); } i = position; } } return(0u >= (uint)result.Count ? new[] { sequence } : result.ToArray()); }
/// <summary> /// Decides if the pattern and context match the input starting at a position. It is a match if the /// <see cref="LContext"/> matches <paramref name="input"/> up to <paramref name="i"/>, <see cref="Pattern"/> matches at <paramref name="i"/> and /// <see cref="RContext"/> matches from the end of the match of <see cref="Pattern"/> to the end of <paramref name="input"/>. /// </summary> /// <param name="input">The input <see cref="ICharSequence"/>.</param> /// <param name="i">The int position within the input.</param> /// <returns><c>true</c> if the pattern and left/right context match, <c>false</c> otherwise.</returns> public virtual bool PatternAndContextMatches(ICharSequence input, int i) { if (i < 0) { throw new ArgumentOutOfRangeException("Can not match pattern at negative indexes"); } int patternLength = this.pattern.Length; int ipl = i + patternLength; if (ipl > input.Length) { // not enough room for the pattern to match return(false); } // evaluate the pattern, left context and right context // fail early if any of the evaluations is not successful if (!input.SubSequence(i, ipl).Equals(this.pattern)) { return(false); } else if (!this.rContext.IsMatch(input.SubSequence(ipl, input.Length))) { return(false); } return(this.lContext.IsMatch(input.SubSequence(0, i))); }
private void DoTestSequence(ICharSequence c) { // slice Assert.AreEqual("a", c.SubSequence(0, 1).ToString()); // mid subsequence Assert.AreEqual("b", c.SubSequence(1, 2).ToString()); // end subsequence Assert.AreEqual("bc", c.SubSequence(1, 3).ToString()); // empty subsequence Assert.AreEqual("", c.SubSequence(0, 0).ToString()); try { c.SubSequence(-1, 1); Assert.Fail(); } #pragma warning disable 168 catch (System.IndexOutOfRangeException expected) #pragma warning restore 168 { // expected exception } try { c.SubSequence(0, -1); Assert.Fail(); } #pragma warning disable 168 catch (System.IndexOutOfRangeException expected) #pragma warning restore 168 { // expected exception } try { c.SubSequence(0, 4); Assert.Fail(); } #pragma warning disable 168 catch (System.IndexOutOfRangeException expected) #pragma warning restore 168 { // expected exception } try { c.SubSequence(2, 1); Assert.Fail(); } #pragma warning disable 168 catch (System.IndexOutOfRangeException expected) #pragma warning restore 168 { // expected exception } }
public static ICharSequence Trim(ICharSequence c) { if (c is AsciiString asciiString) { return(asciiString.Trim()); } if (0u >= (uint)c.Count) { return(c); } int start = 0; int last = c.Count - 1; int end = last; uint uEnd = (uint)end; while ((uint)start <= uEnd && c[start] <= uSpace) { start++; } while (end >= start && c[end] <= uSpace) { end--; } if (0u >= (uint)start && end == last) { return(c); } return(c.SubSequence(start, end + 1)); }
public static ICharSequence GetCharsetAsSequence(ICharSequence contentTypeValue) { if (contentTypeValue is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.contentTypeValue); } int indexOfCharset = AsciiString.IndexOfIgnoreCaseAscii(contentTypeValue, CharsetEquals, 0); if ((uint)indexOfCharset >= NIndexNotFound) { return(null); } int indexOfEncoding = indexOfCharset + CharsetEquals.Count; if (indexOfEncoding < contentTypeValue.Count) { var charsetCandidate = contentTypeValue.SubSequence(indexOfEncoding, contentTypeValue.Count); int indexOfSemicolon = AsciiString.IndexOfIgnoreCaseAscii(charsetCandidate, Semicolon, 0); if ((uint)indexOfSemicolon >= NIndexNotFound) { return(charsetCandidate); } return(charsetCandidate.SubSequence(0, indexOfSemicolon)); } return(null); }
private static ICharSequence EscapeChar(ICharSequence str, CultureInfo locale) { if (str == null || str.Length == 0) { return(str); } ICharSequence buffer = str; // regular escapable Char for terms for (int i = 0; i < escapableTermChars.Length; i++) { buffer = ReplaceIgnoreCase(buffer, locale.TextInfo.ToLower(escapableTermChars[i]), "\\", locale); } // First Character of a term as more escaping chars for (int i = 0; i < escapableTermExtraFirstChars.Length; i++) { if (buffer[0] == escapableTermExtraFirstChars[i][0]) { buffer = new StringCharSequenceWrapper("\\" + buffer[0] + buffer.SubSequence(1, buffer.Length).ToString()); break; } } return(buffer); }
void ITextWatcher.OnTextChanged(ICharSequence s, int start, int before, int count) { if (Mask != null) { if (!_editingOnChanged && _editingBefore) { _editingOnChanged = true; if (_ignore) { return; } if (count > 0) { var startingPosition = _maskToRaw[NextValidPosition(start)]; var addedString = s.SubSequence(start, start + count).ToString(); count = _rawText.AddToString(Clear(addedString), startingPosition, _maxRawLength); if (_initialized) { int currentPosition = startingPosition + count < _rawToMask.Length ? _rawToMask[startingPosition + count] : currentPosition = _lastValidMaskPosition + 1; _selection = NextValidPosition(currentPosition); } } } } }
public static string GetString(ByteBuffer bytes, int length, int additionalSkipLength) { ICharSequence cs = bytes.AsCharBuffer(); string s = cs.SubSequence(0, length).ToString(); SkipBytes(bytes, length * 2 + additionalSkipLength); return(s); }
public void Append(ICharSequence value, int index, int count) { if (value == null || count == 0) { return; } this.Append(value.SubSequence(index, index + count)); }
public void Append(ICharSequence value, int index, int count) { if (value is null || 0u >= (uint)count) { return; } this.Append(value.SubSequence(index, index + count)); }
public static ICharSequence[] Split(ICharSequence sequence, int startIndex, params char[] delimiters) { Contract.Requires(sequence != null); Contract.Requires(delimiters != null); Contract.Requires(startIndex >= 0 && startIndex < sequence.Count); List <ICharSequence> result = InternalThreadLocalMap.Get().CharSequenceList(); int i = startIndex; int length = sequence.Count; while (i < length) { while (i < length && IndexOf(delimiters, sequence[i]) >= 0) { i++; } int position = i; if (i < length) { if (IndexOf(delimiters, sequence[position]) >= 0) { result.Add(sequence.SubSequence(position++, i + 1)); } else { ICharSequence seq = null; for (position++; position < length; position++) { if (IndexOf(delimiters, sequence[position]) >= 0) { seq = sequence.SubSequence(i, position); break; } } result.Add(seq ?? sequence.SubSequence(i)); } i = position; } } return(result.Count == 0 ? new[] { sequence } : result.ToArray()); }
public static int ParseInt(ICharSequence seq, int start, int end, int radix, bool negative) { Contract.Requires(seq != null); Contract.Requires(radix >= MinRadix && radix <= MaxRadix); int max = int.MinValue / radix; int result = 0; int currOffset = start; while (currOffset < end) { int digit = Digit((char)(seq[currOffset++] & 0xFF), radix); if (digit == -1) { throw new FormatException(seq.SubSequence(start, end).ToString()); } if (max > result) { throw new FormatException(seq.SubSequence(start, end).ToString()); } int next = result * radix - digit; if (next > result) { throw new FormatException(seq.SubSequence(start, end).ToString()); } result = next; } if (!negative) { result = -result; if (result < 0) { throw new FormatException(seq.SubSequence(start, end).ToString()); } } return(result); }
/** * Writes chars of the given {@code CharSequence} to the current position of * this buffer, and increases the position by the number of chars written. * * @param csq * the {@code CharSequence} to write. * @param start * the first char to write, must not be negative and not greater * than {@code csq.length()}. * @param end * the last char to write (excluding), must be less than * {@code start} and not greater than {@code csq.length()}. * @return this buffer. * @exception BufferOverflowException * if {@code remaining()} is less than {@code end - start}. * @exception IndexOutOfBoundsException * if either {@code start} or {@code end} is invalid. * @exception ReadOnlyBufferException * if no changes may be made to the contents of this buffer. */ public virtual CharBuffer Append(ICharSequence csq, int start, int end) { if (csq == null) { csq = "null".ToCharSequence(); //$NON-NLS-1$ } ICharSequence cs = csq.SubSequence(start, end); if (cs.Length > 0) { return(Put(cs.ToString())); } return(this); }
public static ICharSequence TrimOws(ICharSequence value) { int length = value.Count; if (length == 0) { return(value); } int start = IndexOfFirstNonOwsChar(value, length); int end = IndexOfLastNonOwsChar(value, start, length); return(start == 0 && end == length - 1 ? value : value.SubSequence(start, end + 1)); }
string subString(ICharSequence source, int start, int end) { start = System.Math.Max(0, start); start = System.Math.Min(source.Length(), start); //the begin index, inclusive. end = System.Math.Max(0, end); end = System.Math.Min(source.Length(), end); // the end index, exclusive. if (start >= 0 && end >= 0 && end >= start) { return(source.SubSequence(start, end)); } return(string.Empty); }
public static ICharSequence GetMimeType(ICharSequence contentTypeValue) { if (contentTypeValue is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.contentTypeValue); } int indexOfSemicolon = AsciiString.IndexOfIgnoreCaseAscii(contentTypeValue, Semicolon, 0); if ((uint)indexOfSemicolon < NIndexNotFound) { return(contentTypeValue.SubSequence(0, indexOfSemicolon)); } return((uint)contentTypeValue.Count > 0u ? contentTypeValue : null); }
public static ICharSequence GetMimeType(ICharSequence contentTypeValue) { if (contentTypeValue == null) { throw new ArgumentException(nameof(contentTypeValue)); } int indexOfSemicolon = AsciiString.IndexOfIgnoreCaseAscii(contentTypeValue, Semicolon, 0); if (indexOfSemicolon != AsciiString.IndexNotFound) { return(contentTypeValue.SubSequence(0, indexOfSemicolon)); } return(contentTypeValue.Count > 0 ? contentTypeValue : null); }
public static ICharSequence GetCharsetAsSequence(ICharSequence contentTypeValue) { if (contentTypeValue == null) { throw new ArgumentException(nameof(contentTypeValue)); } int indexOfCharset = AsciiString.IndexOfIgnoreCaseAscii(contentTypeValue, CharsetEquals, 0); if (indexOfCharset != AsciiString.IndexNotFound) { int indexOfEncoding = indexOfCharset + CharsetEquals.Count; if (indexOfEncoding < contentTypeValue.Count) { return(contentTypeValue.SubSequence(indexOfEncoding, contentTypeValue.Count)); } } return(null); }
internal static ICharSequence UnwrapValue(ICharSequence cs) { int len = cs.Count; if (len > 0 && cs[0] == HttpConstants.DoubleQuoteChar) { if (len >= 2 && cs[len - 1] == HttpConstants.DoubleQuoteChar) { // properly balanced return(len == 2 ? StringCharSequence.Empty : cs.SubSequence(1, len - 1)); } else { return(null); } } return(cs); }
public static ICharSequence Trim(ICharSequence sequence) { Contract.Requires(sequence != null); int length = sequence.Count; int start = IndexOfFirstNonWhiteSpace(sequence); if (start == length) { return(StringCharSequence.Empty); } int last = IndexOfLastNonWhiteSpaceChar(sequence, start); length = last - start + 1; return(length == sequence.Count ? sequence : sequence.SubSequence(start, last + 1)); }
public ICharSequence FilterFormatted(ICharSequence source, int start, int end, ISpanned dest, int dstart, int dend) { var textToCheck = dest.SubSequence(0, dstart) + source.SubSequence(start, end) + dest.SubSequence(dend, dest.Length()); var matcher = pattern.Matcher(textToCheck); // Entered text does not match the pattern if (!matcher.Matches()) { // It does not match partially too if (!matcher.HitEnd()) { return(null); } } return(null); }
public static int ParseInt(ICharSequence seq, int start, int end, int radix) { Contract.Requires(seq != null); Contract.Requires(radix >= MinRadix && radix <= MaxRadix); if (start == end) { throw new FormatException(); } int i = start; bool negative = seq[i] == '-'; if (negative && ++i == end) { throw new FormatException(seq.SubSequence(start, end).ToString()); } return(ParseInt(seq, i, end, radix, negative)); }
public override int GetSize(Paint paint, ICharSequence text, int start, int end, Paint.FontMetricsInt fm) => (int)(margin + padding + paint.MeasureText(text.SubSequence(start, end)) + padding + margin);
public override CharBuffer Slice() { return(new CharSequenceAdapter(sequence.SubSequence(position, limit))); }
private void DoTestSequence(ICharSequence c) { // slice Assert.AreEqual("a", c.SubSequence(0, 1).ToString()); // mid subsequence Assert.AreEqual("b", c.SubSequence(1, 2).ToString()); // end subsequence Assert.AreEqual("bc", c.SubSequence(1, 3).ToString()); // empty subsequence Assert.AreEqual("", c.SubSequence(0, 0).ToString()); try { c.SubSequence(-1, 1); Assert.Fail(); } catch (System.IndexOutOfRangeException expected) { // expected exception } try { c.SubSequence(0, -1); Assert.Fail(); } catch (System.IndexOutOfRangeException expected) { // expected exception } try { c.SubSequence(0, 4); Assert.Fail(); } catch (System.IndexOutOfRangeException expected) { // expected exception } try { c.SubSequence(2, 1); Assert.Fail(); } catch (System.IndexOutOfRangeException expected) { // expected exception } }
public override TextWriter Append(ICharSequence charSequence, int i, int i1) { LogB(charSequence.SubSequence(i, i1)); return(this); }
public static ICharSequence SubstringAfter(this ICharSequence value, char delim) { int pos = value.IndexOf(delim); return(pos >= 0 ? value.SubSequence(pos + 1, value.Count) : null); }
/// <summary> /// Escapes the specified value, if necessary according to /// <a href="https://tools.ietf.org/html/rfc4180#section-2">RFC-4180</a>. /// </summary> /// <param name="value"> /// The value which will be escaped according to /// <a href="https://tools.ietf.org/html/rfc4180#section-2">RFC-4180</a> /// </param> /// <param name="trimWhiteSpace"> /// The value will first be trimmed of its optional white-space characters, according to /// <a href= "https://tools.ietf.org/html/rfc7230#section-7" >RFC-7230</a> /// </param> /// <returns>the escaped value if necessary, or the value unchanged</returns> public static ICharSequence EscapeCsv(ICharSequence value, bool trimWhiteSpace = false) { Contract.Requires(value != null); int length = value.Count; if (length == 0) { return(value); } int start; int last; if (trimWhiteSpace) { start = IndexOfFirstNonOwsChar(value, length); last = IndexOfLastNonOwsChar(value, start, length); } else { start = 0; last = length - 1; } if (start > last) { return(StringCharSequence.Empty); } int firstUnescapedSpecial = -1; bool quoted = false; if (IsDoubleQuote(value[start])) { quoted = IsDoubleQuote(value[last]) && last > start; if (quoted) { start++; last--; } else { firstUnescapedSpecial = start; } } if (firstUnescapedSpecial < 0) { if (quoted) { for (int i = start; i <= last; i++) { if (IsDoubleQuote(value[i])) { if (i == last || !IsDoubleQuote(value[i + 1])) { firstUnescapedSpecial = i; break; } i++; } } } else { for (int i = start; i <= last; i++) { char c = value[i]; if (c == LineFeed || c == CarriageReturn || c == Comma) { firstUnescapedSpecial = i; break; } if (IsDoubleQuote(c)) { if (i == last || !IsDoubleQuote(value[i + 1])) { firstUnescapedSpecial = i; break; } i++; } } } if (firstUnescapedSpecial < 0) { // Special characters is not found or all of them already escaped. // In the most cases returns a same string. New string will be instantiated (via StringBuilder) // only if it really needed. It's important to prevent GC extra load. return(quoted ? value.SubSequence(start - 1, last + 2) : value.SubSequence(start, last + 1)); } } var result = new StringBuilderCharSequence(last - start + 1 + CsvNumberEscapeCharacters); result.Append(DoubleQuote); result.Append(value, start, firstUnescapedSpecial - start); for (int i = firstUnescapedSpecial; i <= last; i++) { char c = value[i]; if (IsDoubleQuote(c)) { result.Append(DoubleQuote); if (i < last && IsDoubleQuote(value[i + 1])) { i++; } } result.Append(c); } result.Append(DoubleQuote); return(result); }
public void Run() { try { int textLengthNew = Option.TextLength; if (Option.TextLengthType == TypeLine) { if (TextView.Layout.LineCount <= Option.TextLength) { TextView.SetText(Text, Android.Widget.TextView.BufferType.Spannable); return; } ViewGroup.MarginLayoutParams lp = (ViewGroup.MarginLayoutParams)TextView.LayoutParameters; string subString = Text.ToString().Substring(TextView.Layout.GetLineStart(0), TextView.Layout.GetLineEnd(Option.TextLength - 1)); textLengthNew = subString.Length - (Option.MoreLabel.Length + 4 + lp.RightMargin / 6); } SpannableStringBuilder spendableStringBuilder = new SpannableStringBuilder(Text.SubSequence(0, textLengthNew)); spendableStringBuilder.Append(" ..."); spendableStringBuilder.Append(Option.MoreLabel); SpannableString ss = SpannableString.ValueOf(spendableStringBuilder); ClickableSpan rclickableSpan = new StRclickableSpan(Option, TextView, Text, StTools.StTypeText.ReadMore); ss.SetSpan(rclickableSpan, ss.Length() - Option.MoreLabel.Length, ss.Length(), SpanTypes.ExclusiveExclusive); if (Build.VERSION.SdkInt >= BuildVersionCodes.JellyBean && Option.ExpandAnimation) { LayoutTransition layoutTransition = new LayoutTransition(); layoutTransition.EnableTransitionType(LayoutTransitionType.Changing); ((ViewGroup)TextView.Parent).LayoutTransition = layoutTransition; } //TextView.SetTextFuture(PrecomputedTextCompat.GetTextFuture(ss, TextViewCompat.GetTextMetricsParams(TextView), null)); TextView.SetText(ss, Android.Widget.TextView.BufferType.Spannable); TextView.MovementMethod = LinkMovementMethod.Instance; } catch (Exception e) { Console.WriteLine(e); } }
// // Check from the request ContentType if this request is a Multipart request. // return an array of String if multipartDataBoundary exists with the multipartDataBoundary // as first element, charset if any as second (missing if not set), else null // protected internal static ICharSequence[] GetMultipartDataBoundary(ICharSequence contentType) { // Check if Post using "multipart/form-data; boundary=--89421926422648 [; charset=xxx]" ICharSequence[] headerContentType = SplitHeaderContentType(contentType); AsciiString multiPartHeader = HttpHeaderValues.MultipartFormData; if (headerContentType[0].RegionMatchesIgnoreCase(0, multiPartHeader, 0, multiPartHeader.Count)) { int mrank; int crank; AsciiString boundaryHeader = HttpHeaderValues.Boundary; if (headerContentType[1].RegionMatchesIgnoreCase(0, boundaryHeader, 0, boundaryHeader.Count)) { mrank = 1; crank = 2; } else if (headerContentType[2].RegionMatchesIgnoreCase(0, boundaryHeader, 0, boundaryHeader.Count)) { mrank = 2; crank = 1; } else { return(null); } ICharSequence boundary = headerContentType[mrank].SubstringAfter(HttpConstants.EqualsSignChar); if (boundary is null) { ThrowHelper.ThrowErrorDataDecoderException_NeedBoundaryValue(); } if (boundary[0] == HttpConstants.DoubleQuoteChar) { ICharSequence bound = CharUtil.Trim(boundary); int index = bound.Count - 1; if (bound[index] == HttpConstants.DoubleQuoteChar) { boundary = bound.SubSequence(1, index); } } AsciiString charsetHeader = HttpHeaderValues.Charset; if (headerContentType[crank].RegionMatchesIgnoreCase(0, charsetHeader, 0, charsetHeader.Count)) { ICharSequence charset = headerContentType[crank].SubstringAfter(HttpConstants.EqualsSignChar); if (charset is object) { return(new[] { new StringCharSequence("--" + boundary.ToString()), charset }); } } return(new ICharSequence[] { new StringCharSequence("--" + boundary.ToString()) }); } return(null); }
/// <summary> /// /// </summary> /// <param name="field">field name</param> /// <param name="text">value that contains a regular expression</param> /// <param name="begin">position in the query string</param> /// <param name="end">position in the query string</param> public RegexpQueryNode(string field, ICharSequence text, int begin, int end) { this.field = field; this.text = text.SubSequence(begin, end); }