private void WriteAddedAndChangedReferences(ExtendedBinaryWriter writer)
{
List <SyncSource> changedSyncSourceObjects = _dirtySyncSourceObjects.ToList();
var changedAndNewReferenceUnion = new HashSet <SyncSource>(_addedSyncSourceObjects);
// Merge the new references and the added ones
// Because it is possible for references to be both added and changed as wel
changedAndNewReferenceUnion.UnionWith(changedSyncSourceObjects);
int referenceCount = changedAndNewReferenceUnion.Count;
writer.Write7BitEncodedInt(referenceCount);
foreach (SyncSource syncSourceObject in changedAndNewReferenceUnion)
{
writer.Write7BitEncodedInt(syncSourceObject.ReferenceId);
if (_addedSyncSourceObjects.Contains(syncSourceObject))
{
Settings.TypeEncoder.WriteType(syncSourceObject.BaseObject.GetType(), writer);
syncSourceObject.WriteFull(writer);
}
else
{
syncSourceObject.WriteChanges(writer);
}
}
}
private void WriteRemovedReferences(ExtendedBinaryWriter writer)
{
writer.Write7BitEncodedInt(_removedSyncSourceObjects.Count);
foreach (SyncSource removedSyncSourceObject in _removedSyncSourceObjects)
{
writer.Write7BitEncodedInt(removedSyncSourceObject.ReferenceId);
}
}
private void WriteUntrackedReferences(ExtendedBinaryWriter writer)
{
lock (_pendingUntrackedSyncSourceObjects)
{
writer.Write7BitEncodedInt(_pendingUntrackedSyncSourceObjects.Count);
foreach (SourceSynchronizer syncSource in _pendingUntrackedSyncSourceObjects)
{
writer.Write7BitEncodedInt(syncSource.ReferenceId);
}
}
}
/// <summary>
/// Converts type into a compact integer array which can be decoded using <see cref="ReadType" />
/// </summary>
/// <returns></returns>
public void WriteType(Type type, ExtendedBinaryWriter writer)
{
var output = new Queue <int>();
EncodeTypeRecursive(output, type);
writer.Write7BitEncodedInt(output.Count);
foreach (int identifier in output)
{
writer.Write7BitEncodedInt(identifier);
}
}
public void Write(ExtendedBinaryWriter writer, IFieldSerializer keySerializer,
IFieldSerializer valueSerializer)
{
writer.Write((byte)_action);
switch (_action)
{
case NotifyCollectionChangedAction.Add:
keySerializer.Serialize(_items[0].Key, writer);
valueSerializer.Serialize(_items[0].Value, writer);
break;
case NotifyCollectionChangedAction.Replace:
keySerializer.Serialize(_items[0].Key, writer);
valueSerializer.Serialize(_items[0].Value, writer);
break;
case NotifyCollectionChangedAction.Remove:
keySerializer.Serialize(_items[0].Key, writer);
break;
case NotifyCollectionChangedAction.Reset:
{
writer.Write7BitEncodedInt(_items.Count);
foreach (KeyValuePair <TKey, TValue> item in _items)
{
keySerializer.Serialize(item.Key, writer);
valueSerializer.Serialize(item.Value, writer);
}
break;
}
}
}
public void Write(ExtendedBinaryWriter writer, ISerializer keySerializer)
{
writer.Write((byte)_action);
switch (_action)
{
case NotifyCollectionChangedAction.Add:
keySerializer.Write(_items[0], writer);
break;
case NotifyCollectionChangedAction.Replace:
keySerializer.Write(_items[0], writer);
break;
case NotifyCollectionChangedAction.Remove:
keySerializer.Write(_items[0], writer);
break;
case NotifyCollectionChangedAction.Reset:
{
writer.Write7BitEncodedInt(_items.Count);
foreach (TKey item in _items)
{
keySerializer.Write(item, writer);
}
break;
}
}
}
public void WriteAddedTypes(ExtendedBinaryWriter writer)
{
writer.Write7BitEncodedInt(_addedCustomTypes.Count);
foreach (var type in _addedCustomTypes)
{
writer.Write(type.AssemblyQualifiedName);
}
}
/// <summary>
/// Foreach connection, pad with connection synchronizationTick.
/// </summary>
/// <param name="synchronizationTick"></param>
/// <returns></returns>
public byte[] SetTick(int synchronizationTick)
{
using var memoryStream = new MemoryStream();
using var writer = new ExtendedBinaryWriter(memoryStream);
writer.Write7BitEncodedInt(synchronizationTick);
writer.Write(_synchronizationPacket);
return(memoryStream.ToArray());
}
public override void WriteFull(ExtendedBinaryWriter binaryWriter)
{
const int commandCount = 1;
binaryWriter.Write7BitEncodedInt(commandCount);
Command resetCommand = Command.FromReset(BaseObject.ToList());
resetCommand.Write(binaryWriter, _keySerializer, _valueSerializer);
}
public override void Write(ExtendedBinaryWriter writer, object value)
{
var collection = (IList)value;
writer.Write7BitEncodedInt(collection.Count);
for (var i = 0; i < collection.Count; i++)
{
UnderlyingType.Write(writer, collection[i]);
}
}
public override void WriteFull(ExtendedBinaryWriter binaryWriter)
{
const int commandCount = 1;
binaryWriter.Write7BitEncodedInt(commandCount);
Command resetCommand = Command.FromReset(Reference.ToList());
resetCommand.Write(binaryWriter, _keySerializer, _valueSerializer);
_commandsInvalidated = false;
}
internal byte[] WriteFull()
{
using var memoryStream = new MemoryStream();
using var writer = new ExtendedBinaryWriter(memoryStream);
// Write remove reference count 0
writer.Write7BitEncodedInt(0);
List <SyncSource> syncSourceObjects = _referencePool.SyncObjects.ToList();
writer.Write7BitEncodedInt(syncSourceObjects.Count);
foreach (SyncSource syncSourceObject in syncSourceObjects)
{
writer.Write7BitEncodedInt(syncSourceObject.ReferenceId);
Settings.TypeEncoder.WriteType(syncSourceObject.BaseObject.GetType(), writer);
syncSourceObject.WriteFull(writer);
}
return(new SynchronizationPacket(memoryStream.ToArray()).SetTick(0));
}
public override void WriteFull(ExtendedBinaryWriter binaryWriter)
{
var arrayRanks = Reference.GetType().GetArrayRank();
var lengths = new int[arrayRanks];
binaryWriter.Write7BitEncodedInt(arrayRanks);
for (int rank = 0; rank < arrayRanks; rank++)
{
int length = Reference.GetLength(rank);
lengths[rank] = length;
binaryWriter.Write7BitEncodedInt(length);
}
int[] zIndex = new int[arrayRanks];
void TraverseArray(int depth)
{
int length = lengths[depth];
if (depth + 1 < arrayRanks)
{
for (int i = 0; i < length; i++)
{
zIndex[depth] = i;
TraverseArray(depth + 1);
}
}
else
{
for (int i = 0; i < length; i++)
{
zIndex[depth] = i;
_elementSerializer.Write(Reference.GetValue(zIndex), binaryWriter);
}
}
}
TraverseArray(0);
}
/// <summary>
/// Writes all of the nodes contained in this list to the underlying stream, prefixed
/// by the number of elements encoded using LEB128 encoding.
/// </summary>
/// <param name="writer">Writer used for writing to the underlying stream.</param>
public override void WriteValue(ExtendedBinaryWriter writer)
{
writer.Write7BitEncodedInt(_list.Count);
foreach (var node in _list)
{
if (node == null)
{
writer.Write((byte)BsfType.Null);
}
else
{
node.WriteType(writer);
node.WriteValue(writer);
}
}
}
public override void WriteChanges(ExtendedBinaryWriter binaryWriter)
{
// A full reset if the underlying dictionary is cleared
if (_commandsInvalidated)
{
WriteFull(binaryWriter);
}
else
{
binaryWriter.Write7BitEncodedInt(_commands.Count);
foreach (Command command in _commands)
{
command.Write(binaryWriter, _keySerializer);
}
_commands.Clear();
}
}
public int GetTextDictionaryKey(string text)
{
if (text == null)
{
return(0);
}
lock (_textDictionary)
{
if (!_textDictionary.TryGetValue(text, out var key))
{
key = _textDictionary.Count + 1;
_textDictionary.Add(text, key);
if (_currentDictionaryWriter == null)
{
_currentDictionaryWriter = new ExtendedBinaryWriter(new MemoryStream(), Encoding.UTF8);
}
_currentDictionaryWriter.Write((byte)DiagnosticsEventKind.TextDictionaryKeyAdded);
var eventDataLengthPos = (int)_currentDictionaryWriter.BaseStream.Position;
_currentDictionaryWriter.Write(0);
var startPos = (int)_currentDictionaryWriter.BaseStream.Position;
_currentDictionaryWriter.Write7BitEncodedInt(key);
_currentDictionaryWriter.WriteNullable(text);
var endPos = (int)_currentDictionaryWriter.BaseStream.Position;
_currentDictionaryWriter.Seek(eventDataLengthPos, SeekOrigin.Begin);
_currentDictionaryWriter.Write(endPos - startPos);
_currentDictionaryWriter.Seek(endPos, SeekOrigin.Begin);
}
return(key);
}
}
public void Write(object value, ExtendedBinaryWriter writer)
{
var referenceIdentifier = _identifierResolver.ResolveIdentifier(value);
writer.Write7BitEncodedInt(referenceIdentifier);
}
public void Serialize(object value, ExtendedBinaryWriter writer)
{
int referenceIdentifier = _referenceResolver.ResolveIdentifier(value);
writer.Write7BitEncodedInt(referenceIdentifier);
}
