private unsafe DateTime ReadDateTime(JsonParserState jsonParserState, IJsonParser reader, State state)
{
var str = CreateLazyStringValueFromParserState(jsonParserState);
var result = LazyStringParser.TryParseDateTime(str.Buffer, str.Size, out DateTime dt, out DateTimeOffset _);
if (result != LazyStringParser.Result.DateTime)
{
ThrowInvalidLastModifiedProperty(state, str, reader);
}
return(dt);
}
public JsonOperationContext(int initialSize, int longLivedSize)
{
_initialSize = initialSize;
_longLivedSize = longLivedSize;
_arenaAllocator = new ArenaMemoryAllocator(initialSize);
_arenaAllocatorForLongLivedValues = new ArenaMemoryAllocator(longLivedSize);
Encoding = new UTF8Encoding();
CachedProperties = new CachedProperties(this);
_jsonParserState = new JsonParserState();
_objectJsonParser = new ObjectJsonParser(_jsonParserState, this);
_documentBuilder = new BlittableJsonDocumentBuilder(this, _jsonParserState, _objectJsonParser);
}
public bool AboutToReadPropertyName(IJsonParser reader, JsonParserState state)
{
if (reader is UnmanagedJsonParser)
{
return(AboutToReadPropertyNameInternal((UnmanagedJsonParser)reader, state));
}
if (reader is ObjectJsonParser)
{
return(AboutToReadPropertyNameInternal((ObjectJsonParser)reader, state));
}
return(AboutToReadPropertyNameInternal(reader, state));
}
public async Task InitializeAsync()
{
AssertNotSync();
try
{
_initialized = true;
_state = new JsonParserState();
_parser = new UnmanagedJsonParser(_session.Context, _state, "stream contents");
_returnBuffer = _session.Context.GetManagedBuffer(out _buffer);
if (await UnmanagedJsonParserHelper.ReadAsync(_peepingTomStream, _parser, _state, _buffer).ConfigureAwait(false) == false)
{
UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream);
}
if (_state.CurrentTokenType != JsonParserToken.StartObject)
{
UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream);
}
if (_isQueryStream)
{
HandleStreamQueryStats(_session.Context, _response, _parser, _state, _buffer, _streamQueryStatistics);
}
var property = UnmanagedJsonParserHelper.ReadString(_session.Context, _peepingTomStream, _parser, _state, _buffer);
if (string.Equals(property, "Results") == false)
{
UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream);
}
if (await UnmanagedJsonParserHelper.ReadAsync(_peepingTomStream, _parser, _state, _buffer).ConfigureAwait(false) == false)
{
UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream);
}
if (_state.CurrentTokenType != JsonParserToken.StartArray)
{
UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream);
}
}
catch
{
Dispose();
throw;
}
}
public unsafe void Valid_String()
{
using (var ctx = JsonOperationContext.ShortTermSingleUse())
{
var state = new JsonParserState();
using (var parser = new UnmanagedJsonParser(ctx, state, "test"))
{
var temp = new Str
{
str = "\nabcdefghijklmnopqrstuvwxyz" +
"abcdefghijklmnopqrstuvwxyz" +
"abcdefghijklmnopqrstuvwxyz" +
"abcdefghijklmnopqrstuvwxyz" +
"abcdefghijklmnopqrstuvwxyz" +
"abcdefghijklmnopqrstuvwxyz" +
"abcdefghijklmnopqrstuvwxyz" +
"abcdefghijklmnopqrstuvwxyz" +
"abcdefghijklmnopqrstuvwxyz" +
"abcdefghijklmnopqrstuvwxyz" +
"abcdefghijklmnopqrstuvwxyz" +
"abcdefghijklmnopqrstuvwxyz" +
"abcdefghijklmnopqrstuvwxyz" +
"abcdefghijklmnopqrstuvwxyz" +
"abcdefghijklmnopqrstuvwxyz" +
"abcdefghijklmnopqrstuvwxyz" +
"abcdefghijklmnopqrstuvwxyz" +
"abcdefghijklmnopqrstuvwxyz" +
"abcdefghijklmnopqrstuvwxyz\n"
};
var obj = RavenJObject.FromObject(temp);
var objString = obj.ToString(Formatting.None);
var buffer = Encoding.UTF8.GetBytes(objString);
fixed(byte *pBuffer = buffer)
{
parser.SetBuffer(pBuffer, buffer.Length);
var writer = new BlittableJsonDocumentBuilder(ctx,
BlittableJsonDocumentBuilder.UsageMode.None,
"test", parser, state);
writer.ReadObjectDocument();
var x = writer.Read();
writer.FinalizeDocument();
var reader = writer.CreateReader();
reader.BlittableValidation();
}
}
}
}
public unsafe void Valid_object_read_from_non_zero_offset()
{
using (var context = JsonOperationContext.ShortTermSingleUse())
{
var jsonParserState = new JsonParserState();
using (var parser = new UnmanagedJsonParser(context, jsonParserState, "changes/1"))
{
byte[] buffer = new byte[4096];
var bufferOffset = 128; //non-zero offset
var allTokens = new AllTokensTypes
{
Bool = true,
Float = 123.4567F,
Int = 45679123,
IntArray = new[] { 1, 2, 3 },
Null = null,
Object = new Empty(),
String = "qwertyuio"
};
var obj = JObject.FromObject(allTokens);
var objString = obj.ToString(Formatting.None);
var data = Encoding.UTF8.GetBytes(objString);
data.CopyTo(buffer, bufferOffset);
fixed(byte *pBuffer = buffer)
{
using (var builder = new BlittableJsonDocumentBuilder(context, BlittableJsonDocumentBuilder.UsageMode.None, "order/1", parser, jsonParserState))
{
parser.SetBuffer(pBuffer + bufferOffset, data.Length);
builder.ReadObjectDocument();
Assert.True(builder.Read());
builder.FinalizeDocument();
using (var reader = builder.CreateReader())
{
var value = reader.ToString();
Assert.NotNull(value);
}
}
}
}
}
}
private unsafe void WriteValue(BlittableJsonTextWriter writer, JsonParserState state, ObjectJsonParser parser)
{
switch (state.CurrentTokenType)
{
case JsonParserToken.Null:
writer.WriteNull();
break;
case JsonParserToken.False:
writer.WriteBool(false);
break;
case JsonParserToken.True:
writer.WriteBool(true);
break;
case JsonParserToken.String:
if (state.CompressedSize.HasValue)
{
var lazyCompressedStringValue = new LazyCompressedStringValue(null, state.StringBuffer,
state.StringSize, state.CompressedSize.Value, this);
writer.WriteString(lazyCompressedStringValue);
}
else
{
writer.WriteString(AllocateStringValue(null, state.StringBuffer, state.StringSize));
}
break;
case JsonParserToken.Float:
writer.WriteDouble(new LazyNumberValue(AllocateStringValue(null, state.StringBuffer, state.StringSize)));
break;
case JsonParserToken.Integer:
writer.WriteInteger(state.Long);
break;
case JsonParserToken.StartObject:
WriteObject(writer, state, parser);
break;
case JsonParserToken.StartArray:
WriteArray(writer, state, parser);
break;
default:
throw new ArgumentOutOfRangeException("Could not understand " + state.CurrentTokenType);
}
}
public override void SetResponseRaw(HttpResponseMessage response, Stream stream, JsonOperationContext context)
{
var state = new JsonParserState();
using (var parser = new UnmanagedJsonParser(context, state, "multi_get/response"))
using (context.GetMemoryBuffer(out JsonOperationContext.MemoryBuffer buffer))
using (var peepingTomStream = new PeepingTomStream(stream, context))
{
if (UnmanagedJsonParserHelper.Read(peepingTomStream, parser, state, buffer) == false)
{
ThrowInvalidJsonResponse(peepingTomStream);
}
if (state.CurrentTokenType != JsonParserToken.StartObject)
{
ThrowInvalidJsonResponse(peepingTomStream);
}
var property = UnmanagedJsonParserHelper.ReadString(context, peepingTomStream, parser, state, buffer);
if (property != nameof(BlittableArrayResult.Results))
{
ThrowInvalidJsonResponse(peepingTomStream);
}
var i = 0;
Result = new List <GetResponse>();
foreach (var getResponse in ReadResponses(context, peepingTomStream, parser, state, buffer))
{
var command = _commands[i];
MaybeSetCache(getResponse, command);
MaybeReadFromCache(getResponse, command, context);
Result.Add(getResponse);
i++;
}
if (UnmanagedJsonParserHelper.Read(peepingTomStream, parser, state, buffer) == false)
{
ThrowInvalidJsonResponse(peepingTomStream);
}
if (state.CurrentTokenType != JsonParserToken.EndObject)
{
ThrowInvalidJsonResponse(peepingTomStream);
}
}
}
public BlittableJsonDocumentBuilder(JsonOperationContext context, JsonParserState state, IJsonParser reader,
BlittableWriter <UnmanagedWriteBuffer> writer = null,
IBlittableDocumentModifier modifier = null)
{
_context = context;
_state = state;
_reader = reader;
_modifier = modifier;
_writer = writer ?? new BlittableWriter <UnmanagedWriteBuffer>(context);
_cacheItem = GlobalCache.Allocate();
_propertiesCache = _cacheItem.PropertyCache;
_positionsCache = _cacheItem.PositionsCache;
_tokensCache = _cacheItem.TokensCache;
}
private DocumentFlags ReadFlags(JsonParserState state)
{
var split = CreateLazyStringValueFromParserState(state).Split(',');
var flags = DocumentFlags.None;
for (var i = 0; i < split.Length; i++)
{
if (Enum.TryParse(split[i], true, out DocumentFlags flag) == false)
{
continue;
}
flags |= flag;
}
return(flags);
}
private static unsafe BlittableJsonReaderObject ParseJsonAllAtOnce(string s, JsonOperationContext ctx)
{
var jsonParserState = new JsonParserState();
var parser = new UnmanagedJsonParser(ctx, jsonParserState, "test");
var builder = new BlittableJsonDocumentBuilder(ctx, BlittableJsonDocumentBuilder.UsageMode.ToDisk, "test", parser, jsonParserState);
builder.ReadObjectDocument();
var value = ctx.GetLazyString(s);
parser.SetBuffer(value.Buffer, value.Size);
Assert.True(builder.Read());
builder.FinalizeDocument();
var reader = builder.CreateReader();
return(reader);
}
/// <summary>
/// Parses a token right after a JSON key token was parsed.
/// </summary>
/// <param name="token">the token to parse</param>
/// <exception cref="JsonParserException">in case parsing fails</exception>
private void ParseInObjectKeyState(JsonToken token)
{
EnsureTokenIsNotNull(token, UNTERMINATED_JSON_OBJECT_ERROR);
switch (token.TokenType)
{
case JsonTokenType.COLON:
state = JsonParserState.IN_OBJECT_COLON;
break;
default:
state = JsonParserState.ERROR;
throw new JsonParserException(UnexpectedTokenErrorMessage(token,
"encountered - key-value delimiter expected"));
}
}
/// <summary>
/// Helper method to remove the top level JSON value from the value stack and also the state.
/// </summary>
/// <exception cref="JsonParserException">in case of an exception</exception>
private void CloseCompositeJsonValueAndRestoreState()
{
EnsureValueContainerStackIsNotEmpty();
if (valueContainerStack.Count != stateStack.Count + 1)
{
throw new JsonParserException(InternalParserErrorMessage(state,
"valueContainerStack and stateStack size mismatch"));
}
if (valueContainerStack.Count == 1)
{
// the outermost array is terminated, do not remove anything from the stack
state = JsonParserState.END;
return;
}
var currentValue = valueContainerStack.First.Value.JsonValue;
valueContainerStack.RemoveFirst();
// ensure that there is a new top level element which is a composite value (object or array)
EnsureValueContainerStackIsNotEmpty();
var topLevelElement = valueContainerStack.First.Value;
if (topLevelElement.JsonValue.ValueType == JsonValueType.ARRAY)
{
if (topLevelElement.BackingList == null)
{
// precaution to ensure we did not do something wrong
throw new JsonParserException(InternalParserErrorMessage(state, "backing list is null"));
}
topLevelElement.BackingList.Add(currentValue);
}
else if (topLevelElement.JsonValue.ValueType == JsonValueType.OBJECT)
{
topLevelElement.LastParsedObjectValue = currentValue;
}
else
{
throw new JsonParserException(InternalParserErrorMessage(state, "not a composite top level object"));
}
state = stateStack.First.Value;
stateStack.RemoveFirst();
}
public override async Task <ResponseDisposeHandling> ProcessResponse(JsonOperationContext context, HttpCache cache, HttpResponseMessage response, string url)
{
var state = new JsonParserState();
Stream stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
using (context.GetMemoryBuffer(out var buffer))
using (var parser = new UnmanagedJsonParser(context, state, "attachments/receive"))
using (var builder = new BlittableJsonDocumentBuilder(context, BlittableJsonDocumentBuilder.UsageMode.None, "attachments/list", parser, state))
using (var peepingTomStream = new PeepingTomStream(stream, context))
{
if (await UnmanagedJsonParserHelper.ReadAsync(peepingTomStream, parser, state, buffer).ConfigureAwait(false) == false)
{
throw new Exception("cannot parse stream");
}
if (state.CurrentTokenType != JsonParserToken.StartObject)
{
throw new Exception($"Expected token {nameof(JsonParserToken.StartObject)}, but got {nameof(state.CurrentTokenType)}.");
}
await UnmanagedJsonParserHelper.ReadObjectAsync(builder, peepingTomStream, parser, buffer).ConfigureAwait(false);
using (var data = builder.CreateReader())
{
if (data.TryGetMember(nameof(AttachmentsMetadata), out object obj) && obj is BlittableJsonReaderArray bjra)
{
foreach (BlittableJsonReaderObject e in bjra)
{
var cur = JsonDeserializationClient.AttachmentDetails(e);
AttachmentsMetadata.Add(cur);
}
}
}
var bufferSize = parser.BufferSize - parser.BufferOffset;
var copy = ArrayPool <byte> .Shared.Rent(bufferSize);
var copyMemory = new Memory <byte>(copy);
buffer.Memory.Memory.Slice(parser.BufferOffset, bufferSize).CopyTo(copyMemory);
Result = Iterate(stream, copy, bufferSize).GetEnumerator();
}
return(ResponseDisposeHandling.Manually);
}
/// <summary>
/// Parses a token right after a delimiter has been parsed.
/// <para>
/// Note for now: not supported yet.
/// </para>
/// </summary>
/// <param name="token">the token to parse</param>
/// <exception cref="JsonParserException">in case parsing fails.</exception>
private void ParseInObjectDelimiterState(JsonToken token)
{
EnsureTokenIsNotNull(token, UNTERMINATED_JSON_OBJECT_ERROR);
EnsureTopLevelElementIsAJsonObject();
switch (token.TokenType)
{
case JsonTokenType.VALUE_STRING:
valueContainerStack.First.Value.LastParsedObjectKey = token.Value;
state = JsonParserState.IN_OBJECT_KEY;
break;
default:
state = JsonParserState.ERROR;
throw new JsonParserException(UnexpectedTokenErrorMessage(token,
"encountered - object key expected"));
}
}
public unsafe void WriteObject(BlittableJsonTextWriter writer, JsonParserState state, ObjectJsonParser parser)
{
if (state.CurrentTokenType != JsonParserToken.StartObject)
{
throw new InvalidOperationException("StartObject expected, but got " + state.CurrentTokenType);
}
writer.WriteStartObject();
bool first = true;
while (true)
{
if (parser.Read() == false)
{
throw new InvalidOperationException("Object json parser can't return partial results");
}
if (state.CurrentTokenType == JsonParserToken.EndObject)
{
break;
}
if (state.CurrentTokenType != JsonParserToken.String)
{
throw new InvalidOperationException("Property expected, but got " + state.CurrentTokenType);
}
if (first == false)
{
writer.WriteComma();
}
first = false;
var lazyStringValue = AllocateStringValue(null, state.StringBuffer, state.StringSize);
writer.WritePropertyName(lazyStringValue);
if (parser.Read() == false)
{
throw new InvalidOperationException("Object json parser can't return partial results");
}
WriteValue(writer, state, parser);
}
writer.WriteEndObject();
}
public unsafe int WriteValue(string str, out BlittableJsonToken token, UsageMode mode = UsageMode.None)
{
if (_intBuffer == null)
{
_intBuffer = new List <int>();
}
int size = Encoding.UTF8.GetMaxByteCount(str.Length);
FillBufferWithEscapePositions(str, _intBuffer);
size += JsonParserState.GetEscapePositionsSize(_intBuffer);
var buffer = _context.GetNativeTempBuffer(size);
fixed(char *pChars = str)
{
var stringSize = Utf8Encoding.GetBytes(pChars, str.Length, buffer, size);
return(WriteValue(buffer, stringSize, _intBuffer, out token, mode, null));
}
}
private unsafe LazyStringValue CreateLazyStringValueFromParserState(JsonParserState state)
{
int escapePositionsCount = state.EscapePositions.Count;
var maxSizeOfEscapePos = escapePositionsCount * 5 // max size of var int
+ JsonParserState.VariableSizeIntSize(escapePositionsCount);
var mem = _ctx.GetMemory(maxSizeOfEscapePos + state.StringSize);
_allocations.Add(mem);
Memory.Copy(mem.Address, state.StringBuffer, state.StringSize);
var lazyStringValueFromParserState = _ctx.AllocateStringValue(null, mem.Address, state.StringSize);
if (escapePositionsCount > 0)
{
lazyStringValueFromParserState.EscapePositions = state.EscapePositions.ToArray();
}
return(lazyStringValueFromParserState);
}
public void FailsOnInvalidJson(string invalidJson)
{
using (var ctx = JsonOperationContext.ShortTermSingleUse())
{
var buffer = Encoding.UTF8.GetBytes(invalidJson);
var state = new JsonParserState();
fixed(byte *pBuffer = buffer)
{
using (var parser = new UnmanagedJsonParser(ctx, state, "test"))
{
parser.SetBuffer(pBuffer, buffer.Length);
var writer = new BlittableJsonDocumentBuilder(ctx, BlittableJsonDocumentBuilder.UsageMode.ToDisk, "test", parser, state);
writer.ReadObjectDocument();
Assert.Throws <InvalidDataException>(() => writer.Read());
}
}
}
}
public JsonOperationContext(int initialSize, int longLivedSize, SharedMultipleUseFlag lowMemoryFlag)
{
Debug.Assert(lowMemoryFlag != null);
_initialSize = initialSize;
_longLivedSize = longLivedSize;
_arenaAllocator = new ArenaMemoryAllocator(lowMemoryFlag, initialSize);
_arenaAllocatorForLongLivedValues = new ArenaMemoryAllocator(lowMemoryFlag, longLivedSize);
CachedProperties = new CachedProperties(this);
_jsonParserState = new JsonParserState();
_objectJsonParser = new ObjectJsonParser(_jsonParserState, this);
_documentBuilder = new BlittableJsonDocumentBuilder(this, _jsonParserState, _objectJsonParser);
LowMemoryFlag = lowMemoryFlag;
#if MEM_GUARD_STACK
ElectricFencedMemory.IncrementConext();
ElectricFencedMemory.RegisterContextAllocation(this, Environment.StackTrace);
#endif
}
/// <summary>
/// Parses a token in an array and an array value has already been parsed previously.
/// </summary>
/// <param name="token"></param>
/// <exception cref="JsonParserException"></exception>
private void ParseInArrayValueState(JsonToken token)
{
EnsureTokenIsNotNull(token, UNTERMINATED_JSON_ARRAY_ERROR);
switch (token.TokenType)
{
case JsonTokenType.COMMA:
state = JsonParserState.IN_ARRAY_DELIMITER;
break;
case JsonTokenType.RIGHT_SQUARE_BRACKET:
CloseCompositeJsonValueAndRestoreState();
break;
default:
state = JsonParserState.ERROR;
throw new JsonParserException(UnexpectedTokenErrorMessage(token,
"in array after value has been parsed"));
}
}
private static unsafe ForceRevisionStrategy GetEnumValue(JsonParserState state, JsonOperationContext ctx)
{
switch (state.StringSize)
{
case 6:
if (*(int *)state.StringBuffer == 1868981570 &&
*(short *)(state.StringBuffer + sizeof(int)) == 25970)
{
return(ForceRevisionStrategy.Before);
}
ThrowInvalidProperty(state, ctx);
break;
default:
ThrowInvalidProperty(state, ctx);
break;
}
return(0);
}
public async Task InitializeAsync()
{
AssertNotSync();
try
{
_initialized = true;
_state = new JsonParserState();
_parser = new UnmanagedJsonParser(_session.Context, _state, "stream contents");
_builder = new BlittableJsonDocumentBuilder(_builderContext, BlittableJsonDocumentBuilder.UsageMode.ToDisk, "readArray/singleResult", _parser, _state);
_returnBuffer = _session.Context.GetMemoryBuffer(out _buffer);
if (await UnmanagedJsonParserHelper.ReadAsync(_peepingTomStream, _parser, _state, _buffer, _token).ConfigureAwait(false) == false)
UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream);
if (_state.CurrentTokenType != JsonParserToken.StartObject)
UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream);
if (_isQueryStream)
HandleStreamQueryStats(_builderContext, _response, _parser, _state, _buffer, _streamQueryStatistics);
var property = UnmanagedJsonParserHelper.ReadString(_builderContext, _peepingTomStream, _parser, _state, _buffer);
if (string.Equals(property, "Results") == false)
UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream);
if (await UnmanagedJsonParserHelper.ReadAsync(_peepingTomStream, _parser, _state, _buffer, _token).ConfigureAwait(false) == false)
UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream);
if (_state.CurrentTokenType != JsonParserToken.StartArray)
UnmanagedJsonParserHelper.ThrowInvalidJson(_peepingTomStream);
}
catch
{
await DisposeAsync().ConfigureAwait(false);
throw;
}
}
/// <summary>
/// Parses a token right after a JSON key-value delimiter (":") was parsed.
/// </summary>
/// <param name="token">the token to parse.</param>
/// <exception cref="JsonParserException">in case parsing fails</exception>
private void ParseInObjectColonState(JsonToken token)
{
EnsureTokenIsNotNull(token, UNTERMINATED_JSON_OBJECT_ERROR);
EnsureTopLevelElementIsAJsonObject();
switch (token.TokenType)
{
case JsonTokenType.VALUE_NUMBER: // fallthrough
case JsonTokenType.VALUE_STRING: // fallthrough
case JsonTokenType.LITERAL_BOOLEAN: // fallthrough
case JsonTokenType.LITERAL_NULL: // fallthrough
// simple JSON value as object value
valueContainerStack.First.Value.LastParsedObjectValue = TokenToSimpleJsonValue(token);
state = JsonParserState.IN_OBJECT_VALUE;
break;
case JsonTokenType.LEFT_BRACE:
// value is an object
var jsonObjectDict = new Dictionary <string, JsonValue>();
valueContainerStack.AddFirst(new JsonValueContainer(JsonObjectValue.FromDictionary(jsonObjectDict),
jsonObjectDict));
stateStack.AddFirst(JsonParserState.IN_OBJECT_VALUE);
state = JsonParserState.IN_OBJECT_START;
break;
case JsonTokenType.LEFT_SQUARE_BRACKET:
// value is an array
var jsonValueList = new LinkedList <JsonValue>();
valueContainerStack.AddFirst(new JsonValueContainer(JsonArrayValue.FromList(jsonValueList),
jsonValueList));
stateStack.AddFirst(JsonParserState.IN_OBJECT_VALUE);
state = JsonParserState.IN_ARRAY_START;
break;
default:
// any other token
throw new JsonParserException(
UnexpectedTokenErrorMessage(token, "after key-value pair encountered"));
}
}
// TODO: When we hit CoreCLR 2.0 see if we can devirtualize this code with some generics shenanigans
private unsafe bool AboutToReadPropertyNameInternal(IJsonParser reader, JsonParserState state)
{
if (_state != State.None)
{
if (!AboutToReadWithStateUnlikely(reader, state))
{
return(false);
}
}
_state = State.None;
while (true)
{
if (reader.Read() == false)
{
return(false);
}
if (state.CurrentTokenType != JsonParserToken.String)
{
return(true); // let the caller handle that
}
if (_readingMetadataObject == false)
{
if (state.StringSize == 9 && state.StringBuffer[0] == (byte)'@' && *(long *)(state.StringBuffer + 1) == 7022344802737087853)
{
_readingMetadataObject = true;
}
return(true);
}
if (AboutToReadPropertyNameInMetadataUnlikely(reader, state, out bool aboutToReadPropertyName))
{
return(aboutToReadPropertyName);
}
}
}
private void SetStringBuffer(string str)
{
// max possible size - we avoid using GetByteCount because profiling showed it to take 2% of runtime
// the buffer might be a bit longer, but we'll reuse it, and it is better than the computing cost
int escapePositionsSize = JsonParserState.FindEscapePositionsMaxSize(str, out _);
int byteCount = str.Length * 5 + escapePositionsSize;
if (_currentStateBuffer == null || _currentStateBuffer.SizeInBytes < byteCount)
{
byteCount = Encodings.Utf8.GetMaxByteCount(str.Length);
// If we do not have a buffer or the buffer is too small, return the memory and get more.
var size = byteCount + escapePositionsSize;
if (_currentStateBuffer == null || _currentStateBuffer.SizeInBytes < size)
{
if (_currentStateBuffer != null)
{
_ctx.ReturnMemory(_currentStateBuffer);
}
_currentStateBuffer = _ctx.GetMemory(size);
Debug.Assert(_currentStateBuffer != null && _currentStateBuffer.Address != null);
}
}
_state.StringBuffer = _currentStateBuffer.Address;
fixed(char *pChars = str)
{
_state.StringSize = Encodings.Utf8.GetBytes(pChars, str.Length, _state.StringBuffer, _currentStateBuffer.SizeInBytes);
_state.CompressedSize = null; // don't even try
_state.FindEscapePositionsIn(_state.StringBuffer, ref _state.StringSize, escapePositionsSize);
var escapePos = _state.StringBuffer + _state.StringSize;
_state.WriteEscapePositionsTo(escapePos);
}
}
public async Task <BlittableJsonReaderArray> ParseArrayToMemoryAsync(Stream stream, string debugTag,
BlittableJsonDocumentBuilder.UsageMode mode)
{
var state = new JsonParserState();
var buffer = GetParsingBuffer();
using (var parser = new UnmanagedJsonParser(this, state, debugTag))
{
var writer = new BlittableJsonDocumentBuilder(this, mode, debugTag, parser, state);
try
{
CachedProperties.NewDocument();
writer.ReadArray();
while (true)
{
var read = await stream.ReadAsync(buffer, 0, buffer.Length);
if (read == 0)
{
throw new EndOfStreamException("Stream ended without reaching end of json content");
}
parser.SetBuffer(buffer, read);
if (writer.Read())
{
break;
}
}
writer.FinalizeDocument();
_disposables.Add(writer);
return(writer.CreateArrayReader());
}
catch (Exception)
{
writer.Dispose();
throw;
}
}
}
/// <summary>
/// Parse a token right after a JSON object has ben started.
/// </summary>
/// <param name="token">the token to parse</param>
/// <exception cref="JsonParserException">in case parsing fails</exception>
private void ParseInObjectStartState(JsonToken token)
{
EnsureTokenIsNotNull(token, UNTERMINATED_JSON_OBJECT_ERROR);
EnsureTopLevelElementIsAJsonObject();
switch (token.TokenType)
{
case JsonTokenType.RIGHT_BRACE:
// object is closed right after it was started
CloseCompositeJsonValueAndRestoreState();
break;
case JsonTokenType.VALUE_STRING:
valueContainerStack.First.Value.LastParsedObjectKey = token.Value;
state = JsonParserState.IN_OBJECT_KEY;
break;
default:
state = JsonParserState.ERROR;
throw new JsonParserException(UnexpectedTokenErrorMessage(token,
"encountered - object key expected"));
}
}
private BlittableJsonReaderObject ParseToMemory(Stream stream, string debugTag, BlittableJsonDocumentBuilder.UsageMode mode)
{
var state = new JsonParserState();
var buffer = GetParsingBuffer();
using (var parser = new UnmanagedJsonParser(this, state, debugTag))
{
var builder = new BlittableJsonDocumentBuilder(this, mode, debugTag, parser, state);
try
{
CachedProperties.NewDocument();
builder.ReadObject();
while (true)
{
var read = stream.Read(buffer, 0, buffer.Length);
if (read == 0)
{
throw new EndOfStreamException("Stream ended without reaching end of json content");
}
parser.SetBuffer(buffer, read);
if (builder.Read())
{
break;
}
}
builder.FinalizeDocument();
_disposables.Add(builder);
return(builder.CreateReader());
}
catch (Exception)
{
builder.Dispose();
throw;
}
}
}
public async Task <BlittableJsonReaderObject> TryReadFromWebSocket(
JsonOperationContext context,
RavenClientWebSocket webSocket,
string debugTag,
CancellationToken cancellationToken)
{
var jsonParserState = new JsonParserState();
JsonOperationContext.ManagedPinnedBuffer bytes;
using (context.GetManagedBuffer(out bytes))
using (var parser = new UnmanagedJsonParser(context, jsonParserState, debugTag))
{
var writer = new BlittableJsonDocumentBuilder(context,
BlittableJsonDocumentBuilder.UsageMode.None, debugTag, parser, jsonParserState);
writer.ReadObjectDocument();
var result = await webSocket.ReceiveAsync(bytes.Buffer, cancellationToken).ConfigureAwait(false);
parser.SetBuffer(bytes, result.Count);
while (writer.Read() == false)
{
// we got incomplete json response.
// This might happen if we close the connection but still server sends something
if (result.CloseStatus != null)
{
return(null);
}
result = await webSocket.ReceiveAsync(bytes.Buffer, cancellationToken).ConfigureAwait(false);
parser.SetBuffer(bytes, result.Count);
}
writer.FinalizeDocument();
return(writer.CreateReader());
}
}
