private int CreateOutboundMessage(Span <byte> payload) { var writer = new SpanWriter <byte>(payload); writer.WriteUInt16(myPort, true); writer.WriteInt64(currentTerm, true); writer.WriteInt64(lastLogIndex, true); writer.WriteInt64(lastLogTerm, true); return(writer.WrittenCount); }
public static int CreateWorldItem(Span <byte> buffer, Item item) { var itemID = item is BaseMulti ? item.ItemID | 0x4000 : item.ItemID & 0x3FFF; var hasAmount = item.Amount != 0; var amount = item.Amount; var serial = hasAmount ? item.Serial | 0x80000000 : item.Serial & 0x7FFFFFFF; var loc = item.Location; var hue = item.Hue; var flags = item.GetPacketFlags(); var direction = (int)item.Direction; var hasDirection = direction != 0; var hasHue = hue != 0; var hasFlags = flags != 0; var x = hasDirection ? loc.X | 0x8000 : loc.X & 0x7FFF; var y = (loc.Y & 0x3FFF) | (hasHue ? 0x8000 : 0) | (hasFlags ? 0x4000 : 0); var length = 14 + (hasAmount ? 2 : 0) + (hasDirection ? 1 : 0) + (hasHue ? 2 : 0) + (hasFlags ? 1 : 0); var writer = new SpanWriter(buffer); writer.Write((byte)0x1A); // Packet ID writer.Write((ushort)length); writer.Write(serial); writer.Write((ushort)itemID); if (amount != 0) { writer.Write((ushort)amount); } writer.Write((ushort)x); writer.Write((ushort)y); if (direction != 0) { writer.Write((byte)direction); } writer.Write((sbyte)loc.Z); if (hue != 0) { writer.Write((ushort)hue); } if (flags != 0) { writer.Write((byte)flags); } return(writer.Position); }
private int CreateOutboundMessage(Span <byte> payload) { var writer = new SpanWriter <byte>(payload); WriteUInt16LittleEndian(writer.Slide(sizeof(ushort)), myPort); WriteInt64LittleEndian(writer.Slide(sizeof(long)), currentTerm); WriteInt64LittleEndian(writer.Slide(sizeof(long)), lastLogIndex); WriteInt64LittleEndian(writer.Slide(sizeof(long)), lastLogTerm); return(writer.WrittenCount); }
/// <summary> /// Fills up the block's type, and entry count. /// </summary> public override void FinalizeHeader() { var blockWriter = new SpanWriter(Buffer); blockWriter.Position = LastPosition; // Write up the block info - write what we can write - the entry count blockWriter.Position = 0; blockWriter.WriteUInt16((ushort)Type); blockWriter.WriteUInt16((ushort)((EntryCount * 2) + 1)); }
ReadOnlySpan <byte> ValueToByteArray(TValue value, ref SpanWriter writer) { IWriterCtx ctx = null; if (_valueHandler.NeedsCtx()) { ctx = new DBWriterCtx(_tr); } _valueWriter(value, ref writer, ctx); return(writer.GetPersistentSpanAndReset()); }
internal ReadOnlySpan <byte> EncodeBatch(KeyValuePair <byte[], ResultCacheEntry>[] operations) { if (operations.Length == 0) { throw new ArgumentException("Zero size batch", nameof(operations)); } long maxSize = 0; maxSize += 8; // sequence maxSize += 4 * operations.Length; // count foreach (var entry in operations) { maxSize += 1; // op code maxSize += 10; // varint max maxSize += entry.Key.Length; if (entry.Value.ResultState == ResultState.Exist) { maxSize += 10; // varint max maxSize += entry.Value.Data?.Length ?? 0; } } Span <byte> data = new byte[maxSize]; // big enough to contain all data regardless of size var writer = new SpanWriter(data); // write sequence writer.Write(operations.First().Value.Sequence); // write operations count writer.Write((int)operations.Length); foreach (var operation in operations) { var key = operation.Key; var entry = operation.Value; // write op type (byte) writer.Write(entry.ResultState == ResultState.Exist ? (byte)OperationType.Put : (byte)OperationType.Delete); // write key len (varint) writer.WriteVarInt((ulong)key.Length); // write key writer.Write(key); if (entry.ResultState == ResultState.Exist) { // write data len (varint) writer.WriteVarInt((ulong)entry.Data.Length); // write data writer.Write(entry.Data); } } return(data.Slice(0, writer.Position)); }
void StartNewHashIndexFile() { _hashIndexFile = _fileCollection.AddFile("hid"); _hashIndexWriter = _hashIndexFile.GetExclusiveAppenderWriter(); var fileInfo = new HashKeyIndex(_subDBId, _fileCollection.NextGeneration(), _fileCollection.Guid, (uint)_keyLen); var writer = new SpanWriter(_hashIndexWriter); fileInfo.WriteHeader(ref writer); writer.Sync(); _fileCollection.SetInfo(_hashIndexFile.Index, fileInfo); }
public const int MobileMovingPacketCacheLength = MobileMovingPacketLength * 8 * 2; // 8 notoriety, 2 client versions public static void CreateBondedStatus(Span <byte> buffer, Serial serial, bool bonded) { var writer = new SpanWriter(buffer); writer.Write((byte)0xBF); // Packet ID writer.Write((ushort)11); // Length writer.Write((ushort)0x19); // Subpacket ID writer.Write((byte)0); // Command writer.Write(serial); writer.Write(bonded); }
private int WriteAnnouncement(Span <byte> output) { var writer = new SpanWriter <byte>(output); writer.WriteUInt16(myPort, true); writer.WriteInt64(term, true); writer.WriteInt64(snapshotIndex, true); LogEntryMetadata.Create(snapshot).Serialize(ref writer); return(writer.WrittenCount); }
static Utf8String s_emptyHeaders = (Utf8String)"\n\n\n\n\n\n\n\n\n\n\nx-ms-date:"; // this wont be needed once we have UTF8 literals public static bool TryWrite(Span <byte> output, Sha256 hash, string verb, string canonicalizedResource, DateTime utc, out int bytesWritten) { try { var writer = new SpanWriter(output); writer.WriteLine(verb); writer.Write("\n\n\n\n\n\n\n\n\n\n\nx-ms-date:"); writer.WriteLine(utc, 'R'); writer.Write(canonicalizedResource); hash.Append(writer.Written); writer.Index = 0; writer.WriteBytes(hash, default, Base64Experimental.BytesToUtf8Encoder);
public void Marshal(Span <byte> span, int protocolVersion) { var writer = new SpanWriter(span); // DoL writes byte 0x00 and then region ID as a byte // but region is represented elsewhere as a ushort writer.WriteUInt16BigEndian(_region.Id); writer.Skip(20); writer.WriteFixedString(_region.Port.ToString(), 5); writer.WriteFixedString(_region.Port.ToString(), 5); // yeah, twice writer.WriteFixedString(_region.Address.ToString(), 20); }
public void Writable() { Span <IBufferTransformation> transformations = s_transformations; Span <byte> buffer = stackalloc byte[256]; var writer = new SpanWriter(buffer); var ulonger = new UInt128(); ulonger.Lower = ulong.MaxValue; ulonger.Upper = 1; writer.WriteBytes(ulonger, default, transformations.Slice(3));
void StartNewPureValueFile() { _pureValueFile = _fileCollection.AddFile("hpv"); _pureValueFileWriter = _pureValueFile.GetAppenderWriter(); var fileInfo = new FilePureValuesWithId(_subDBId, _fileCollection.NextGeneration(), _fileCollection.Guid); var writer = new SpanWriter(_pureValueFileWriter); fileInfo.WriteHeader(ref writer); writer.Sync(); _pureValueFile.Flush(); _fileCollection.SetInfo(_pureValueFile.Index, fileInfo); }
public static void CreateSoundEffect(ref Span <byte> buffer, int soundID, IPoint3D target) { var writer = new SpanWriter(buffer); writer.Write((byte)0x54); // Packet ID writer.Write((byte)1); // flags writer.Write((short)soundID); writer.Write((short)0); // volume writer.Write((short)target.X); writer.Write((short)target.Y); writer.Write((short)target.Z); }
public static void CreateRemoveHairPacket(Span <byte> buffer, Serial hairSerial) { if (buffer[0] != 0) { return; } var writer = new SpanWriter(buffer); writer.Write((byte)0x1D); // Packet ID writer.Write(hairSerial); }
ReadOnlySpan <byte> ValueToByteArray(TValue value) { var writer = new SpanWriter(); IWriterCtx ctx = null; if (_valueHandler.NeedsCtx()) { ctx = new DBWriterCtx(_tr); } _valueWriter(value, ref writer, ctx); return(writer.GetSpan()); }
public void Write(ref SpanWriter w) { w.Write(Oggs); w.Write(StreamVersion); w.Write((byte)TypeFlag); w.Write(GranulePosition); w.Write(Serial); w.Write(PageNumber); w.Write(Checksum); w.Write(TotalSegments); w.Write(SegmentTable); }
public ListFieldHandler(IFieldHandlerFactory fieldHandlerFactory, ITypeConvertorGenerator typeConvertGenerator, Type type) { _fieldHandlerFactory = fieldHandlerFactory; _typeConvertGenerator = typeConvertGenerator; _type = type; _isSet = type.InheritsOrImplements(typeof(ISet <>)); _itemsHandler = _fieldHandlerFactory.CreateFromType(type.GetGenericArguments()[0], FieldHandlerOptions.None); var writer = new SpanWriter(); writer.WriteFieldHandler(_itemsHandler); Configuration = writer.GetSpan().ToArray(); }
ReadOnlySpan <byte> KeyToByteArray(TKey key, ref SpanWriter writer) { writer.WriteBlock(_prefix); IWriterCtx ctx = null; if (_keyHandler.NeedsCtx()) { ctx = new DBWriterCtx(_tr); } _keyWriter(key, ref writer, ctx); return(writer.GetPersistentSpanAndReset()); }
internal static void WriteHeader(ref SpanWriter writer, Guid?guid) { if (guid.HasValue) { writer.WriteByteArrayRaw(MagicStartOfFileWithGuid); writer.WriteGuid(guid.Value); } else { writer.WriteByteArrayRaw(MagicStartOfFile); } }
void PreserveJustMostOftenUsed(uint fileId) { var frequencies = new List <uint>(); foreach (var itemPair in _cache) { if (itemPair.Value.FileId == fileId) { frequencies.Add(itemPair.Value.AccessRate); } } var preserveRate = frequencies.OrderByDescending(r => r).Skip(frequencies.Count / 5).FirstOrDefault(); foreach (var itemPair in _cache) { if (itemPair.Value.FileId == fileId) { if (preserveRate < itemPair.Value.AccessRate) { var cacheValue = itemPair.Value; var content = new byte[cacheValue.ContentLength]; _fileCollection.GetFile(cacheValue.FileId).RandomRead(content.AsSpan(0, (int)cacheValue.ContentLength), cacheValue.FileOfs, true); var writer = _cacheValueWriter; if (writer == null) { goto remove; } lock (writer) { if (writer != _cacheValueWriter) { goto remove; } if (writer.GetCurrentPositionWithoutWriter() + cacheValue.ContentLength > _sizeLimitOfOneValueFile) { goto remove; } cacheValue.FileId = _cacheValueFileId; cacheValue.FileOfs = (uint)writer.GetCurrentPositionWithoutWriter(); var trueWriter = new SpanWriter(writer); trueWriter.WriteBlock(content); trueWriter.Sync(); } _cache.TryUpdate(itemPair.Key, cacheValue, itemPair.Value); continue; } remove: _cache.TryRemove(itemPair.Key); } } }
public ODBSetFieldHandler(IObjectDB odb, Type type, IFieldHandlerFactory fieldHandlerFactory) { _odb = odb; _typeConvertGenerator = odb.TypeConvertorGenerator; _type = type; _keysHandler = fieldHandlerFactory.CreateFromType(type.GetGenericArguments()[0], FieldHandlerOptions.Orderable | FieldHandlerOptions.AtEndOfStream); var writer = new SpanWriter(); writer.WriteFieldHandler(_keysHandler); _configuration = writer.GetSpan().ToArray(); CreateConfiguration(); }
ReadOnlySpan <byte> KeyToByteArray(TKey key) { var writer = new SpanWriter(); IWriterCtx ctx = null; if (_keyHandler.NeedsCtx()) { ctx = new DBWriterCtx(_tr); } writer.WriteBlock(_prefix); _keyWriter(key, ref writer, ctx); return(writer.GetSpan()); }
public static void CreateOPLInfo(Span <byte> buffer, Serial serial, int hash) { if (buffer[0] != 0) { return; } var writer = new SpanWriter(buffer); writer.Write((byte)0xDC); // Packet ID writer.Write(serial); writer.Write(hash); }
private int WriteAnnouncement(Span <byte> output) { var writer = new SpanWriter <byte>(output); writer.WriteUInt16(myPort, true); writer.WriteInt64(term, true); writer.WriteInt64(snapshotIndex, true); writer.WriteInt64(snapshot.Length.GetValueOrDefault(-1), true); writer.WriteInt64(snapshot.Term, true); writer.Write(snapshot.Timestamp); return(writer.WrittenCount); }
void CanSerializeSimpleValue(object value) { var writer = new SpanWriter(); var storedDescriptorCtx = _mapping.StoreNewDescriptors(value); storedDescriptorCtx.FinishNewDescriptors(ref writer); storedDescriptorCtx.StoreObject(ref writer, value); storedDescriptorCtx.CommitNewDescriptors(); var reader = new SpanReader(writer.GetSpan()); var obj = _mapping.LoadObject(ref reader); Assert.Equal(value, obj); }
public void CanSerializeInt() { var writer = new SpanWriter(); var storedDescriptorCtx = _mapping.StoreNewDescriptors(12345); storedDescriptorCtx.FinishNewDescriptors(ref writer); storedDescriptorCtx.StoreObject(ref writer, 12345); storedDescriptorCtx.CommitNewDescriptors(); var reader = new SpanReader(writer.GetSpan()); var obj = _mapping.LoadObject(ref reader); Assert.Equal(12345, obj); }
public override void AppendTo(ref SpanWriter writer, OrderedHashSet <string> strings, ref int entries, ref int switches) { var hasHue = Hue != 0; var hasClass = !string.IsNullOrEmpty(Class); writer.WriteAscii( hasHue switch { true when hasClass => $"{{ gumppic {X} {Y} {GumpID} hue={Hue} class={Class} }}", true => $"{{ gumppic {X} {Y} {GumpID} hue={Hue} }}", false when hasClass => $"{{ gumppic {X} {Y} {GumpID} class={Class} }}", false => $"{{ gumppic {X} {Y} {GumpID} }}", }
private protected int WriteAnnouncement(Span <byte> output, int entriesCount) { var writer = new SpanWriter <byte>(output); writer.WriteUInt16(myPort, true); writer.WriteInt64(term, true); writer.WriteInt64(prevLogIndex, true); writer.WriteInt64(prevLogTerm, true); writer.WriteInt64(commitIndex, true); writer.WriteInt32(entriesCount, true); return(writer.WrittenCount); }
private int WriteAnnouncement(Span <byte> output) { var writer = new SpanWriter <byte>(output); WriteUInt16LittleEndian(writer.Slide(sizeof(ushort)), myPort); WriteInt64LittleEndian(writer.Slide(sizeof(long)), term); WriteInt64LittleEndian(writer.Slide(sizeof(long)), snapshotIndex); WriteInt64LittleEndian(writer.Slide(sizeof(long)), snapshot.Length.GetValueOrDefault(-1)); WriteInt64LittleEndian(writer.Slide(sizeof(long)), snapshot.Term); writer.Write(snapshot.Timestamp); return(writer.WrittenCount); }