Beispiel #1
0
        private MessageBuilder GetMessageBuilder <T> (MessageTypeHandler <T> messageTypeHandler, IGrouping <ulong, Datom> datoms)
        {
            var messageBuilder = new MessageBuilder();

            messageBuilder.Message = messageTypeHandler.Factory(datoms.Key);

            datoms.GroupBy(y => new ParameterWithArrayIndex()
            {
                Parameter           = y.Parameter,
                ParameterArrayIndex = y.ParameterArrayIndex
            })
            .Select(grouping => grouping.OrderByDescending(x => x.TransactionId).First())
            .ToList()
            .ForEach(x => {
                var fieldHandler = messageTypeHandler.FieldsByParameterNumber[x.Parameter];
                if (fieldHandler.FieldClass == FieldClass.Simple)
                {
                    var simpleFieldHandler = (SimpleField <T>)fieldHandler;
                    simpleFieldHandler.Deserialize((T)messageBuilder.Message, x);
                }
                else
                {
                    var referenceFieldHandler = (ReferenceField <T>)fieldHandler;
                    messageBuilder.References.Add(new ReferenceFromBuilder()
                    {
                        Parameter          = x.Parameter,
                        ReferencedTypeId   = referenceFieldHandler.ReferencedTypeId,
                        ReferencedIdentity = referenceFieldHandler.DeserializeIdentity(x),
                        RepeatedFieldIndex = x.ParameterArrayIndex,
                    });
                }
            });

            return(messageBuilder);
        }
Beispiel #2
0
        private Dictionary <ulong, MessageBuilder> GetMessageBuildersForType <T>(IGrouping <ushort, Datom> datoms)
        {
            MessageTypeHandler <T> messageTypeHandler = (MessageTypeHandler <T>)_messageTypeHandlerByTypeId[datoms.Key];

            return(datoms.GroupBy(x => x.Identity)
                   .Select(groupedByIdentity =>
                           new KeyValuePair <ulong, MessageBuilder>(
                               groupedByIdentity.Key,
                               GetMessageBuilder(messageTypeHandler, groupedByIdentity)
                               )
                           ).ToDictionary(x => x.Key, x => x.Value));
        }
Beispiel #3
0
        private void WireUpReferencesForType <T> (ushort typeId, Dictionary <ushort, Dictionary <ulong, MessageBuilder> > types)
        {
            MessageTypeHandler <T> messageTypeHandler = (MessageTypeHandler <T>)_messageTypeHandlerByTypeId[typeId];

            var instances = types[typeId];

            foreach (var instanceKeyValue in instances)
            {
                foreach (var reference in instanceKeyValue.Value.References)
                {
                    if (types.ContainsKey(reference.ReferencedTypeId))
                    {
                        var referencedType = types[reference.ReferencedTypeId];
                        if (referencedType.ContainsKey(reference.ReferencedIdentity))
                        {
                            var field   = messageTypeHandler.FieldsByParameterNumber[reference.Parameter] as ReferenceField <T>;
                            var message = (T)instanceKeyValue.Value.Message;
                            field.SetReference(message, (int)reference.RepeatedFieldIndex, referencedType[reference.ReferencedIdentity].Message);
                        }
                    }
                }
            }
        }