public static T DeserializeSegment <TTypeResolver, T>(ArraySegment <byte> originalBytes, int index, int lastIndex, DirtyTracker tracker)
where TTypeResolver : ITypeResolver, new()
{
var offset = ObjectSegmentHelper.GetOffset(originalBytes, index, lastIndex, tracker);
if (offset == -1)
{
return(default(T));
}
int size;
var array = originalBytes.Array;
return(Formatter <TTypeResolver, T> .Default.Deserialize(ref array, offset, tracker, out size));
}
public static int SerializeFixedLength <TTypeResolver, T>(ref byte[] targetBytes, int startOffset, int offset, int index, int lastIndex, ArraySegment <byte> originalBytes, byte[] extraBytes, DirtyTracker tracker)
where TTypeResolver : ITypeResolver, new()
{
BinaryUtil.WriteInt32(ref targetBytes, startOffset + (8 + 4 * index), offset - startOffset);
var formatter = global::ZeroFormatter.Formatters.Formatter <TTypeResolver, T> .Default;
var len = formatter.GetLength();
BinaryUtil.EnsureCapacity(ref targetBytes, offset, len.Value);
var readOffset = GetOffset(originalBytes, index, lastIndex, tracker);
if (readOffset != -1)
{
Buffer.BlockCopy(originalBytes.Array, readOffset, targetBytes, offset, len.Value);
}
else
{
var extraOffset = GetExtraBytesOffset(extraBytes, lastIndex, index);
Buffer.BlockCopy(extraBytes, extraOffset, targetBytes, offset, len.Value);
}
return(len.Value);
}
public static int GetOffset(ArraySegment <byte> originalBytes, int index, int lastIndex, DirtyTracker tracker)
{
if (index > lastIndex)
{
return(-1);
}
var array = originalBytes.Array;
var readOffset = BinaryUtil.ReadInt32(ref array, originalBytes.Offset + 8 + 4 * index);
if (readOffset == 0)
{
return(-1);
}
return(originalBytes.Offset + readOffset);
}
public static ArraySegment <byte> GetSegment(ArraySegment <byte> originalBytes, int index, int lastIndex, DirtyTracker tracker)
{
var offset = GetOffset(originalBytes, index, lastIndex, tracker);
if (offset == -1)
{
return(default(ArraySegment <byte>)); // note:very very dangerous.
}
var sliceLength = originalBytes.Offset + originalBytes.Count;
return(new ArraySegment <byte>(originalBytes.Array, offset, (sliceLength - offset)));
}
public static void SetFixedProperty <TTypeResolver, T>(ArraySegment <byte> bytes, int index, int lastIndex, byte[] extraBytes, T value, DirtyTracker tracker)
where TTypeResolver : ITypeResolver, new()
{
if (index <= lastIndex)
{
var array = bytes.Array;
Formatter <TTypeResolver, T> .Default.Serialize(ref array, ObjectSegmentHelper.GetOffset(bytes, index, lastIndex, tracker), value);
}
else
{
// from extraBytes
var offset = GetExtraBytesOffset(extraBytes, lastIndex, index);
Formatter <TTypeResolver, T> .Default.Serialize(ref extraBytes, offset, value);
}
}
public static LookupSegment <TKey, TElement> Create(DirtyTracker tracker, byte[] bytes, int offset, LookupSegmentMode mode, out int byteSize)
{
tracker = tracker.CreateChild();
var byteSizeOrCount = BinaryUtil.ReadInt32(ref bytes, offset);
if (byteSizeOrCount == -1)
{
byteSize = 4;
return(null);
}
var segment = new LookupSegment <TKey, TElement>();
if (mode == LookupSegmentMode.LazyAll)
{
byteSize = byteSizeOrCount;
segment.count = BinaryUtil.ReadInt32(ref bytes, offset + 4);
var formatter = Formatter <IList <IList <GroupingSegment <TKey, TElement> > > > .Default;
int _;
segment.groupings = formatter.Deserialize(ref bytes, offset + 8, tracker, out _);
segment.tracker = tracker;
segment.originalBytes = new ArraySegment <byte>(bytes, offset, byteSize);
segment.mode = LookupSegmentMode.LazyAll;
return(segment);
}
else
{
var originalOffset = offset;
var keyFormatter = Formatter <TKey> .Default;
var valuesFormatter = Formatter <IList <TElement> > .Default;
segment.tracker = tracker;
segment.groupings = new List <IList <GroupingSegment <TKey, TElement> > >(byteSizeOrCount);
for (int i = 0; i < byteSizeOrCount; i++)
{
segment.groupings.Add(null); // null clear
}
int size = 0;
byteSize = 4;
offset += 4;
for (int i = 0; i < byteSizeOrCount; i++)
{
var key = keyFormatter.Deserialize(ref bytes, offset, tracker, out size);
byteSize += size;
offset += size;
var values = valuesFormatter.Deserialize(ref bytes, offset, tracker, out size);
byteSize += size;
offset += size;
var group = segment.GetGrouping(key, true);
foreach (var item in values)
{
group.Add(item);
}
}
segment.originalBytes = new ArraySegment <byte>(bytes, originalOffset, byteSize);
segment.mode = LookupSegmentMode.Immediate;
return(segment);
}
}
public static T GetFixedProperty <T>(ArraySegment <byte> bytes, int index, int lastIndex, byte[] extraBytes, DirtyTracker tracker)
{
if (index <= lastIndex)
{
var array = bytes.Array;
int _;
return(Formatter <T> .Default.Deserialize(ref array, ObjectSegmentHelper.GetOffset(bytes, index, lastIndex, tracker), tracker, out _));
}
else
{
// from extraBytes
var offset = GetExtraBytesOffset(extraBytes, lastIndex, index);
int _;
return(Formatter <T> .Default.Deserialize(ref extraBytes, offset, tracker, out _));
}
}
// deserialize immediate:)
public static DictionaryEntry <TTypeResolver, TKey, TValue> Create <TTypeResolver, TKey, TValue>(byte[] bytes, int offset, DirtyTracker tracker, out int byteSize)
where TTypeResolver : ITypeResolver, new()
{
byteSize = 0;
var hashCode = BinaryUtil.ReadInt32(ref bytes, offset);
offset += 4;
byteSize += 4;
var next = BinaryUtil.ReadInt32(ref bytes, offset);
offset += 4;
byteSize += 4;
int size;
var key = Formatter <TTypeResolver, TKey> .Default.Deserialize(ref bytes, offset, tracker, out size);
offset += size;
byteSize += size;
var value = Formatter <TTypeResolver, TValue> .Default.Deserialize(ref bytes, offset, tracker, out size);
byteSize += size;
return(new DictionaryEntry <TTypeResolver, TKey, TValue>(hashCode, next, key, value));
}
public static ArraySegment <byte> GetSegment(ArraySegment <byte> originalBytes, int index, int nextIndex, int lastIndex, DirtyTracker tracker)
{
var offset = GetOffset(originalBytes, index, lastIndex, tracker);
if (offset == -1)
{
return(default(ArraySegment <byte>)); // note:very very dangerous.
}
int count;
if (nextIndex == -1 || nextIndex > lastIndex)
{
count = originalBytes.Offset + originalBytes.Count - offset; // last index
}
else
{
var nextOffset = ObjectSegmentHelper.GetOffset(originalBytes, nextIndex, lastIndex, tracker);
if (nextOffset == -1)
{
return(default(ArraySegment <byte>)); // note: precondition failed.
}
count = nextOffset - offset;
}
return(new ArraySegment <byte>(originalBytes.Array, offset, count));
}
