public BlittableJsonReaderObject ReadObjectWithExternalProperties(DynamicJsonValue obj, string debugTag)
{
var state = new JsonParserState();
using (var parser = new ObjectJsonParser(state, obj, this))
{
var writer = new BlittableJsonDocumentBuilder(this, BlittableJsonDocumentBuilder.UsageMode.None, debugTag, parser, state);
try
{
writer.ReadObject();
if (writer.Read() == false)
{
throw new InvalidOperationException("Partial json content in object json parser shouldn't happen");
}
writer.FinalizeDocumentWithoutProperties(CachedProperties.Version);
_disposables.Add(writer);
return(writer.CreateReader(CachedProperties));
}
catch (Exception)
{
writer.Dispose();
throw;
}
}
}
private BlittableJsonReaderObject ReadObjectInternal(object builder, string documentId, BlittableJsonDocumentBuilder.UsageMode mode)
{
var state = new JsonParserState();
using (var parser = new ObjectJsonParser(state, builder, this))
{
var writer = new BlittableJsonDocumentBuilder(this, mode, documentId, parser, state);
try
{
CachedProperties.NewDocument();
writer.ReadObject();
if (writer.Read() == false)
{
throw new InvalidOperationException("Partial content in object json parser shouldn't happen");
}
writer.FinalizeDocument();
_disposables.Add(writer);
return(writer.CreateReader());
}
catch (Exception)
{
writer.Dispose();
throw;
}
}
}
public virtual void Dispose()
{
if (_disposed)
{
return;
}
Reset();
_objectJsonParser.Dispose();
_documentBuilder.Dispose();
_arenaAllocator.Dispose();
_arenaAllocatorForLongLivedValues?.Dispose();
if (_managedBuffers != null)
{
foreach (var managedPinnedBuffer in _managedBuffers)
{
managedPinnedBuffer.Dispose();
}
_managedBuffers = null;
}
if (_pinnedObjects != null)
{
foreach (var pinnedObject in _pinnedObjects)
{
pinnedObject.Free();
}
}
_disposed = true;
}
public void Dispose()
{
Disposed = true;
Reset(true);
_documentBuilder.Dispose();
}
public JsonOperationContext(int initialSize, int longLivedSize, SharedMultipleUseFlag lowMemoryFlag)
{
Debug.Assert(lowMemoryFlag != null);
_disposeOnceRunner = new DisposeOnce <ExceptionRetry>(() =>
{
#if MEM_GUARD_STACK
ElectricFencedMemory.DecrementConext();
ElectricFencedMemory.UnRegisterContextAllocation(this);
#endif
Reset(true);
_documentBuilder.Dispose();
_arenaAllocator.Dispose();
_arenaAllocatorForLongLivedValues?.Dispose();
if (_managedBuffers != null)
{
foreach (var managedPinnedBuffer in _managedBuffers)
{
managedPinnedBuffer.Dispose();
}
_managedBuffers = null;
}
if (_pinnedObjects != null)
{
foreach (var pinnedObject in _pinnedObjects)
{
pinnedObject.Free();
}
_pinnedObjects = 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
}
private void DisposeIfNeeded(int generation, UnmanagedJsonParser parser, BlittableJsonDocumentBuilder builder)
{
// if the generation has changed, that means that we had reset the context
// this can happen if we were waiting on an async call for a while, got timed out / error / something
// and the context was reset before we got back from the async call
// since the full context was reset, there is no point in trying to dispose things, they were already
// taken care of
if (generation == _generation)
{
parser?.Dispose();
builder?.Dispose();
}
}
public override void Dispose()
{
if (_disposed)
{
return;
}
lock (this)
{
if (_disposed)
{
return;
}
#if MEM_GUARD_STACK
ElectricFencedMemory.DecrementConext();
ElectricFencedMemory.UnRegisterContextAllocation(this);
#endif
Reset(true);
_documentBuilder.Dispose();
_arenaAllocator.Dispose();
_arenaAllocatorForLongLivedValues?.Dispose();
if (_managedBuffers != null)
{
foreach (var managedPinnedBuffer in _managedBuffers)
{
managedPinnedBuffer.Dispose();
}
_managedBuffers = null;
}
if (_pinnedObjects != null)
{
foreach (var pinnedObject in _pinnedObjects)
{
pinnedObject.Free();
}
}
_disposed = true;
}
}
private async Task <BlittableJsonReaderObject> ParseToMemoryAsync(Stream stream, string documentId, BlittableJsonDocumentBuilder.UsageMode mode)
{
_jsonParserState.Reset();
ManagedPinnedBuffer bytes;
using (GetManagedBuffer(out bytes))
using (var parser = new UnmanagedJsonParser(this, _jsonParserState, documentId))
{
var writer = new BlittableJsonDocumentBuilder(this, mode, documentId, parser, _jsonParserState);
try
{
CachedProperties.NewDocument();
writer.ReadObjectDocument();
while (true)
{
var read = await stream.ReadAsync(bytes.Buffer.Array, bytes.Buffer.Offset, bytes.Length);
if (read == 0)
{
throw new EndOfStreamException("Stream ended without reaching end of json content");
}
parser.SetBuffer(bytes, read);
if (writer.Read())
{
break;
}
}
writer.FinalizeDocument();
var reader = writer.CreateReader();
RegisterLiveReader(reader);
return(reader);
}
catch (Exception)
{
writer.Dispose();
throw;
}
}
}
public async Task <BlittableJsonReaderArray> ParseArrayToMemoryAsync(Stream stream, string debugTag,
BlittableJsonDocumentBuilder.UsageMode mode)
{
_jsonParserState.Reset();
ManagedPinnedBuffer bytes;
using (GetManagedBuffer(out bytes))
using (var parser = new UnmanagedJsonParser(this, _jsonParserState, debugTag))
{
var writer = new BlittableJsonDocumentBuilder(this, mode, debugTag, parser, _jsonParserState);
try
{
CachedProperties.NewDocument();
writer.ReadArrayDocument();
while (true)
{
var read = await stream.ReadAsync(bytes.Buffer.Array, bytes.Buffer.Offset, bytes.Length);
if (read == 0)
{
throw new EndOfStreamException("Stream ended without reaching end of json content");
}
parser.SetBuffer(bytes, read);
if (writer.Read())
{
break;
}
}
writer.FinalizeDocument();
// here we "leak" the memory used by the array, in practice this is used
// in short scoped context, so we don't care
return(writer.CreateArrayReader());
}
catch (Exception)
{
writer.Dispose();
throw;
}
}
}
public async Task <BlittableJsonReaderObject> ReadFromWebSocket(
WebSocket webSocket,
string debugTag,
CancellationToken cancellationToken)
{
_jsonParserState.Reset();
ManagedPinnedBuffer bytes;
using (var parser = new UnmanagedJsonParser(this, _jsonParserState, debugTag))
using (GetManagedBuffer(out bytes))
{
var writer = new BlittableJsonDocumentBuilder(this,
BlittableJsonDocumentBuilder.UsageMode.None, debugTag, parser, _jsonParserState);
try
{
writer.ReadObjectDocument();
var result = await webSocket.ReceiveAsync(bytes.Buffer, cancellationToken);
if (result.MessageType == WebSocketMessageType.Close)
{
return(null);
}
parser.SetBuffer(bytes, result.Count);
while (writer.Read() == false)
{
result = await webSocket.ReceiveAsync(bytes.Buffer, cancellationToken);
parser.SetBuffer(bytes, result.Count);
}
writer.FinalizeDocument();
return(writer.CreateReader());
}
catch (Exception)
{
writer.Dispose();
throw;
}
}
}
public async Task <BlittableJsonReaderObject> ParseAsync(BlittableJsonDocumentBuilder.UsageMode mode, string debugTag)
{
var writer = new BlittableJsonDocumentBuilder(_context, mode, debugTag, _parser, _state);
try
{
writer.ReadObject();
_context.CachedProperties.NewDocument();
while (true)
{
if (_parser.BufferOffset == _parser.BufferSize)
{
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);
}
else
{
_parser.SetBuffer(new ArraySegment <byte>(_buffer, _parser.BufferOffset, _parser.BufferSize));
}
if (writer.Read())
{
break;
}
}
writer.FinalizeDocument();
return(writer.CreateReader());
}
catch (Exception)
{
writer.Dispose();
throw;
}
}
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;
}
}
}
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> ReadFromWebSocket(
WebSocket webSocket,
string debugTag,
CancellationToken cancellationToken)
{
if (_disposed)
{
ThrowObjectDisposed();
}
_jsonParserState.Reset();
UnmanagedJsonParser parser = null;
BlittableJsonDocumentBuilder builder = null;
var managedBuffer = default(ReturnBuffer);
var generation = _generation;
try
{
parser = new UnmanagedJsonParser(this, _jsonParserState, debugTag);
builder = new BlittableJsonDocumentBuilder(this,
BlittableJsonDocumentBuilder.UsageMode.None, debugTag, parser, _jsonParserState);
managedBuffer = GetManagedBuffer(out var bytes);
try
{
builder.ReadObjectDocument();
var result = await webSocket.ReceiveAsync(bytes.Buffer, cancellationToken);
EnsureNotDisposed();
if (result.MessageType == WebSocketMessageType.Close)
{
return(null);
}
bytes.Valid = result.Count;
bytes.Used = 0;
parser.SetBuffer(bytes);
while (true)
{
var read = builder.Read();
bytes.Used += parser.BufferOffset;
if (read)
{
break;
}
result = await webSocket.ReceiveAsync(bytes.Buffer, cancellationToken);
bytes.Valid = result.Count;
bytes.Used = 0;
parser.SetBuffer(bytes);
}
builder.FinalizeDocument();
return(builder.CreateReader());
}
catch (Exception)
{
builder.Dispose();
throw;
}
}
finally
{
DisposeIfNeeded(generation, parser, builder);
if (generation == _generation)
{
managedBuffer.Dispose();
}
}
}
public void Dispose()
{
_builder?.Dispose();
}
public void Dispose()
{
_returnManagedBuffer.Dispose();
_parser?.Dispose();
_writer?.Dispose();
}
