/// <summary>
 /// Initializes a new instance of the BsonReader class.
 /// </summary>
 /// <param name="settings">The reader settings.</param>
 protected BsonReader(
     BsonReaderSettings settings
 )
 {
     this.settings = settings.FrozenCopy();
     this.state = BsonReaderState.Initial;
 }
 // constructors
 internal JsonReaderBookmark(BsonReaderState state, BsonType currentBsonType, string currentName, JsonReaderContext context, JsonToken currentToken, BsonValue currentValue, JsonToken pushedToken, int position)
     : base(state, currentBsonType, currentName)
 {
     _context = context.Clone();
     _currentToken = currentToken;
     _currentValue = currentValue;
     _pushedToken = pushedToken;
     _position = position;
 }
 protected BsonReaderBookmark(
     BsonReaderState state,
     BsonType currentBsonType,
     string currentName
 )
 {
     this.state = state;
     this.currentBsonType = currentBsonType;
     this.currentName = currentName;
 }
        // constructors
        /// <summary>
        /// Initializes a new instance of the BsonReader class.
        /// </summary>
        /// <param name="settings">The reader settings.</param>
        protected BsonReader(BsonReaderSettings settings)
        {
            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }

            _settings = settings.FrozenCopy();
            _state = BsonReaderState.Initial;
        }
 // constructors
 internal BsonBinaryReaderBookmark(
     BsonReaderState state,
     BsonType currentBsonType,
     string currentName,
     BsonBinaryReaderContext context,
     int position)
     : base(state, currentBsonType, currentName)
 {
     _context = context.Clone();
     _position = position;
 }
 // constructors
 internal BsonDocumentReaderBookmark(
     BsonReaderState state,
     BsonType currentBsonType,
     string currentName,
     BsonDocumentReaderContext context,
     BsonValue currentValue)
     : base(state, currentBsonType, currentName)
 {
     _context = context.Clone();
     _currentValue = currentValue;
 }
        /// <summary>
        /// Reads the name of an element from the reader.
        /// </summary>
        /// <returns>The name of the element.</returns>
        public string ReadName()
        {
            if (_disposed)
            {
                ThrowObjectDisposedException();
            }
            if (_state == BsonReaderState.Type)
            {
                ReadBsonType();
            }
            if (_state != BsonReaderState.Name)
            {
                ThrowInvalidState("ReadName", BsonReaderState.Name);
            }

            _state = BsonReaderState.Value;
            return(_currentName);
        }
 private bool ReadReference()
 {
     JsonReader.State currentState = base.CurrentState;
     if (currentState != JsonReader.State.Property)
     {
         if (currentState == JsonReader.State.ObjectStart)
         {
             base.SetToken(JsonToken.PropertyName, "$ref");
             this._bsonReaderState = BsonReaderState.ReferenceRef;
             return(true);
         }
         if (currentState != JsonReader.State.PostValue)
         {
             throw JsonReaderException.Create(this, "Unexpected state when reading BSON reference: " + base.CurrentState);
         }
     }
     else
     {
         if (this._bsonReaderState == BsonReaderState.ReferenceRef)
         {
             base.SetToken(JsonToken.String, this.ReadLengthString());
             return(true);
         }
         if (this._bsonReaderState != BsonReaderState.ReferenceId)
         {
             throw JsonReaderException.Create(this, "Unexpected state when reading BSON reference: " + this._bsonReaderState);
         }
         base.SetToken(JsonToken.Bytes, this.ReadBytes(12));
         return(true);
     }
     if (this._bsonReaderState == BsonReaderState.ReferenceRef)
     {
         base.SetToken(JsonToken.PropertyName, "$id");
         this._bsonReaderState = BsonReaderState.ReferenceId;
         return(true);
     }
     if (this._bsonReaderState != BsonReaderState.ReferenceId)
     {
         throw JsonReaderException.Create(this, "Unexpected state when reading BSON reference: " + this._bsonReaderState);
     }
     base.SetToken(JsonToken.EndObject);
     this._bsonReaderState = BsonReaderState.Normal;
     return(true);
 }
        /// <summary>
        /// Reads the name of an element from the reader.
        /// </summary>
        /// <returns>The name of the element.</returns>
        public override string ReadName()
        {
            if (disposed)
            {
                ThrowObjectDisposedException();
            }
            if (state == BsonReaderState.Type)
            {
                ReadBsonType();
            }
            if (state != BsonReaderState.Name)
            {
                var message = string.Format("ReadName cannot be called when State is: {0}", state);
                throw new InvalidOperationException(message);
            }

            state = BsonReaderState.Value;
            return(currentName);
        }
        private bool ReadReference()
        {
            switch (base.CurrentState)
            {
            case State.ObjectStart:
                SetToken(JsonToken.PropertyName, "$ref");
                _bsonReaderState = BsonReaderState.ReferenceRef;
                return(true);

            case State.Property:
                if (_bsonReaderState == BsonReaderState.ReferenceRef)
                {
                    SetToken(JsonToken.String, ReadLengthString());
                    return(true);
                }
                if (_bsonReaderState == BsonReaderState.ReferenceId)
                {
                    SetToken(JsonToken.Bytes, ReadBytes(12));
                    return(true);
                }
                throw new JsonReaderException("Unexpected state when reading BSON reference: " + _bsonReaderState);

            case State.PostValue:
                if (_bsonReaderState == BsonReaderState.ReferenceRef)
                {
                    SetToken(JsonToken.PropertyName, "$id");
                    _bsonReaderState = BsonReaderState.ReferenceId;
                    return(true);
                }
                if (_bsonReaderState == BsonReaderState.ReferenceId)
                {
                    SetToken(JsonToken.EndObject);
                    _bsonReaderState = BsonReaderState.Normal;
                    return(true);
                }
                throw new JsonReaderException("Unexpected state when reading BSON reference: " + _bsonReaderState);

            default:
                throw new JsonReaderException("Unexpected state when reading BSON reference: " + base.CurrentState);
            }
        }
 /// <summary>
 /// Verifies the current state and BsonType of the reader.
 /// </summary>
 /// <param name="methodName">The name of the method calling this one.</param>
 /// <param name="requiredBsonType">The required BSON type.</param>
 protected void VerifyBsonType(string methodName, BsonType requiredBsonType)
 {
     if (state == BsonReaderState.Initial || state == BsonReaderState.ScopeDocument || state == BsonReaderState.Type)
     {
         ReadBsonType();
     }
     if (state == BsonReaderState.Name)
     {
         // ignore name
         state = BsonReaderState.Value;
     }
     if (state != BsonReaderState.Value)
     {
         ThrowInvalidState(methodName, BsonReaderState.Value);
     }
     if (currentBsonType != requiredBsonType)
     {
         var message = string.Format(
             "{0} can only be called when CurrentBsonType is {1}, not when CurrentBsonType is {2}.",
             methodName, requiredBsonType, currentBsonType);
         throw new InvalidOperationException(message);
     }
 }
