protected internal override async Task <object> UnpackFromAsyncCore(Unpacker unpacker, CancellationToken cancellationToken)
        {
            if (unpacker.IsArrayHeader)
            {
                var result = new MessagePackObject[UnpackHelpers.GetItemsCount(unpacker)];
                for (int i = 0; i < result.Length; i++)
                {
                    var item = await unpacker.ReadObjectAsync(cancellationToken).ConfigureAwait(false);

                    if (!item.Success)
                    {
                        SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
                    }

                    result[i] = item.Value;
                }

                return(new MessagePackObject(result));
            }
            else if (unpacker.IsMapHeader)
            {
                var itemsCount = UnpackHelpers.GetItemsCount(unpacker);
                var result     = new MessagePackObjectDictionary(itemsCount);
                for (int i = 0; i < itemsCount; i++)
                {
                    var key = await unpacker.ReadObjectAsync(cancellationToken).ConfigureAwait(false);

                    if (!key.Success)
                    {
                        SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
                    }

                    var value = await unpacker.ReadObjectAsync(cancellationToken).ConfigureAwait(false);

                    if (!value.Success)
                    {
                        SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
                    }

                    result.Add(key.Value, value.Value);
                }

                return(new MessagePackObject(result));
            }
            else
            {
                var result = unpacker.LastReadData;
                return(result.IsNil ? MessagePackObject.Nil : result);
            }
        }
Example #2
0
        protected internal override async Task <DictionaryEntry> UnpackFromAsyncCore(Unpacker unpacker, CancellationToken cancellationToken)
        {
            if (unpacker.IsArrayHeader)
            {
                var key = await unpacker.ReadObjectAsync(cancellationToken).ConfigureAwait(false);

                if (!key.Success)
                {
                    SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
                }

                var value = await unpacker.ReadObjectAsync(cancellationToken).ConfigureAwait(false);

                if (!value.Success)
                {
                    SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
                }

                return(new DictionaryEntry(key.Value, value.Value));
            }
            else
            {
                // Previous DictionaryEntry serializer accidentally pack it as map...
                AsyncReadResult <MessagePackObject> key   = default(AsyncReadResult <MessagePackObject>);
                AsyncReadResult <MessagePackObject> value = default(AsyncReadResult <MessagePackObject>);

                for (var propertyName = await unpacker.ReadStringAsync(cancellationToken).ConfigureAwait(false);
                     (!key.Success || !value.Success) && propertyName.Success;
                     propertyName = await unpacker.ReadStringAsync(cancellationToken).ConfigureAwait(false))
                {
                    switch (propertyName.Value)
                    {
                    case "Key":
                    {
                        key = await unpacker.ReadObjectAsync(cancellationToken).ConfigureAwait(false);

                        if (!key.Success)
                        {
                            SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
                        }

                        break;
                    }

                    case "Value":
                    {
                        value = await unpacker.ReadObjectAsync(cancellationToken).ConfigureAwait(false);

                        if (!value.Success)
                        {
                            SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
                        }

                        break;
                    }
                    }
                }

                if (!key.Success)
                {
                    SerializationExceptions.ThrowMissingProperty("Key");
                }

                if (!value.Success)
                {
                    SerializationExceptions.ThrowMissingProperty("Value");
                }

                return(new DictionaryEntry(key.Value, value.Value));
            }
        }