Ejemplo n.º 1
0
        public void TestUndefined()
        {
            var json = "undefined";

            using (bsonReader = BsonReader.Create(json)) {
                Assert.AreEqual(BsonType.Undefined, bsonReader.ReadBsonType());
                bsonReader.ReadUndefined();
                Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
            }
            Assert.AreEqual(json, BsonSerializer.Deserialize <BsonUndefined>(new StringReader(json)).ToJson());
        }
Ejemplo n.º 2
0
        public void TestUndefined()
        {
            var json = "undefined";

            using (_bsonReader = new JsonReader(json))
            {
                Assert.AreEqual(BsonType.Undefined, _bsonReader.ReadBsonType());
                _bsonReader.ReadUndefined();
                Assert.AreEqual(BsonReaderState.Done, _bsonReader.State);
            }
            Assert.AreEqual(json, BsonSerializer.Deserialize <BsonUndefined>(json).ToJson());
        }
        public void TestUndefinedExtendedJson()
        {
            var json = "{ \"$undefined\" : true }";

            using (_bsonReader = new JsonReader(json))
            {
                Assert.AreEqual(BsonType.Undefined, _bsonReader.ReadBsonType());
                _bsonReader.ReadUndefined();
                Assert.AreEqual(BsonReaderState.Done, _bsonReader.State);
            }
            var canonicalJson = "undefined";

            Assert.AreEqual(canonicalJson, BsonSerializer.Deserialize <BsonUndefined>(new StringReader(json)).ToJson());
        }
        // public methods
        /// <summary>
        /// Deserializes an object from a BsonReader.
        /// </summary>
        /// <param name="bsonReader">The BsonReader.</param>
        /// <param name="nominalType">The nominal type of the object.</param>
        /// <param name="actualType">The actual type of the object.</param>
        /// <param name="options">The serialization options.</param>
        /// <returns>An object.</returns>
        public override object Deserialize(
            BsonReader bsonReader,
            Type nominalType,
            Type actualType,
            IBsonSerializationOptions options)
        {
            VerifyTypes(nominalType, actualType, typeof(BsonUndefined));

            var bsonType = bsonReader.GetCurrentBsonType();
            switch (bsonType)
            {
                case BsonType.Undefined:
                    bsonReader.ReadUndefined();
                    return BsonUndefined.Value;
                default:
                    var message = string.Format("Cannot deserialize BsonUndefined from BsonType {0}.", bsonType);
                    throw new FileFormatException(message);
            }
        }
        // public methods
        /// <summary>
        /// Deserializes an object from a BsonReader.
        /// </summary>
        /// <param name="bsonReader">The BsonReader.</param>
        /// <param name="nominalType">The nominal type of the object.</param>
        /// <param name="actualType">The actual type of the object.</param>
        /// <param name="options">The serialization options.</param>
        /// <returns>An object.</returns>
        public override object Deserialize(
            BsonReader bsonReader,
            Type nominalType,
            Type actualType,
            IBsonSerializationOptions options)
        {
            VerifyTypes(nominalType, actualType, typeof(BsonUndefined));

            var bsonType = bsonReader.GetCurrentBsonType();

            switch (bsonType)
            {
            case BsonType.Undefined:
                bsonReader.ReadUndefined();
                return(BsonUndefined.Value);

            default:
                var message = string.Format("Cannot deserialize BsonUndefined from BsonType {0}.", bsonType);
                throw new FileFormatException(message);
            }
        }
        // public methods
        /// <summary>
        /// Deserializes an object from a BsonReader.
        /// </summary>
        /// <param name="bsonReader">The BsonReader.</param>
        /// <param name="nominalType">The nominal type of the object.</param>
        /// <param name="actualType">The actual type of the object.</param>
        /// <param name="options">The serialization options.</param>
        /// <returns>An object.</returns>
        public override object Deserialize(
            BsonReader bsonReader,
            Type nominalType,
            Type actualType,
            IBsonSerializationOptions options)
        {
            VerifyTypes(nominalType, actualType, typeof(BsonUndefined));

            var bsonType = bsonReader.GetCurrentBsonType();

            if (bsonType == BsonType.Null)
            {
                bsonReader.ReadNull();
                return(null);
            }
            else
            {
                bsonReader.ReadUndefined();
                return(BsonUndefined.Value);
            }
        }