Exemple #12
0
        private void ReadType(BsonType type)
        {
            switch (type)
            {
            case BsonType.Number:
                SetToken(JsonToken.Float, ReadDouble());
                break;

            case BsonType.String:
            case BsonType.Symbol:
                SetToken(JsonToken.String, ReadLengthString());
                break;

            case BsonType.Object:
            {
                SetToken(JsonToken.StartObject);

                ContainerContext newContext = new ContainerContext(JTokenType.Object);
                _stack.Add(newContext);
                newContext.Length = ReadInt32();
                break;
            }

            case BsonType.Array:
            {
                SetToken(JsonToken.StartArray);

                ContainerContext newContext = new ContainerContext(JTokenType.Array);
                _stack.Add(newContext);
                newContext.Length = ReadInt32();
                break;
            }

            case BsonType.Binary:
                SetToken(JsonToken.Bytes, ReadBinary());
                break;

            case BsonType.Undefined:
                SetToken(JsonToken.Undefined);
                break;

            case BsonType.Oid:
                byte[] oid = ReadBytes(12);
                SetToken(JsonToken.Bytes, oid);
                break;

            case BsonType.Boolean:
                bool b = Convert.ToBoolean(ReadByte());
                SetToken(JsonToken.Boolean, b);
                break;

            case BsonType.Date:
                long     ticks    = ReadInt64();
                DateTime dateTime = JsonConvert.ConvertJavaScriptTicksToDateTime(ticks);
                SetToken(JsonToken.Date, dateTime);
                break;

            case BsonType.Null:
                SetToken(JsonToken.Null);
                break;

            case BsonType.Regex:
                string expression = ReadString();
                string modifiers  = ReadString();

                string regex = @"/" + expression + @"/" + modifiers;
                SetToken(JsonToken.String, regex);
                break;

            case BsonType.Reference:
                SetToken(JsonToken.StartObject);
                _bsonReaderState = BsonReaderState.ReferenceStart;
                break;

            case BsonType.Code:
                SetToken(JsonToken.String, ReadLengthString());
                break;

            case BsonType.CodeWScope:
                SetToken(JsonToken.StartObject);
                _bsonReaderState = BsonReaderState.CodeWScopeStart;
                break;

            case BsonType.Integer:
                SetToken(JsonToken.Integer, (long)ReadInt32());
                break;

            case BsonType.TimeStamp:
            case BsonType.Long:
                SetToken(JsonToken.Integer, ReadInt64());
                break;

            default:
                throw new ArgumentOutOfRangeException("type", "Unexpected BsonType value: " + type);
            }
        }
        /// <summary>
        /// Reads the name of an element from the reader.
        /// </summary>
        /// <returns>The name of the element.</returns>
        public override string ReadName() {
            if (disposed) { ThrowObjectDisposedException(); }
            if (state == BsonReaderState.Type) {
                ReadBsonType();
            }
            if (state != BsonReaderState.Name) {
                var message = string.Format("ReadName cannot be called when State is: {0}", state);
                throw new InvalidOperationException(message);
            }

            state = BsonReaderState.Value;
            return currentName;
        }
