public void IndexOfAny_SearchOnlyInsideTheRange_IfStartAndCountAreProvided()
{
// Arrange
const string buffer = "Hello, World!, Hello people!";
var segment = new StringSegment(buffer, 3, buffer.Length - 3);
// Act
var result = segment.IndexOfAny(new[] { '!' }, 15, 5);
// Assert
Assert.Equal(-1, result);
}
public void IndexOfAny_SkipsANumberOfCaracters_IfStartIsProvided()
{
// Arrange
const string buffer = "Hello, World!, Hello people!";
var segment = new StringSegment(buffer, 3, buffer.Length - 3);
// Act
var result = segment.IndexOfAny(new[] { '!' }, 15);
// Assert
Assert.Equal(buffer.Length - 4, result);
}
private static StringSegment UnEscapeJsonString(StringSegment json, ref int index)
{
if (json.IsNullOrEmpty())
{
return(json);
}
var jsonLength = json.Length;
var buffer = json.Buffer;
var offset = json.Offset;
var firstChar = buffer[offset + index];
if (firstChar == JsonUtils.QuoteChar)
{
index++;
// MicroOp: See if we can short-circuit evaluation (to avoid StringBuilder)
var strEndPos = json.IndexOfAny(IsSafeJsonChars, index);
if (strEndPos == -1)
{
return(json.Subsegment(index, jsonLength - index));
}
if (json.GetChar(strEndPos) == JsonUtils.QuoteChar)
{
var potentialValue = json.Subsegment(index, strEndPos - index);
index = strEndPos + 1;
return(potentialValue);
}
}
else
{
var i = index + offset;
var end = offset + jsonLength;
while (i < end)
{
var c = buffer[i];
if (c == JsonUtils.QuoteChar || c == JsonUtils.EscapeChar)
{
break;
}
i++;
}
if (i == end)
{
return(new StringSegment(buffer, offset + index, jsonLength - index));
}
}
return(Unescape(json));
}
private static SipResponse CreateResponse(StringSegment headers, ReadOnlyMemory <byte> body)
{
var firstSeparatorIndex = headers.IndexOfAny(WordDelimiters);
var version = headers.Subsegment(0, firstSeparatorIndex);
var afterVersionChars = headers.Subsegment(firstSeparatorIndex + 1);
var secondSeparatorIndex = afterVersionChars.IndexOfAny(WordDelimiters);
var statusCode = afterVersionChars.Subsegment(0, secondSeparatorIndex);
var afterStatusCodeChars = afterVersionChars.Subsegment(secondSeparatorIndex + 1);
var lineBreakIndex = afterStatusCodeChars.AsSpan().IndexOf(CRLFString.AsSpan());
var reasonPhrase = afterStatusCodeChars.Subsegment(0, lineBreakIndex);
return(new SipResponse(headers, statusCode, reasonPhrase, version, body));
}
private static StringSegment ReadDisplayName(StringSegment chars)
{
var isQuoted = TryReadQuotedDisplayName(chars, out var startIndex, out var length);
var skipQuotedOffset = isQuoted ? startIndex + length : 0;
var displayNameEndIndex = chars.IndexOfAny(UriOrParametersStart, skipQuotedOffset);
if (displayNameEndIndex < 0)
{
return(StringSegment.Empty);
}
return(chars.Subsegment(0, displayNameEndIndex));
}
public bool TryRead(BlittableJsonReaderObject docReader, StringSegment path, out object result, out StringSegment leftPath)
{
var indexOfFirstSeparator = path.IndexOfAny(_separators, 0);
object reader;
//if not found -> indexOfFirstSeparator == -1 -> take whole includePath as segment
if (docReader.TryGetMember(path.SubSegment(0, indexOfFirstSeparator), out reader) == false)
{
leftPath = path;
result = null;
return(false);
}
if (indexOfFirstSeparator == -1)
{
leftPath = path;
result = reader;
return(true);
}
var pathSegment = path.SubSegment(indexOfFirstSeparator + 1);
switch (path[indexOfFirstSeparator])
{
case PropertySeparator:
var subObject = reader as BlittableJsonReaderObject;
if (subObject != null)
{
return(TryRead(subObject, pathSegment, out result, out leftPath));
}
leftPath = pathSegment;
result = reader;
return(false);
case CollectionSeparator:
var subArray = reader as BlittableJsonReaderArray;
if (subArray != null)
{
leftPath = pathSegment;
result = ReadArray(subArray, pathSegment);
return(true);
}
throw new InvalidOperationException($"Invalid path. After the collection separator ('{CollectionSeparator}') {reader?.GetType()?.FullName ?? "null"} object has been ancountered instead of {nameof(BlittableJsonReaderArray)}.");
default:
throw new NotSupportedException($"Unhandled separator character: {path[indexOfFirstSeparator]}");
}
}
private IEnumerable <object> ReadArray(BlittableJsonReaderArray array, StringSegment pathSegment)
{
// ReSharper disable once ForCanBeConvertedToForeach
for (int i = 0; i < array.Length; i++)
{
var item = array[i];
var arrayObject = item as BlittableJsonReaderObject;
if (arrayObject != null)
{
object result;
StringSegment leftPath;
if (TryRead(arrayObject, pathSegment, out result, out leftPath))
{
var enumerable = result as IEnumerable;
if (enumerable != null)
{
foreach (var nestedItem in enumerable)
{
yield return(nestedItem);
}
}
else
{
yield return(result);
}
}
}
else
{
var arrayReader = item as BlittableJsonReaderArray;
if (arrayReader != null)
{
var indexOfFirstSeparatorInSubIndex = pathSegment.IndexOfAny(_separators, 0);
var subSegment = pathSegment.SubSegment(indexOfFirstSeparatorInSubIndex + 1);
foreach (var nestedItem in ReadArray(arrayReader, subSegment))
{
yield return(nestedItem);
}
}
else
{
yield return(item);
}
}
}
}
public void FindEscapePositionsIn(StringSegment str)
{
EscapePositions.Clear();
var lastEscape = 0;
while (true)
{
var curEscape = str.IndexOfAny(EscapeChars, lastEscape);
if (curEscape == -1)
{
break;
}
EscapePositions.Add(curEscape - lastEscape);
lastEscape = curEscape + 1;
}
}
private StringSegment GetNextToken(StringSegment path, out int consumed)
{
int SkipQuote(char ch, int i)
{
for (int j = i; j < path.Length; j++)
{
if (path[j] == '\'')
{
j++;// escape next chart
continue;
}
if (path[j] == ch)
{
return(j);
}
}
return(path.Length);
}
if (path.Length == 0)
{
consumed = 0;
return(path);
}
if (path[0] == '"' || path[0] == '\'')
{
consumed = SkipQuote(path[0], 1);
return(path.Subsegment(1, consumed - 2));
}
consumed = path.IndexOfAny(_separators, 0);
if (consumed == -1)
{
return(path);
}
return(path.Subsegment(0, consumed));
}
public static bool TryReadComputedProperties(BlittableJsonTraverser blittableJsonTraverser, StringSegment leftPath, ref object value)
{
value = TypeConverter.ConvertForIndexing(value);
if (leftPath == "Length" || leftPath == "length" ||
leftPath == "Count" || leftPath == "count")
{
if (value is LazyStringValue lazyStringValue)
{
value = lazyStringValue.Size;
return(true);
}
if (value is string s)
{
value = s.Length;
return(true);
}
if (value is LazyCompressedStringValue lazyCompressedStringValue)
{
value = lazyCompressedStringValue.UncompressedSize;
return(true);
}
var array = value as BlittableJsonReaderArray;
if (array != null)
{
value = array.Length;
return(true);
}
if (value is BlittableJsonReaderObject json)
{
value = json.Count;
return(true);
}
if (value is Array a)
{
value = a.Length;
return(true);
}
if (value is List <object> l)
{
value = l.Count;
return(true);
}
value = null;
return(false);
}
if (value is BlittableJsonReaderObject obj) // dictionary key e.g. .Where(x => x.Events.Any(y => y.Key.In(dates)))
{
var isKey = leftPath == "Key";
if (isKey || leftPath == "Value")
{
var index = 0;
var property = new BlittableJsonReaderObject.PropertyDetails();
var values = new object[obj.Count];
for (int i = 0; i < obj.Count; i++)
{
obj.GetPropertyByIndex(i, ref property);
var val = isKey ? property.Name : property.Value;
values[index++] = TypeConverter.ConvertForIndexing(val);
}
value = values;
return(true);
}
if (TryRead(blittableJsonTraverser, obj, leftPath, out value))
{
return(true);
}
}
if (value is DateTime || value is DateTimeOffset || value is TimeSpan)
{
int indexOfPropertySeparator;
do
{
indexOfPropertySeparator = leftPath.IndexOfAny(BlittableJsonTraverser.PropertySeparators, 0);
if (indexOfPropertySeparator != -1)
{
leftPath = leftPath.Subsegment(0, indexOfPropertySeparator);
}
var accessor = TypeConverter.GetPropertyAccessor(value);
value = accessor.GetValue(leftPath.Value, value);
if (value == null)
{
return(false);
}
} while (indexOfPropertySeparator != -1);
return(true);
}
if (value is string == false &&
value is IEnumerable items)
{
value = ReadNestedComputed(blittableJsonTraverser, items, leftPath);
return(true);
}
value = null;
return(false);
}
public static void GetDocIdFromInclude <TIncludeOp>(BlittableJsonReaderObject docReader, StringSegment includePath, char identityPartsSeparator, TIncludeOp op)
where TIncludeOp : struct, IIncludeOp
{
Func <object, StringSegment, char, string> valueHandler = null;
var indexOfPrefixStart = includePath.IndexOfAny(PrefixSeparatorChar, 0);
StringSegment pathSegment;
StringSegment?addition = null;
if (HasSuffixSeparator(includePath, out var indexOfSuffixStart))
{
addition = includePath.Subsegment(indexOfSuffixStart + 1);
if (addition.Value[addition.Value.Length - 1].Equals(']') == false ||
((addition.Value.Length >= 4) && (addition.Value.Subsegment(0, 3).Equals(SuffixStart) == false || addition.Value[3].Equals(identityPartsSeparator) == false)))
{
return;
}
pathSegment = includePath.Subsegment(0, indexOfSuffixStart);
valueHandler = HandleSuffixValue;
}
else if (indexOfPrefixStart != -1)
{
addition = includePath.Subsegment(indexOfPrefixStart + 1);
if (!includePath[includePath.Length - 1].Equals(')'))
{
return;
}
pathSegment = includePath.Subsegment(0, indexOfPrefixStart);
valueHandler = HandlePrefixValue;
}
else
{
pathSegment = includePath;
}
if (BlittableJsonTraverser.Default.TryRead(docReader, pathSegment, out object value, out StringSegment leftPath) == false)
{
var json = value as BlittableJsonReaderObject;
if (json != null)
{
// include on dictionary.Keys or dictionary.Values
var isKey = leftPath == "$Keys" || leftPath == "$Key";
var isValue = leftPath == "$Values" || leftPath == "$Value";
if (isKey || isValue)
{
var property = new BlittableJsonReaderObject.PropertyDetails();
for (int i = 0; i < json.Count; i++)
{
json.GetPropertyByIndex(i, ref property);
var val = isKey ? property.Name : property.Value;
if (val != null)
{
op.Include(null, val.ToString());
}
}
}
}
if (value is BlittableJsonReaderArray array)
{
foreach (var item in array)
{
if (item is BlittableJsonReaderObject inner)
{
GetDocIdFromInclude(inner, leftPath, identityPartsSeparator, op);
}
}
}
return;
}
var collectionOfIds = value as IEnumerable;
if (collectionOfIds != null && value is LazyStringValue == false)
{
foreach (var item in collectionOfIds)
{
if (item == null)
{
continue;
}
if (addition != null)
{
var includedId = valueHandler(item, addition.Value, identityPartsSeparator);
if (includedId != null)
{
op.Include(null, includedId);
}
}
op.Include(null, BlittableValueToString(item));
}
}
else
{
if (addition != null)
{
var includedId = valueHandler(value, addition.Value, identityPartsSeparator);
if (includedId != null)
{
op.Include(docReader, includedId);
}
}
op.Include(docReader, BlittableValueToString(value));
}
}
public static void GetDocIdFromInclude(BlittableJsonReaderObject docReader, StringSegment includePath,
HashSet <string> includedIds)
{
var indexOfPrefixStart = includePath.IndexOfAny(PrefixSeparatorChar, 0);
StringSegment pathSegment;
StringSegment?addition = null;
if (HasSuffixSeparator(includePath, out var indexOfSuffixStart))
{
addition = includePath.Subsegment(indexOfSuffixStart + 1);
if (!addition.Value[addition.Value.Length - 1].Equals(']') ||
((addition.Value.Length >= 4) &&
!addition.Value.Subsegment(0, 4).Equals(SuffixStart)))
{
return;
}
pathSegment = includePath.Subsegment(0, indexOfSuffixStart);
_valueHandler = HandleSuffixValue;
}
else if (indexOfPrefixStart != -1)
{
addition = includePath.Subsegment(indexOfPrefixStart + 1);
if (!includePath[includePath.Length - 1].Equals(')'))
{
return;
}
pathSegment = includePath.Subsegment(0, indexOfPrefixStart);
_valueHandler = HandlePrefixValue;
}
else
{
pathSegment = includePath;
}
if (BlittableJsonTraverser.Default.TryRead(docReader, pathSegment, out object value, out StringSegment leftPath) == false)
{
var json = value as BlittableJsonReaderObject;
if (json != null)
{
var isKey = leftPath == "$Keys"; // include on dictionary.Keys or dictionary.Values
if (isKey || leftPath == "$Values")
{
var property = new BlittableJsonReaderObject.PropertyDetails();
foreach (var propertyIndex in json.GetPropertiesByInsertionOrder())
{
json.GetPropertyByIndex(propertyIndex, ref property);
var val = isKey ? property.Name : property.Value;
if (val != null)
{
includedIds.Add(val.ToString());
}
}
}
}
return;
}
var collectionOfIds = value as IEnumerable;
if (collectionOfIds != null)
{
foreach (var item in collectionOfIds)
{
if (item == null)
{
continue;
}
if (addition != null)
{
var includedId = _valueHandler(item, addition.Value);
if (includedId != null)
{
includedIds.Add(includedId);
}
}
includedIds.Add(BlittableValueToString(item));
}
}
else
{
if (addition != null)
{
var includedId = _valueHandler(value, addition.Value);
if (includedId != null)
{
includedIds.Add(includedId);
}
}
includedIds.Add(BlittableValueToString(value));
}
}
public static List <PageFragment> ParseTemplatePage(StringSegment text)
{
var to = new List <PageFragment>();
if (text.IsNullOrWhiteSpace())
{
return(to);
}
int pos;
var lastPos = 0;
while ((pos = text.IndexOf("{{", lastPos)) != -1)
{
var block = text.Subsegment(lastPos, pos - lastPos);
to.Add(new PageStringFragment(block));
var varStartPos = pos + 2;
var varEndPos = text.IndexOfAny(VarDelimiters, varStartPos);
var varName = text.Subsegment(varStartPos, varEndPos - varStartPos).Trim();
if (varEndPos == -1)
{
throw new ArgumentException($"Invalid Server HTML Template at '{text.SafeSubsegment(50)}...'", nameof(text));
}
List <Command> filterCommands = null;
var isFilter = text.GetChar(varEndPos) == '|';
if (isFilter)
{
filterCommands = text.Subsegment(varEndPos + 1).ParseCommands(
separator: '|',
atEndIndex: (str, strPos) =>
{
while (str.Length > strPos && char.IsWhiteSpace(str.GetChar(strPos)))
{
strPos++;
}
if (str.Length > strPos + 1 && str.GetChar(strPos) == '}' && str.GetChar(strPos + 1) == '}')
{
varEndPos = varEndPos + 1 + strPos + 1;
return(strPos);
}
return(null);
});
}
else
{
varEndPos += 1;
}
lastPos = varEndPos + 1;
var originalText = text.Subsegment(pos, lastPos - pos);
to.Add(new PageVariableFragment(originalText, varName, filterCommands));
}
if (lastPos != text.Length - 1)
{
var lastBlock = lastPos == 0 ? text : text.Subsegment(lastPos);
to.Add(new PageStringFragment(lastBlock));
}
return(to);
}
public bool TryRead(BlittableJsonReaderObject docReader, StringSegment path, out object result, out StringSegment leftPath)
{
var indexOfFirstSeparator = path.IndexOfAny(_separators, 0);
object reader;
//if not found -> indexOfFirstSeparator == -1 -> take whole includePath as segment
var propertySegment = path.Subsegment(0, indexOfFirstSeparator);
if (docReader.TryGetMember(propertySegment, out reader) == false)
{
leftPath = path;
result = null;
return(false);
}
if (indexOfFirstSeparator == -1)
{
leftPath = string.Empty;// we read it all
result = reader;
return(true);
}
switch (path[indexOfFirstSeparator])
{
case PropertySeparator:
var pathSegment = path.Subsegment(indexOfFirstSeparator + 1);
var propertyInnerObject = reader as BlittableJsonReaderObject;
if (propertyInnerObject != null)
{
if (TryRead(propertyInnerObject, pathSegment, out result, out leftPath))
{
return(true);
}
if (result == null)
{
result = reader;
}
return(false);
}
leftPath = pathSegment;
result = reader;
return(false);
case CollectionSeparatorStart:
if (path.Length <= indexOfFirstSeparator + 2 ||
path[indexOfFirstSeparator + 1] != ']' ||
path[indexOfFirstSeparator + 2] != '.')
{
if (indexOfFirstSeparator + 1 < path.Length &&
path[indexOfFirstSeparator + 1] == ']')
{
if (reader is BlittableJsonReaderArray innerArray)
{
leftPath = string.Empty; // we are done with this path
result = ReadArray(innerArray, leftPath);
return(true);
}
}
result = null;
leftPath = path;
return(false);
}
leftPath = path.Subsegment(indexOfFirstSeparator + CollectionSeparator.Length);
if (reader is BlittableJsonReaderArray collectionInnerArray)
{
result = ReadArray(collectionInnerArray, leftPath);
leftPath = string.Empty; // we consume and handle internally the rest of it
return(true);
}
if (reader is BlittableJsonReaderObject nested)
{
return(ReadNestedObjects(nested, leftPath, out result, out leftPath));
}
result = reader;
return(false);
default:
throw new NotSupportedException($"Unhandled separator character: {path[indexOfFirstSeparator]}");
}
}
public int IndexOfAny() => _largeSegment.IndexOfAny(_indexOfAnyChars, 1, 7);
public static void GetDocIdFromInclude(BlittableJsonReaderObject docReader, StringSegment includePath,
HashSet <string> includedIds)
{
var indexOfPrefixStart = includePath.IndexOfAny(PrefixSeparatorChar, 0);
var indexOfSuffixStart = includePath.IndexOfAny(SuffixSeparatorChar, 0);
StringSegment pathSegment;
StringSegment?addition = null;
if (indexOfSuffixStart != -1)
{
addition = includePath.SubSegment(indexOfSuffixStart + 1);
if (!addition.Value[addition.Value.Length - 1].Equals(']') ||
((addition.Value.Length >= 4) &&
!addition.Value.SubSegment(0, 4).Equals(SuffixStart)))
{
return;
}
pathSegment = includePath.SubSegment(0, indexOfSuffixStart);
ValueHandler = HandleSuffixValue;
}
else if (indexOfPrefixStart != -1)
{
addition = includePath.SubSegment(indexOfPrefixStart + 1);
if (!includePath[includePath.Length - 1].Equals(')'))
{
return;
}
pathSegment = includePath.SubSegment(0, indexOfPrefixStart);
ValueHandler = HandlePrefixValue;
}
else
{
pathSegment = includePath;
}
object value;
StringSegment leftPath;
if (BlittableJsonTraverser.Default.TryRead(docReader, pathSegment, out value, out leftPath) == false)
{
return;
}
var collectionOfIds = value as IEnumerable;
if (collectionOfIds != null)
{
foreach (var item in collectionOfIds)
{
if (addition != null)
{
var includedId = ValueHandler(item, addition.Value);
if (includedId != null)
{
includedIds.Add(includedId);
}
}
includedIds.Add(BlittableValueToString(item));
}
}
else
{
if (addition != null)
{
var includedId = ValueHandler(value, addition.Value);
if (includedId != null)
{
includedIds.Add(includedId);
}
}
includedIds.Add(BlittableValueToString(value));
}
}