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)); }