Exemple #14
0
 // constructors
 /// <summary>
 /// Initializes a new instance of the BsonReader class.
 /// </summary>
 /// <param name="settings">The reader settings.</param>
 protected BsonReader(BsonReaderSettings settings)
 {
     _settings = settings.FrozenCopy();
     _state    = BsonReaderState.Initial;
 }
        private void ReadType(BsonType type)
        {
            switch (type)
            {
            case BsonType.Number:
                SetToken(JsonToken.Float, ReadDouble());
                break;

            case BsonType.String:
            case BsonType.Symbol:
                SetToken(JsonToken.String, ReadLengthString());
                break;

            case BsonType.Object:
            {
                SetToken(JsonToken.StartObject);
                ContainerContext containerContext2 = new ContainerContext(BsonType.Object);
                PushContext(containerContext2);
                containerContext2.Length = ReadInt32();
                break;
            }

            case BsonType.Array:
            {
                SetToken(JsonToken.StartArray);
                ContainerContext containerContext = new ContainerContext(BsonType.Array);
                PushContext(containerContext);
                containerContext.Length = ReadInt32();
                break;
            }

            case BsonType.Binary:
                SetToken(JsonToken.Bytes, ReadBinary());
                break;

            case BsonType.Undefined:
                SetToken(JsonToken.Undefined);
                break;

            case BsonType.Oid:
            {
                byte[] value2 = ReadBytes(12);
                SetToken(JsonToken.Bytes, value2);
                break;
            }

            case BsonType.Boolean:
            {
                bool flag = Convert.ToBoolean(ReadByte());
                SetToken(JsonToken.Boolean, flag);
                break;
            }

            case BsonType.Date:
            {
                long     javaScriptTicks = ReadInt64();
                DateTime dateTime        = JsonConvert.ConvertJavaScriptTicksToDateTime(javaScriptTicks);
                DateTime dateTime2;
                switch (DateTimeKindHandling)
                {
                case DateTimeKind.Unspecified:
                    dateTime2 = DateTime.SpecifyKind(dateTime, DateTimeKind.Unspecified);
                    break;

                case DateTimeKind.Local:
                    dateTime2 = dateTime.ToLocalTime();
                    break;

                default:
                    dateTime2 = dateTime;
                    break;
                }
                SetToken(JsonToken.Date, dateTime2);
                break;
            }

            case BsonType.Null:
                SetToken(JsonToken.Null);
                break;

            case BsonType.Regex:
            {
                string str   = ReadString();
                string str2  = ReadString();
                string value = "/" + str + "/" + str2;
                SetToken(JsonToken.String, value);
                break;
            }

            case BsonType.Reference:
                SetToken(JsonToken.StartObject);
                _bsonReaderState = BsonReaderState.ReferenceStart;
                break;

            case BsonType.Code:
                SetToken(JsonToken.String, ReadLengthString());
                break;

            case BsonType.CodeWScope:
                SetToken(JsonToken.StartObject);
                _bsonReaderState = BsonReaderState.CodeWScopeStart;
                break;

            case BsonType.Integer:
                SetToken(JsonToken.Integer, (long)ReadInt32());
                break;

            case BsonType.TimeStamp:
            case BsonType.Long:
                SetToken(JsonToken.Integer, ReadInt64());
                break;

            default:
                throw new ArgumentOutOfRangeException("type", "Unexpected BsonType value: " + type);
            }
        }