Ejemplo n.º 7
0
        private void ReadValue()
        {
            //bool value = true;
            _type = PBBsonReaderType.Value;
            switch (_bsonType)
            {
            case BsonType.Document:
                WriteLine(2, "ReadStartDocument");
                WriteLine(1, "{");
                //_indent += 2;
                Indent(2);
                _reader.ReadStartDocument();
                _type = PBBsonReaderType.Document;
                //value = false;
                break;

            case BsonType.Array:
                WriteLine(2, "ReadStartArray");
                WriteLine(1, "[");
                //_indent += 2;
                Indent(2);
                _reader.ReadStartArray();
                _type = PBBsonReaderType.Array;
                //value = false;
                break;

            case BsonType.Binary:
                _value = BsonValue.Create(_reader.ReadBytes());
                break;

            case BsonType.Boolean:
                _value = BsonValue.Create(_reader.ReadBoolean());
                break;

            case BsonType.DateTime:
                _value = BsonValue.Create(_reader.ReadDateTime());
                break;

            case BsonType.Double:
                _value = BsonValue.Create(_reader.ReadDouble());
                break;

            case BsonType.Int32:
                _value = BsonValue.Create(_reader.ReadInt32());
                break;

            case BsonType.Int64:
                _value = BsonValue.Create(_reader.ReadInt64());
                break;

            case BsonType.JavaScript:
                _value = BsonValue.Create(_reader.ReadJavaScript());
                break;

            case BsonType.JavaScriptWithScope:
                _value = BsonValue.Create(_reader.ReadJavaScriptWithScope());
                break;

            case BsonType.MaxKey:
                _reader.ReadMaxKey();
                _value = BsonMaxKey.Value;
                break;

            case BsonType.MinKey:
                _reader.ReadMinKey();
                _value = BsonMinKey.Value;
                break;

            case BsonType.Null:
                _reader.ReadNull();
                _value = BsonNull.Value;
                break;

            case BsonType.ObjectId:
                _value = BsonValue.Create(_reader.ReadObjectId());
                break;

            case BsonType.RegularExpression:
                _value = BsonValue.Create(_reader.ReadRegularExpression());
                break;

            case BsonType.String:
                _value = BsonValue.Create(_reader.ReadString());
                break;

            case BsonType.Symbol:
                _value = BsonValue.Create(_reader.ReadSymbol());
                break;

            case BsonType.Timestamp:
                _value = BsonValue.Create(_reader.ReadTimestamp());
                break;

            case BsonType.Undefined:
                _reader.ReadUndefined();
                _value = BsonUndefined.Value;
                break;

            default:
                throw new PBException("error unable to read value type {0}", _bsonType);
            }
            //return value;
        }
Ejemplo n.º 8
0
        // public methods
        /// <summary>
        /// Deserializes an object from a BsonReader.
        /// </summary>
        /// <param name="bsonReader">The BsonReader.</param>
        /// <param name="nominalType">The nominal type of the object.</param>
        /// <param name="actualType">The actual type of the object.</param>
        /// <param name="options">The serialization options.</param>
        /// <returns>An object.</returns>
        public override object Deserialize(
            BsonReader bsonReader,
            Type nominalType,
            Type actualType,
            IBsonSerializationOptions options)
        {
            VerifyTypes(nominalType, actualType, typeof(BsonUndefined));

            var bsonType = bsonReader.GetCurrentBsonType();
            if (bsonType == BsonType.Null)
            {
                bsonReader.ReadNull();
                return null;
            }
            else
            {
                bsonReader.ReadUndefined();
                return BsonUndefined.Value;
            }
        }