Beispiel #1
0
        protected internal override DictionaryEntry UnpackFromCore(Unpacker unpacker)
        {
            if (unpacker.IsArrayHeader)
            {
                MessagePackObject key;
                MessagePackObject value;

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

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

                return(new DictionaryEntry(key, value));
            }
            else
            {
                // Previous DictionaryEntry serializer accidentally pack it as map...
                MessagePackObject key   = default(MessagePackObject);
                MessagePackObject value = default(MessagePackObject);
                bool   isKeyFound       = false;
                bool   isValueFound     = false;
                string propertyName;

                while ((!isKeyFound || !isValueFound) && unpacker.ReadString(out propertyName))
                {
                    switch (propertyName)
                    {
                    case "Key":
                    {
                        if (!unpacker.ReadObject(out key))
                        {
                            SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
                        }

                        isKeyFound = true;
                        break;
                    }

                    case "Value":
                    {
                        if (!unpacker.ReadObject(out value))
                        {
                            SerializationExceptions.ThrowUnexpectedEndOfStream(unpacker);
                        }

                        isValueFound = true;
                        break;
                    }
                    }
                }

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

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

                return(new DictionaryEntry(key, value));
            }
        }
Beispiel #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));
            }
        }