Exemple #16
0
    private void ReadType(BsonType type)
    {
      switch (type)
      {
        case BsonType.Number:
          SetToken(JsonToken.Float, ReadDouble());
          break;
        case BsonType.String:
        case BsonType.Symbol:
          SetToken(JsonToken.String, ReadLengthString());
          break;
        case BsonType.Object:
          {
            SetToken(JsonToken.StartObject);

            ContainerContext newContext = new ContainerContext(JTokenType.Object);
            _stack.Add(newContext);
            newContext.Length = ReadInt32();
            break;
          }
        case BsonType.Array:
          {
            SetToken(JsonToken.StartArray);

            ContainerContext newContext = new ContainerContext(JTokenType.Array);
            _stack.Add(newContext);
            newContext.Length = ReadInt32();
            break;
          }
        case BsonType.Binary:
          SetToken(JsonToken.Bytes, ReadBinary());
          break;
        case BsonType.Undefined:
          SetToken(JsonToken.Undefined);
          break;
        case BsonType.Oid:
          byte[] oid = ReadBytes(12);
          SetToken(JsonToken.Bytes, oid);
          break;
        case BsonType.Boolean:
          bool b = Convert.ToBoolean(ReadByte());
          SetToken(JsonToken.Boolean, b);
          break;
        case BsonType.Date:
          long ticks = ReadInt64();
          DateTime dateTime = JsonConvert.ConvertJavaScriptTicksToDateTime(ticks);
          SetToken(JsonToken.Date, dateTime);
          break;
        case BsonType.Null:
          SetToken(JsonToken.Null);
          break;
        case BsonType.Regex:
          string expression = ReadString();
          string modifiers = ReadString();

          string regex = @"/" + expression + @"/" + modifiers;
          SetToken(JsonToken.String, regex);
          break;
        case BsonType.Reference:
          SetToken(JsonToken.StartObject);
          _bsonReaderState = BsonReaderState.ReferenceStart;
          break;
        case BsonType.Code:
          SetToken(JsonToken.String, ReadLengthString());
          break;
        case BsonType.CodeWScope:
          SetToken(JsonToken.StartObject);
          _bsonReaderState = BsonReaderState.CodeWScopeStart;
          break;
        case BsonType.Integer:
          SetToken(JsonToken.Integer, (long)ReadInt32());
          break;
        case BsonType.TimeStamp:
        case BsonType.Long:
          SetToken(JsonToken.Integer, ReadInt64());
          break;
        default:
          throw new ArgumentOutOfRangeException("type", "Unexpected BsonType value: " + type);
      }
    }
Exemple #17
0
 // constructors
 internal BsonBinaryReaderBookmark(BsonReaderState state, BsonType currentBsonType, string currentName, BsonBinaryReaderContext context, int position)
     : base(state, currentBsonType, currentName)
 {
     this.context  = context.Clone();
     this.position = position;
 }
        /// <summary>
        /// Reads the name of an element from the reader.
        /// </summary>
        /// <returns>The name of the element.</returns>
        public string ReadName()
        {
            if (disposed) { ThrowObjectDisposedException(); }
            if (state == BsonReaderState.Type)
            {
                ReadBsonType();
            }
            if (state != BsonReaderState.Name)
            {
                ThrowInvalidState("ReadName", BsonReaderState.Name);
            }

            state = BsonReaderState.Value;
            return currentName;
        }
 /// <summary>
 /// Initializes a new instance of the BsonBaseReader class.
 /// </summary>
 protected BsonBaseReader()
 {
     state = BsonReaderState.Initial;
 }
Exemple #20
0
 // constructors
 internal BsonDocumentReaderBookmark(BsonReaderState state, BsonType currentBsonType, string currentName, BsonDocumentReaderContext context, BsonValue currentValue)
     : base(state, currentBsonType, currentName)
 {
     this.context      = context.Clone();
     this.currentValue = currentValue;
 }
Exemple #21
0
        private void ReadType(BsonType type)
        {
            switch (type)
            {
            case BsonType.Number:
                double d = ReadDouble();
                SetFloatToken(d);
                break;

            case BsonType.String:
            case BsonType.Symbol:
                SetToken(JsonToken.String, ReadLengthString());
                break;

            case BsonType.Object:
            {
                SetToken(JsonToken.StartObject);

                ContainerContext newContext = new ContainerContext(BsonType.Object);
                PushContext(newContext);
                newContext.Length = ReadInt32();
                break;
            }

            case BsonType.Array:
            {
                SetToken(JsonToken.StartArray);

                ContainerContext newContext = new ContainerContext(BsonType.Array);
                PushContext(newContext);
                newContext.Length = ReadInt32();
                break;
            }

            case BsonType.Binary:
                BsonBinaryType binaryType;
                byte[]         data = ReadBinary(out binaryType);

                object value = (binaryType != BsonBinaryType.Uuid)
                        ? data
                        : (object)new Guid(data);

                SetToken(JsonToken.Bytes, value);
                break;

            case BsonType.Undefined:
                SetToken(JsonToken.Undefined);
                break;

            case BsonType.Oid:
                byte[] oid = ReadBytes(12);
                SetToken(JsonToken.Bytes, oid);
                break;

            case BsonType.Boolean:
                bool b = Convert.ToBoolean(ReadByte());
                SetBoolToken(b);
                break;

            case BsonType.Date:
                long     ticks       = ReadInt64();
                DateTime utcDateTime = DateTimeUtils.ConvertJavaScriptTicksToDateTime(ticks);

                DateTime dateTime;
                switch (DateTimeKindHandling)
                {
                case DateTimeKind.Unspecified:
                    dateTime = DateTime.SpecifyKind(utcDateTime, DateTimeKind.Unspecified);
                    break;

                case DateTimeKind.Local:
                    dateTime = utcDateTime.ToLocalTime();
                    break;

                default:
                    dateTime = utcDateTime;
                    break;
                }

                SetToken(JsonToken.Date, dateTime);
                break;

            case BsonType.Null:
                SetToken(JsonToken.Null);
                break;

            case BsonType.Regex:
                string expression = ReadString();
                string modifiers  = ReadString();

                string regex = @"/" + expression + @"/" + modifiers;
                SetToken(JsonToken.String, regex);
                break;

            case BsonType.Reference:
                SetToken(JsonToken.StartObject);
                _bsonReaderState = BsonReaderState.ReferenceStart;
                break;

            case BsonType.Code:
                SetToken(JsonToken.String, ReadLengthString());
                break;

            case BsonType.CodeWScope:
                SetToken(JsonToken.StartObject);
                _bsonReaderState = BsonReaderState.CodeWScopeStart;
                break;

            case BsonType.Integer:
                SetIntToken((long)ReadInt32());
                break;

            case BsonType.TimeStamp:
            case BsonType.Long:
                SetIntToken(ReadInt64());
                break;

            default:
                throw new ArgumentOutOfRangeException("type", "Unexpected BsonType value: " + type);
            }
        }
