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