Exemplo n.º 1
0
        public object Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
        {
            var type = reader.GetMessagePackType();

            switch (type)
            {
            case MessagePackType.Integer:
                var code = reader.Peek();
                if (MessagePackCode.MinNegativeFixInt <= code && code <= MessagePackCode.MaxNegativeFixInt)
                {
                    return(reader.ReadSByte());
                }
                else if (MessagePackCode.MinFixInt <= code && code <= MessagePackCode.MaxFixInt)
                {
                    return(reader.ReadByte());
                }
                else
                {
                    switch (code)
                    {
                    case MessagePackCode.Int8: return(reader.ReadSByte());

                    case MessagePackCode.Int16: return(reader.ReadInt16());

                    case MessagePackCode.Int32: return(reader.ReadInt32());

                    case MessagePackCode.Int64: return(reader.ReadInt64());

                    case MessagePackCode.UInt8: return(reader.ReadByte());

                    case MessagePackCode.UInt16: return(reader.ReadUInt16());

                    case MessagePackCode.UInt32: return(reader.ReadUInt32());

                    case MessagePackCode.UInt64: return(reader.ReadUInt64());

                    default: ThrowHelper.ThrowInvalidOperationException_Primitive_Bytes(); return(null);
                    }
                }

            case MessagePackType.Boolean:
                return(reader.ReadBoolean());

            case MessagePackType.Float:
                if (MessagePackCode.Float32 == reader.Peek())
                {
                    return(reader.ReadSingle());
                }
                else
                {
                    return(reader.ReadDouble());
                }

            case MessagePackType.String:
                return(reader.ReadString());

            case MessagePackType.Binary:
                return(reader.ReadBytes());

            case MessagePackType.Extension:
                var extTypeCode = reader.GetExtensionFormatTypeCode();
                if (extTypeCode != ReservedMessagePackExtensionTypeCode.DateTime)
                {
                    ThrowHelper.ThrowInvalidOperationException_Primitive_Bytes();
                }
                return(reader.ReadDateTime());

            case MessagePackType.Array:
            {
                var length = reader.ReadArrayHeader();

                var objectFormatter = formatterResolver.GetFormatter <object>();
                var array           = new object[length];
                for (int i = 0; i < length; i++)
                {
                    array[i] = objectFormatter.Deserialize(ref reader, formatterResolver);
                }

                return(array);
            }

            case MessagePackType.Map:
            {
                var length = reader.ReadMapHeader();

                var objectFormatter = formatterResolver.GetFormatter <object>();
                var hash            = new Dictionary <object, object>(length);
                for (int i = 0; i < length; i++)
                {
                    var key   = objectFormatter.Deserialize(ref reader, formatterResolver);
                    var value = objectFormatter.Deserialize(ref reader, formatterResolver);

                    hash.Add(key, value);
                }

                return(hash);
            }

            case MessagePackType.Nil:
                reader.Advance(1);
                return(null);

            default:
                ThrowHelper.ThrowInvalidOperationException_Primitive_Bytes(); return(null);
            }
        }