Exemple #22
0
        private void ReadType(BsonType type)
        {
            switch (type)
            {
            case BsonType.Number:
                this.SetToken(JsonToken.Float, this.ReadDouble());
                break;

            case BsonType.String:
            case BsonType.Symbol:
                this.SetToken(JsonToken.String, this.ReadLengthString());
                break;

            case BsonType.Object:
            {
                this.SetToken(JsonToken.StartObject);

                ContainerContext newContext = new ContainerContext(BsonType.Object);
                this.PushContext(newContext);
                newContext.Length = this.ReadInt32();
                break;
            }

            case BsonType.Array:
            {
                this.SetToken(JsonToken.StartArray);

                ContainerContext newContext = new ContainerContext(BsonType.Array);
                this.PushContext(newContext);
                newContext.Length = this.ReadInt32();
                break;
            }

            case BsonType.Binary:
                this.SetToken(JsonToken.Bytes, this.ReadBinary());
                break;

            case BsonType.Undefined:
                this.SetToken(JsonToken.Undefined);
                break;

            case BsonType.Oid:
                byte[] oid = this.ReadBytes(12);
                this.SetToken(JsonToken.Bytes, oid);
                break;

            case BsonType.Boolean:
                bool b = Convert.ToBoolean(this.ReadByte());
                this.SetToken(JsonToken.Boolean, b);
                break;

            case BsonType.Date:
                long     ticks       = this.ReadInt64();
                DateTime utcDateTime = JsonConvert.ConvertJavaScriptTicksToDateTime(ticks);

                DateTime dateTime;
                switch (this.DateTimeKindHandling)
                {
                case DateTimeKind.Unspecified:
                    dateTime = DateTime.SpecifyKind(utcDateTime, DateTimeKind.Unspecified);
                    break;

                case DateTimeKind.Local:
                    dateTime = utcDateTime.ToLocalTime();
                    break;

                default:
                    dateTime = utcDateTime;
                    break;
                }

                this.SetToken(JsonToken.Date, dateTime);
                break;

            case BsonType.Null:
                this.SetToken(JsonToken.Null);
                break;

            case BsonType.Regex:
                string expression = this.ReadString();
                string modifiers  = this.ReadString();

                string regex = string.Format("{0}{1}{2}{3}", @"/", expression, @"/", modifiers);
                this.SetToken(JsonToken.String, regex);
                break;

            case BsonType.Reference:
                this.SetToken(JsonToken.StartObject);
                this._bsonReaderState = BsonReaderState.ReferenceStart;
                break;

            case BsonType.Code:
                this.SetToken(JsonToken.String, this.ReadLengthString());
                break;

            case BsonType.CodeWScope:
                this.SetToken(JsonToken.StartObject);
                this._bsonReaderState = BsonReaderState.CodeWScopeStart;
                break;

            case BsonType.Integer:
                this.SetToken(JsonToken.Integer, (long)this.ReadInt32());
                break;

            case BsonType.TimeStamp:
            case BsonType.Long:
                this.SetToken(JsonToken.Integer, this.ReadInt64());
                break;

            default:
                throw new ArgumentOutOfRangeException("type", string.Format("Unexpected BsonType value: {0}", type));
            }
        }
