public static void Split(this Utf8Span this_, byte ch, StringSplitOptions options, ref Utf8SpanArray arr)
{
arr.data1 = this_;
var removeEmpty = (options & StringSplitOptions.RemoveEmptyEntries) != 0;
var index = 0;
var pos = 0;
arr.count = 0;
while (true)
{
var idx = this_.SubstringRaw(pos).IndexOfRaw(ch);
if (idx == -1)
{
break;
}
else
{
idx += pos;
}
var length = idx != -1 ? idx - pos : this_.Length() - pos;
if (!removeEmpty || length != 0)
{
arr.Add(pos, length);
index++;
}
pos = idx + 1;
}
var last = this_.SubstringRaw(pos);
if (!removeEmpty || last.Length() != 0)
{
arr.Add(pos, last.Length());
}
}
public static Utf8Span ReadTo(ref Utf8Span str, byte end)
{
var idx = str.IndexOfRaw(end);
if (idx == -1)
{
throw new FormatException();
}
var v = str.SubstringRaw(0, idx);
str = str.SubstringRaw(idx + 1);
return(v);
}
public static int IsLetter(Utf8Span str, int offset)
{
str = str.SubstringRaw(offset);
var ch = str.CharAt(0);
if (ch >= 'a' && ch <= 'z')
{
return(1);
}
if (ch >= 'A' && ch <= 'Z')
{
return(1);
}
if (ch < 128)
{
return(0);
}
var enu = str.GetEnumerator();
if (!enu.MoveNext())
{
return(0);
}
var l = enu.Current;
if (l > char.MaxValue)
{
return(0);
}
if (!char.IsLetter((char)l))
{
return(0);
}
return(new Utf8String(l.ToString()).Length());
}
public static Utf8Span TrimEndSimple(this Utf8Span str)
{
while (str.Length() != 0 && Utf8Utils.IsWhiteSpace(str.CharAt(str.Length() - 1)))
{
str = str.SubstringRaw(0, str.Length() - 1);
}
return(str);
}
public static bool EndsWithRaw(this Utf8Span str, Utf8Span value, StringComparison comparisonType = StringComparison.Ordinal)
{
if (str.Length() < value.Length())
{
return(false);
}
return(str.SubstringRaw(str.Length() - value.Length()).EqualsRaw(value, comparisonType));
}
public static Utf8Span TryCaptureBetween(this Utf8Span str, byte before, byte after)
{
var start = str.IndexOfRaw(before);
if (start == -1)
{
return(Utf8Span.Empty);
}
str = str.SubstringRaw(start + 1);
var end = str.IndexOfRaw(after);
if (end == -1)
{
return(Utf8Span.Empty);
}
return(str.SubstringRaw(0, end));
}
public static Utf8Span CaptureBetween(this Utf8Span str, byte before, byte after)
{
var start = str.IndexOfRaw(before);
if (start == -1)
{
throw new InvalidDataException();
}
str = str.SubstringRaw(start + 1);
var end = str.IndexOfRaw(after);
if (end == -1)
{
throw new InvalidDataException();
}
return(str.SubstringRaw(0, end));
}
public static Utf8Span TryCaptureBetween(this Utf8Span str, Utf8Span before, Utf8Span after, StringComparison comparisonType = StringComparison.Ordinal)
{
var start = str.IndexOfRaw(before, comparisonType);
if (start == -1)
{
return(Utf8Span.Empty);
}
str = str.SubstringRaw(start + before.Length());
var end = str.IndexOfRaw(after, comparisonType);
if (end == -1)
{
return(Utf8Span.Empty);
}
return(str.SubstringRaw(0, end));
}
public static Utf8Span CaptureBetween(this Utf8Span str, Utf8Span before, Utf8Span after, StringComparison comparisonType = StringComparison.Ordinal)
{
var start = str.IndexOfRaw(before, comparisonType);
if (start == -1)
{
throw new InvalidDataException();
}
str = str.SubstringRaw(start + before.Length());
var end = str.IndexOfRaw(after, comparisonType);
if (end == -1)
{
throw new InvalidDataException();
}
return(str.SubstringRaw(0, end));
}
public static Utf8Span TryCaptureBefore(this Utf8Span str, byte suffix)
{
var end = str.IndexOfRaw(suffix);
if (end == -1)
{
return(Utf8Span.Empty);
}
return(str.SubstringRaw(0, end));
}
public static Utf8Span TryCaptureAfter(this Utf8Span str, byte prefix)
{
var start = str.IndexOfRaw(prefix);
if (start == -1)
{
return(Utf8Span.Empty);
}
return(str.SubstringRaw(start + 1));
}
public static Utf8Span TryCaptureAfter(this Utf8Span str, Utf8Span prefix, StringComparison comparisonType = StringComparison.Ordinal)
{
var start = str.IndexOfRaw(prefix, comparisonType);
if (start == -1)
{
return(Utf8Span.Empty);
}
return(str.SubstringRaw(start + prefix.Length()));
}
public static Utf8Span CaptureBefore(this Utf8Span str, byte suffix)
{
var end = str.IndexOfRaw(suffix);
if (end == -1)
{
throw new InvalidDataException();
}
return(str.SubstringRaw(0, end));
}
public static Utf8Span CaptureBefore(this Utf8Span str, Utf8Span suffix, StringComparison comparisonType = StringComparison.Ordinal)
{
var end = str.IndexOfRaw(suffix, comparisonType);
if (end == -1)
{
throw new InvalidDataException();
}
return(str.SubstringRaw(0, end));
}
public static Utf8Span CaptureAfter(this Utf8Span str, Utf8Span prefix, StringComparison comparisonType = StringComparison.Ordinal)
{
var start = str.IndexOfRaw(prefix, comparisonType);
if (start == -1)
{
throw new InvalidDataException();
}
return(str.SubstringRaw(start + prefix.Length()));
}
public static Utf8Span CaptureAfter(this Utf8Span str, byte prefix)
{
var start = str.IndexOfRaw(prefix);
if (start == -1)
{
throw new InvalidDataException();
}
return(str.SubstringRaw(start + 1));
}
public static Utf8Span TryCaptureBefore(this Utf8Span str, Utf8Span suffix, StringComparison comparisonType = StringComparison.Ordinal)
{
var end = str.IndexOfRaw(suffix, comparisonType);
if (end == -1)
{
return(Utf8Span.Empty);
}
return(str.SubstringRaw(0, end));
}
public Utf8Span this[int index]
{
get
{
var b = boundaries[index];
if (b.Length < 0)
{
return(data2.SubstringRaw(b.Start, -b.Length));
}
return(data1.SubstringRaw(b.Start, b.Length));
}
}
private static int IndexOfRawCaseInsensitive(Utf8Span str, Utf8Span value)
{
var maxToCheck = str.Length() - value.Length();
for (int i = 0; i <= maxToCheck; i++)
{
if (EqualsIgnoreCaseRaw(str.SubstringRaw(i, value.Length()), value))
{
return(i);
}
}
return(-1);
}
public static DateTime ParseDateConcatenated(Utf8Span date)
{
if (date.Length() != 14)
{
throw new FormatException();
}
return(new DateTime(
ParseInt32(date.SubstringRaw(0, 4)),
ParseInt32(date.SubstringRaw(4, 2)),
ParseInt32(date.SubstringRaw(6, 2)),
ParseInt32(date.SubstringRaw(8, 2)),
ParseInt32(date.SubstringRaw(10, 2)),
ParseInt32(date.SubstringRaw(12, 2)),
DateTimeKind.Utc
));
}
public static DateTime ParseDateSeparated(Utf8Span date)
{
if (date.Length() != 19)
{
throw new FormatException();
}
return(new DateTime(
ParseInt32(date.SubstringRaw(0, 4)),
ParseInt32(date.SubstringRaw(5, 2)),
ParseInt32(date.SubstringRaw(8, 2)),
ParseInt32(date.SubstringRaw(11, 2)),
ParseInt32(date.SubstringRaw(14, 2)),
ParseInt32(date.SubstringRaw(17, 2)),
DateTimeKind.Utc
));
}
public Utf8SpanWithIndex SubstringRaw(int start, int length)
{
return(new Utf8SpanWithIndex(Span.SubstringRaw(start, length), this.Index + start));
}
public static int IndexOfRaw(this Utf8Span str, byte value, int start)
{
var k = str.SubstringRaw(start).IndexOfRaw(value);
return(k != -1 ? start + k : -1);
}
public static int IndexOfRaw(this Utf8Span str, Utf8Span value, int start, StringComparison comparisonType = StringComparison.Ordinal)
{
var k = str.SubstringRaw(start).IndexOfRaw(value, comparisonType);
return(k != -1 ? start + k : -1);
}
