public override void Write(IRowOutputInterface output, IntLookup lookup)
{
output.WriteInt(base.IBalance);
WriteTranslatePointer(this._iLeft, output, lookup);
WriteTranslatePointer(this._iRight, output, lookup);
WriteTranslatePointer(this._iParent, output, lookup);
}
public override void Write(IRowOutputInterface output, IntLookup lookup)
{
output.WriteSize(this.storageSize);
for (NodeAVL eavl = base.NPrimaryNode; eavl != null; eavl = eavl.nNext)
{
((NodeAVLDisk)eavl).Write(output, lookup);
}
output.WriteData(base.RowData, base.table.ColTypes);
output.WriteEnd();
}
private void InitMessageTypesDictionary()
{
var messageTypes = _messageTypes.ToArray();
var messageTypePointers = messageTypes.Select(t => t.TypeHandle.Value.ToInt64()).ToArray();
// -1 to ensure that when a diff is applied it's still positive
_messageTypePointerDiff = messageTypePointers.Min() - 1;
var keys = messageTypePointers.Select(p => (int)(p - _messageTypePointerDiff)).ToArray();
var values = messageTypes.Select((type, index) => index + 1).ToArray();
_identifiers = new IntLookup <int>(keys, values);
}
public void Test()
{
var values = Enumerable.Range(1, 100).ToDictionary(i => i, i => i + 1);
var intLookup = new IntLookup <int>(values.Keys.ToArray(), values.Values.ToArray());
foreach (var kvp in values)
{
int value;
if (intLookup.TryGet(kvp.Key, out value))
{
Assert.AreEqual(kvp.Value, value);
}
}
}
public void Test()
{
var values = Enumerable.Range(1, 100).ToDictionary(i => i, i => i + 1);
var intLookup = new IntLookup<int>(values.Keys.ToArray(), values.Values.ToArray());
foreach (var kvp in values)
{
int value;
if (intLookup.TryGet(kvp.Key, out value))
{
Assert.AreEqual(kvp.Value, value);
}
}
}
private static void WriteTranslatePointer(int pointer, IRowOutputInterface output, IntLookup lookup)
{
int i = 0;
if (pointer != -1)
{
i = lookup.LookupFirstEqual(pointer);
}
output.WriteInt(i);
}
public virtual void Write(IRowOutputInterface o, IntLookup lookup)
{
}
public ActorRegistry(IReadOnlyCollection<Tuple<ActorDescriptor, IRingBuffer, ActorId>> actors)
{
if (actors.Count > ActorId.MaxValue)
{
throw new ArgumentException("To many actors");
}
var messageTypesOrdered = actors.Select(t => t.Item1)
.SelectMany(d => d.HandledMessageTypes)
.Distinct()
.OrderBy(t => t.TypeHandle.Value.ToInt64())
.ToArray();
if (messageTypesOrdered.Length == 0)
{
throw new ArgumentException("The handled messages set is empty. This is a useless registry");
}
_messageTypeDiff = messageTypesOrdered.First().TypeHandle.Value.ToInt64() - 1;
var ringsGroupedByMessageId = actors.SelectMany(
t =>
t.Item1.HandledMessageTypes.Select(
messageType => new {MessageTypeId = GetMessageTypeId(messageType), Buffer = t.Item2}))
.GroupBy(a => a.MessageTypeId)
.ToArray();
var buffers = new List<IRingBuffer>();
AddPadding(buffers);
var count = ringsGroupedByMessageId.Length;
var keys = new int[count];
var values = new Tuple<int, int>[count];
var index = 0;
foreach (var g in ringsGroupedByMessageId)
{
keys[index] = g.Key;
var start = buffers.Count;
buffers.AddRange(g.Select(tuple => tuple.Buffer));
var end = buffers.Count;
var length = end - start;
values[index] = Tuple.Create(start, length);
index += 1;
}
AddPadding(buffers);
// create one table
var bufferArray = buffers.ToArray();
var valuesArray =
values.Select(tuple => new ArraySegment<IRingBuffer>(bufferArray, tuple.Item1, tuple.Item2)).ToArray();
_messageTypeToBuffers = new IntLookup<ArraySegment<IRingBuffer>>(keys, valuesArray);
// by actor
var max = actors.Max(t => t.Item3.Value);
_buffersByActor = new IRingBuffer[max + 1];
foreach (var actor in actors)
{
_buffersByActor[actor.Item3.Value] = actor.Item2;
}
}