Exemple #23
0
        private void ReadType(BsonType type)
        {
            switch (type)
            {
            case BsonType.Number:
                double d = ReadDouble();

                if (_floatParseHandling == FloatParseHandling.Decimal)
                {
                    SetToken(JsonToken.Float, Convert.ToDecimal(d, CultureInfo.InvariantCulture));
                }
                else
                {
                    SetToken(JsonToken.Float, d);
                }
                break;

            case BsonType.String:
            case BsonType.Symbol:
                SetToken(JsonToken.String, ReadLengthString());
                break;

            case BsonType.Object:
            {
                SetToken(JsonToken.StartObject);

                ContainerContext newContext = new ContainerContext(BsonType.Object);
                PushContext(newContext);
                newContext.Length = ReadInt32();
                break;
            }

            case BsonType.Array:
            {
                SetToken(JsonToken.StartArray);

                ContainerContext newContext = new ContainerContext(BsonType.Array);
                PushContext(newContext);
                newContext.Length = ReadInt32();
                break;
            }

            case BsonType.Binary:
                SetToken(JsonToken.Bytes, ReadBinary());
                break;

            case BsonType.Undefined:
                SetToken(JsonToken.Undefined);
                break;

            case BsonType.Oid:
                byte[] oid = ReadBytes(12);
                SetToken(JsonToken.Bytes, oid);
                break;

            case BsonType.Boolean:
                bool b = Convert.ToBoolean(ReadByte());
                SetToken(JsonToken.Boolean, b);
                break;

            case BsonType.Date:
                long     ticks       = ReadInt64();
                DateTime utcDateTime = DateTimeUtils.ConvertJavaScriptTicksToDateTime(ticks);

                DateTime dateTime;
                switch (DateTimeKindHandling)
                {
                case DateTimeKind.Unspecified:
                    dateTime = DateTime.SpecifyKind(utcDateTime, DateTimeKind.Unspecified);
                    break;

                case DateTimeKind.Local:
                    dateTime = utcDateTime.ToLocalTime();
                    break;

                default:
                    dateTime = utcDateTime;
                    break;
                }

                SetToken(JsonToken.Date, dateTime);
                break;

            case BsonType.Null:
                SetToken(JsonToken.Null);
                break;

            case BsonType.Regex:
                string expression = ReadString();
                string modifiers  = ReadString();

                string regex = @"/" + expression + @"/" + modifiers;
                SetToken(JsonToken.String, regex);
                break;

            case BsonType.Reference:
                SetToken(JsonToken.StartObject);
                _bsonReaderState = BsonReaderState.ReferenceStart;
                break;

            case BsonType.Code:
                SetToken(JsonToken.String, ReadLengthString());
                break;

            case BsonType.CodeWScope:
                SetToken(JsonToken.StartObject);
                _bsonReaderState = BsonReaderState.CodeWScopeStart;
                break;

            case BsonType.Integer:
                SetToken(JsonToken.Integer, (long)ReadInt32());
                break;

            case BsonType.TimeStamp:
            case BsonType.Long:
                SetToken(JsonToken.Integer, ReadInt64());
                break;

            default:
                throw new ArgumentOutOfRangeException("type", "Unexpected BsonType value: " + type);
            }
        }
 private bool ReadReference()
 {
     switch (CurrentState)
     {
         case State.ObjectStart:
         {
             SetToken(JsonToken.PropertyName, JsonTypeReflector.RefPropertyName);
             _bsonReaderState = BsonReaderState.ReferenceRef;
             return true;
         }
         case State.Property:
         {
             if (_bsonReaderState == BsonReaderState.ReferenceRef)
             {
                 SetToken(JsonToken.String, ReadLengthString());
                 return true;
             }
             else if (_bsonReaderState == BsonReaderState.ReferenceId)
             {
                 SetToken(JsonToken.Bytes, ReadBytes(12));
                 return true;
             }
             else
             {
                 throw JsonReaderException.Create(this, "Unexpected state when reading BSON reference: " + _bsonReaderState);
             }
         }
         case State.PostValue:
         {
             if (_bsonReaderState == BsonReaderState.ReferenceRef)
             {
                 SetToken(JsonToken.PropertyName, JsonTypeReflector.IdPropertyName);
                 _bsonReaderState = BsonReaderState.ReferenceId;
                 return true;
             }
             else if (_bsonReaderState == BsonReaderState.ReferenceId)
             {
                 SetToken(JsonToken.EndObject);
                 _bsonReaderState = BsonReaderState.Normal;
                 return true;
             }
             else
             {
                 throw JsonReaderException.Create(this, "Unexpected state when reading BSON reference: " + _bsonReaderState);
             }
         }
         default:
             throw JsonReaderException.Create(this, "Unexpected state when reading BSON reference: " + CurrentState);
     }
 }
 /// <summary>
 /// Verifies the current state and BsonType of the reader.
 /// </summary>
 /// <param name="methodName">The name of the method calling this one.</param>
 /// <param name="requiredBsonType">The required BSON type.</param>
 protected void VerifyBsonType(string methodName, BsonType requiredBsonType)
 {
     if (state == BsonReaderState.Initial || state == BsonReaderState.ScopeDocument || state == BsonReaderState.Type)
     {
         ReadBsonType();
     }
     if (state == BsonReaderState.Name)
     {
         // ignore name
         state = BsonReaderState.Value;
     }
     if (state != BsonReaderState.Value)
     {
         ThrowInvalidState(methodName, BsonReaderState.Value);
     }
     if (currentBsonType != requiredBsonType)
     {
         var message = string.Format(
             "{0} can only be called when CurrentBsonType is {1}, not when CurrentBsonType is {2}.",
             methodName, requiredBsonType, currentBsonType);
         throw new InvalidOperationException(message);
     }
 }
