Beispiel #1
0
        private void WriteTokenInternal(BsonToken t)
        {
            switch (t.Type)
            {
            case BsonType.Object:
            {
                BsonObject value = (BsonObject)t;
                this._writer.Write(value.CalculatedSize);
                foreach (BsonProperty property in value)
                {
                    this._writer.Write((sbyte)property.Value.Type);
                    this.WriteString((string)property.Name.Value, property.Name.ByteCount, null);
                    this.WriteTokenInternal(property.Value);
                }
                this._writer.Write((byte)0);
            }
            break;

            case BsonType.Array:
            {
                BsonArray value = (BsonArray)t;
                this._writer.Write(value.CalculatedSize);
                int index = 0;
                foreach (BsonToken c in value)
                {
                    this._writer.Write((sbyte)c.Type);
                    this.WriteString(index.ToString(CultureInfo.InvariantCulture), MathUtils.IntLength(index), null);
                    this.WriteTokenInternal(c);
                    index++;
                }
                this._writer.Write((byte)0);
            }
            break;

            case BsonType.Integer:
            {
                BsonValue value = (BsonValue)t;
                this._writer.Write(Convert.ToInt32(value.Value, CultureInfo.InvariantCulture));
            }
            break;

            case BsonType.Long:
            {
                BsonValue value = (BsonValue)t;
                this._writer.Write(Convert.ToInt64(value.Value, CultureInfo.InvariantCulture));
            }
            break;

            case BsonType.Number:
            {
                BsonValue value = (BsonValue)t;
                this._writer.Write(Convert.ToDouble(value.Value, CultureInfo.InvariantCulture));
            }
            break;

            case BsonType.String:
            {
                BsonString value = (BsonString)t;
                this.WriteString((string)value.Value, value.ByteCount, value.CalculatedSize - 4);
            }
            break;

            case BsonType.Boolean:
            {
                BsonValue value = (BsonValue)t;
                this._writer.Write((bool)value.Value);
            }
            break;

            case BsonType.Null:
            case BsonType.Undefined:
                break;

            case BsonType.Date:
            {
                BsonValue value = (BsonValue)t;

                long ticks = 0;

                if (value.Value is DateTime)
                {
                    DateTime dateTime = (DateTime)value.Value;
                    if (this.DateTimeKindHandling == DateTimeKind.Utc)
                    {
                        dateTime = dateTime.ToUniversalTime();
                    }
                    else if (this.DateTimeKindHandling == DateTimeKind.Local)
                    {
                        dateTime = dateTime.ToLocalTime();
                    }

                    ticks = JsonConvert.ConvertDateTimeToJavaScriptTicks(dateTime, false);
                }
                        #if !PocketPC && !NET20
                else
                {
                    DateTimeOffset dateTimeOffset = (DateTimeOffset)value.Value;
                    ticks = JsonConvert.ConvertDateTimeToJavaScriptTicks(dateTimeOffset.UtcDateTime, dateTimeOffset.Offset);
                }
                        #endif

                this._writer.Write(ticks);
            }
            break;

            case BsonType.Binary:
            {
                BsonValue value = (BsonValue)t;

                byte[] data = (byte[])value.Value;
                this._writer.Write(data.Length);
                this._writer.Write((byte)BsonBinaryType.Binary);
                this._writer.Write(data);
            }
            break;

            case BsonType.Oid:
            {
                BsonValue value = (BsonValue)t;

                byte[] data = (byte[])value.Value;
                this._writer.Write(data);
            }
            break;

            case BsonType.Regex:
            {
                BsonRegex value = (BsonRegex)t;

                this.WriteString((string)value.Pattern.Value, value.Pattern.ByteCount, null);
                this.WriteString((string)value.Options.Value, value.Options.ByteCount, null);
            }
            break;

            default:
                throw new ArgumentOutOfRangeException("t", "Unexpected token when writing BSON: {0}".FormatWith(CultureInfo.InvariantCulture, t.Type));
            }
        }
Beispiel #2
0
        private int CalculateSize(BsonToken t)
        {
            switch (t.Type)
            {
            case BsonType.Object:
            {
                BsonObject value = (BsonObject)t;

                int bases = 4;
                foreach (BsonProperty p in value)
                {
                    int size = 1;
                    size += this.CalculateSize(p.Name);
                    size += this.CalculateSize(p.Value);

                    bases += size;
                }
                bases += 1;
                value.CalculatedSize = bases;
                return(bases);
            }

            case BsonType.Array:
            {
                BsonArray value = (BsonArray)t;

                int size  = 4;
                int index = 0;
                foreach (BsonToken c in value)
                {
                    size += 1;
                    size += this.CalculateSize(MathUtils.IntLength(index));
                    size += this.CalculateSize(c);
                    index++;
                }
                size += 1;
                value.CalculatedSize = size;

                return(value.CalculatedSize);
            }

            case BsonType.Integer:
                return(4);

            case BsonType.Long:
                return(8);

            case BsonType.Number:
                return(8);

            case BsonType.String:
            {
                BsonString value = (BsonString)t;
                string     s     = (string)value.Value;
                value.ByteCount      = (s != null) ? Encoding.GetByteCount(s) : 0;
                value.CalculatedSize = this.CalculateSizeWithLength(value.ByteCount, value.IncludeLength);

                return(value.CalculatedSize);
            }

            case BsonType.Boolean:
                return(1);

            case BsonType.Null:
            case BsonType.Undefined:
                return(0);

            case BsonType.Date:
                return(8);

            case BsonType.Binary:
            {
                BsonValue value = (BsonValue)t;

                byte[] data = (byte[])value.Value;
                value.CalculatedSize = 4 + 1 + data.Length;

                return(value.CalculatedSize);
            }

            case BsonType.Oid:
                return(12);

            case BsonType.Regex:
            {
                BsonRegex value = (BsonRegex)t;
                int       size  = 0;
                size += this.CalculateSize(value.Pattern);
                size += this.CalculateSize(value.Options);
                value.CalculatedSize = size;

                return(value.CalculatedSize);
            }

            default:
                throw new ArgumentOutOfRangeException("t", "Unexpected token when writing BSON: {0}".FormatWith(CultureInfo.InvariantCulture, t.Type));
            }
        }