public void WriteString(LazyCompressedStringValue str)
{
var strBuffer = str.DecompressToTempBuffer(out AllocatedMemoryData allocated, _context);
try
{
var strSrcBuffer = str.Buffer;
var size = str.UncompressedSize;
var escapeSequencePos = str.CompressedSize;
var numberOfEscapeSequences = BlittableJsonReaderBase.ReadVariableSizeInt(strSrcBuffer, ref escapeSequencePos);
// We ensure our buffer will have enough space to deal with the whole string.
int bufferSize = 2 * numberOfEscapeSequences + size + 2;
if (bufferSize >= JsonOperationContext.ManagedPinnedBuffer.Size)
{
goto WriteLargeCompressedString; // OK, do it the slow way instead.
}
EnsureBuffer(bufferSize);
_buffer[_pos++] = Quote;
while (numberOfEscapeSequences > 0)
{
numberOfEscapeSequences--;
var bytesToSkip = BlittableJsonReaderBase.ReadVariableSizeInt(strSrcBuffer, ref escapeSequencePos);
WriteRawString(strBuffer, bytesToSkip);
strBuffer += bytesToSkip;
size -= bytesToSkip + 1 /*for the escaped char we skip*/;
var b = *(strBuffer++);
var auxPos = _pos;
_buffer[auxPos++] = (byte)'\\';
_buffer[auxPos++] = GetEscapeCharacter(b);
_pos = auxPos;
}
// write remaining (or full string) to the buffer in one shot
WriteRawString(strBuffer, size);
_buffer[_pos++] = Quote;
return;
WriteLargeCompressedString:
UnlikelyWriteLargeString(numberOfEscapeSequences, strSrcBuffer, escapeSequencePos, strBuffer, size);
}
finally
{
if (allocated != null) //precaution
{
_context.ReturnMemory(allocated);
}
}
}
public void Reset()
{
_unmanagedWriteBuffer.Dispose();
if (_compressionBuffer != null)
{
_context.ReturnMemory(_compressionBuffer);
_compressionBuffer = null;
}
if (_innerBuffer != null)
{
_context.ReturnMemory(_innerBuffer);
_innerBuffer = null;
}
}
public void Dispose()
{
if (_buffer != null)
{
_context.ReturnMemory(_buffer);
_buffer = null;
}
if (_compressionBuffer != null)
{
_context.ReturnMemory(_compressionBuffer);
_compressionBuffer = null;
}
_stream.Dispose();
}
public void Clear()
{
_current.Used = 0;
_sizeInBytes = 0;
// this releases everything but the current item
var prev = _current.Previous;
_current.Previous = null;
while (prev != null)
{
_context.ReturnMemory(prev.Allocation);
prev = prev.Previous;
}
}
public void Dispose()
{
// _unmanagedWriteBuffer.Dispose();
if (_compressionBuffer != null)
{
_context.ReturnMemory(_compressionBuffer);
}
_compressionBuffer = null;
if (_innerBuffer != null)
{
_context.ReturnMemory(_innerBuffer);
}
_innerBuffer = null;
}
public bool Equals(LazyCompressedStringValue other)
{
if (other.UncompressedSize != UncompressedSize)
{
return(false);
}
if (other.CompressedSize == CompressedSize)
{
return(Memory.Compare(Buffer, other.Buffer, CompressedSize) == 0);
}
AllocatedMemoryData otherAllocated = null;
AllocatedMemoryData allocated = null;
try
{
var otherTempBuffer = other.DecompressToTempBuffer(out otherAllocated);
var tempBuffer = DecompressToTempBuffer(out allocated);
return(Memory.Compare(tempBuffer, otherTempBuffer, UncompressedSize) == 0);
}
finally
{
if (otherAllocated != null)
{
other._context.ReturnMemory(otherAllocated);
}
if (allocated != null)
{
_context.ReturnMemory(allocated);
}
}
}
public void Dispose()
{
if (AllocatedMemoryData != null)
{
_context.ReturnMemory(AllocatedMemoryData);
AllocatedMemoryData = null;
}
}
public void Dispose()
{
while (_current != null)
{
_context.ReturnMemory(_current.Allocation);
_current = _current.Previous;
}
}
public void Dispose()
{
if (IsDisposed)
{
ThrowAlreadyDisposed();
}
if (AllocatedMemoryData != null)
{
_context.ReturnMemory(AllocatedMemoryData);
}
IsDisposed = true;
}
public void WriteString(LazyCompressedStringValue str)
{
AllocatedMemoryData allocated;
var strBuffer = str.DecompressToTempBuffer(out allocated);
try
{
var size = str.UncompressedSize;
EnsureBuffer(1);
_buffer[_pos++] = Quote;
var escapeSequencePos = str.CompressedSize;
var numberOfEscapeSequences = BlittableJsonReaderBase.ReadVariableSizeInt(str.Buffer, ref escapeSequencePos);
while (numberOfEscapeSequences > 0)
{
numberOfEscapeSequences--;
var bytesToSkip = BlittableJsonReaderBase.ReadVariableSizeInt(str.Buffer, ref escapeSequencePos);
WriteRawString(strBuffer, bytesToSkip);
strBuffer += bytesToSkip;
size -= bytesToSkip + 1 /*for the escaped char we skip*/;
var b = *(strBuffer++);
EnsureBuffer(2);
_buffer[_pos++] = (byte)'\\';
_buffer[_pos++] = GetEscapeCharacter(b);
}
// write remaining (or full string) to the buffer in one shot
WriteRawString(strBuffer, size);
EnsureBuffer(1);
_buffer[_pos++] = Quote;
}
finally
{
if (allocated != null) //precaution
{
_context.ReturnMemory(allocated);
}
}
}
private void ReturnAllocatedMemory()
{
if (AllocatedMemoryData == null)
{
return;
}
if (_context.Generation == AllocatedMemoryData.ContextGeneration)
{
_context.ReturnMemory(AllocatedMemoryData);
}
AllocatedMemoryData = null;
}
public void Dispose()
{
if (IsDisposed)
{
return;
}
#if MEM_GUARD
FreedBy = Environment.StackTrace;
#endif
// The actual lifetime of the _head Segment is unbounded: it will
// be released by the GC when we no longer have any references to
// it (i.e. no more copies of this struct)
//
// We can, however, force the deallocation of all the previous
// Segments by ensuring we don't keep any references after the
// Dispose is run.
var head = _head;
_head = null; // Further references are NREs.
for (Segment next; head != null; head = next)
{
_context.ReturnMemory(head.Allocation);
// This is used to signal that Dispose has run to other copies
head.Address = null;
#if DEBUG
// Helps to avoid program errors, albeit unnecessary
head.Allocation = null;
head.AccumulatedSizeInBytes = -1;
head.Used = -1;
#endif
// `next` is used to keep a reference to the previous Segment.
// Since `next` lives only within this for loop and we clear up
// all other references, non-head Segments should be GC'd.
next = head.DeallocationPendingPrevious;
head.Previous = null;
head.DeallocationPendingPrevious = null;
}
}
public void Dispose()
{
#if MEM_GUARD
if (FreedBy == null) //if already disposed, keep the "FreedBy"
{
FreedBy = Environment.StackTrace;
}
#endif
var start = _current;
while (_current != null &&
_current.Address != null) //prevent double dispose
{
_context.ReturnMemory(_current.Allocation);
_current.Address = null; //precaution, to make memory issues more visible
_current = _current.PreviousAllocated;
}
GC.KeepAlive(start);
}