Exemple #26
0
        private void ReadType(BsonType type)
        {
            DateTime time2;

            switch (type)
            {
            case BsonType.Number:
            {
                double num = this.ReadDouble();
                if (base._floatParseHandling != FloatParseHandling.Decimal)
                {
                    base.SetToken(JsonToken.Float, num);
                    return;
                }
                base.SetToken(JsonToken.Float, Convert.ToDecimal(num, CultureInfo.InvariantCulture));
                return;
            }

            case BsonType.String:
            case BsonType.Symbol:
                base.SetToken(JsonToken.String, this.ReadLengthString());
                return;

            case BsonType.Object:
            {
                base.SetToken(JsonToken.StartObject);
                ContainerContext newContext = new ContainerContext(BsonType.Object);
                this.PushContext(newContext);
                newContext.Length = this.ReadInt32();
                return;
            }

            case BsonType.Array:
            {
                base.SetToken(JsonToken.StartArray);
                ContainerContext newContext = new ContainerContext(BsonType.Array);
                this.PushContext(newContext);
                newContext.Length = this.ReadInt32();
                return;
            }

            case BsonType.Binary:
            {
                byte[] b    = this.ReadBinary(out BsonBinaryType type2);
                object obj2 = (type2 != BsonBinaryType.Uuid) ? ((object)b) : ((object)new Guid(b));
                base.SetToken(JsonToken.Bytes, obj2);
                return;
            }

            case BsonType.Undefined:
                base.SetToken(JsonToken.Undefined);
                return;

            case BsonType.Oid:
            {
                byte[] buffer2 = this.ReadBytes(12);
                base.SetToken(JsonToken.Bytes, buffer2);
                return;
            }

            case BsonType.Boolean:
            {
                bool flag = Convert.ToBoolean(this.ReadByte());
                base.SetToken(JsonToken.Boolean, flag);
                return;
            }

            case BsonType.Date:
            {
                DateTime time = DateTimeUtils.ConvertJavaScriptTicksToDateTime(this.ReadInt64());
                switch (this.DateTimeKindHandling)
                {
                case DateTimeKind.Unspecified:
                    time2 = DateTime.SpecifyKind(time, DateTimeKind.Unspecified);
                    goto Label_019C;

                case DateTimeKind.Local:
                    time2 = time.ToLocalTime();
                    goto Label_019C;
                }
                time2 = time;
                break;
            }

            case BsonType.Null:
                base.SetToken(JsonToken.Null);
                return;

            case BsonType.Regex:
            {
                string str  = this.ReadString();
                string str2 = this.ReadString();
                string str3 = "/" + str + "/" + str2;
                base.SetToken(JsonToken.String, str3);
                return;
            }

            case BsonType.Reference:
                base.SetToken(JsonToken.StartObject);
                this._bsonReaderState = BsonReaderState.ReferenceStart;
                return;

            case BsonType.Code:
                base.SetToken(JsonToken.String, this.ReadLengthString());
                return;

            case BsonType.CodeWScope:
                base.SetToken(JsonToken.StartObject);
                this._bsonReaderState = BsonReaderState.CodeWScopeStart;
                return;

            case BsonType.Integer:
                base.SetToken(JsonToken.Integer, (long)this.ReadInt32());
                return;

            case BsonType.TimeStamp:
            case BsonType.Long:
                base.SetToken(JsonToken.Integer, this.ReadInt64());
                return;

            default:
                throw new ArgumentOutOfRangeException("type", "Unexpected BsonType value: " + type);
            }
Label_019C:
            base.SetToken(JsonToken.Date, time2);
        }
        private bool ReadCodeWScope()
        {
            switch (_bsonReaderState)
            {
                case BsonReaderState.CodeWScopeStart:
                    SetToken(JsonToken.PropertyName, "$code");
                    _bsonReaderState = BsonReaderState.CodeWScopeCode;
                    return true;
                case BsonReaderState.CodeWScopeCode:
                    // total CodeWScope size - not used
                    ReadInt32();

                    SetToken(JsonToken.String, ReadLengthString());
                    _bsonReaderState = BsonReaderState.CodeWScopeScope;
                    return true;
                case BsonReaderState.CodeWScopeScope:
                    if (CurrentState == State.PostValue)
                    {
                        SetToken(JsonToken.PropertyName, "$scope");
                        return true;
                    }
                    else
                    {
                        SetToken(JsonToken.StartObject);
                        _bsonReaderState = BsonReaderState.CodeWScopeScopeObject;

                        ContainerContext newContext = new ContainerContext(BsonType.Object);
                        PushContext(newContext);
                        newContext.Length = ReadInt32();

                        return true;
                    }
                case BsonReaderState.CodeWScopeScopeObject:
                    bool result = ReadNormal();
                    if (result && TokenType == JsonToken.EndObject)
                        _bsonReaderState = BsonReaderState.CodeWScopeScopeEnd;

                    return result;
                case BsonReaderState.CodeWScopeScopeEnd:
                    SetToken(JsonToken.EndObject);
                    _bsonReaderState = BsonReaderState.Normal;
                    return true;
                default:
                    throw new ArgumentOutOfRangeException();
            }
        }
 /// <summary>
 /// Initializes a new instance of the BsonBaseReader class.
 /// </summary>
 protected BsonBaseReader() {
     state = BsonReaderState.Initial;
 }
        private void ReadType(BsonType type)
        {
            switch (type)
            {
                case BsonType.Number:
                    double d = ReadDouble();

                    if (_floatParseHandling == FloatParseHandling.Decimal)
                        SetToken(JsonToken.Float, Convert.ToDecimal(d, CultureInfo.InvariantCulture));
                    else
                        SetToken(JsonToken.Float, d);
                    break;
                case BsonType.String:
                case BsonType.Symbol:
                    SetToken(JsonToken.String, ReadLengthString());
                    break;
                case BsonType.Object:
                {
                    SetToken(JsonToken.StartObject);

                    ContainerContext newContext = new ContainerContext(BsonType.Object);
                    PushContext(newContext);
                    newContext.Length = ReadInt32();
                    break;
                }
                case BsonType.Array:
                {
                    SetToken(JsonToken.StartArray);

                    ContainerContext newContext = new ContainerContext(BsonType.Array);
                    PushContext(newContext);
                    newContext.Length = ReadInt32();
                    break;
                }
                case BsonType.Binary:
                    SetToken(JsonToken.Bytes, ReadBinary());
                    break;
                case BsonType.Undefined:
                    SetToken(JsonToken.Undefined);
                    break;
                case BsonType.Oid:
                    byte[] oid = ReadBytes(12);
                    SetToken(JsonToken.Bytes, oid);
                    break;
                case BsonType.Boolean:
                    bool b = Convert.ToBoolean(ReadByte());
                    SetToken(JsonToken.Boolean, b);
                    break;
                case BsonType.Date:
                    long ticks = ReadInt64();
                    DateTime utcDateTime = DateTimeUtils.ConvertJavaScriptTicksToDateTime(ticks);

                    DateTime dateTime;
                    switch (DateTimeKindHandling)
                    {
                        case DateTimeKind.Unspecified:
                            dateTime = DateTime.SpecifyKind(utcDateTime, DateTimeKind.Unspecified);
                            break;
                        case DateTimeKind.Local:
                            dateTime = utcDateTime.ToLocalTime();
                            break;
                        default:
                            dateTime = utcDateTime;
                            break;
                    }

                    SetToken(JsonToken.Date, dateTime);
                    break;
                case BsonType.Null:
                    SetToken(JsonToken.Null);
                    break;
                case BsonType.Regex:
                    string expression = ReadString();
                    string modifiers = ReadString();

                    string regex = @"/" + expression + @"/" + modifiers;
                    SetToken(JsonToken.String, regex);
                    break;
                case BsonType.Reference:
                    SetToken(JsonToken.StartObject);
                    _bsonReaderState = BsonReaderState.ReferenceStart;
                    break;
                case BsonType.Code:
                    SetToken(JsonToken.String, ReadLengthString());
                    break;
                case BsonType.CodeWScope:
                    SetToken(JsonToken.StartObject);
                    _bsonReaderState = BsonReaderState.CodeWScopeStart;
                    break;
                case BsonType.Integer:
                    SetToken(JsonToken.Integer, (long)ReadInt32());
                    break;
                case BsonType.TimeStamp:
                case BsonType.Long:
                    SetToken(JsonToken.Integer, ReadInt64());
                    break;
                default:
                    throw new ArgumentOutOfRangeException("type", "Unexpected BsonType value: " + type);
            }
        }
 // constructors
 /// <summary>
 /// Initializes a new instance of the BsonReaderBookmark class.
 /// </summary>
 /// <param name="state">The state of the reader.</param>
 /// <param name="currentBsonType">The current BSON type.</param>
 /// <param name="currentName">The name of the current element.</param>
 protected BsonReaderBookmark(BsonReaderState state, BsonType currentBsonType, string currentName)
 {
     _state           = state;
     _currentBsonType = currentBsonType;
     _currentName     = currentName;
 }