public override Voucher Deserialize(IBsonReader bsonReader) { string read = null; bsonReader.ReadStartDocument(); var voucher = new Voucher { ID = bsonReader.ReadObjectId("_id", ref read), Date = bsonReader.ReadDateTime("date", ref read), Type = VoucherType.Ordinary, }; voucher.Type = bsonReader.ReadString("special", ref read) switch { "amorz" => VoucherType.Amortization, "acarry" => VoucherType.AnnualCarry, "carry" => VoucherType.Carry, "dep" => VoucherType.Depreciation, "dev" => VoucherType.Devalue, "unc" => VoucherType.Uncertain, _ => VoucherType.Ordinary, }; voucher.Details = bsonReader.ReadArray("detail", ref read, new VoucherDetailSerializer().Deserialize); voucher.Remark = bsonReader.ReadString("remark", ref read); bsonReader.ReadEndDocument(); return(voucher); }
public override Amortization Deserialize(IBsonReader bsonReader) { string read = null; bsonReader.ReadStartDocument(); var amort = new Amortization { ID = bsonReader.ReadGuid("_id", ref read), User = bsonReader.ReadString("user", ref read), Name = bsonReader.ReadString("name", ref read), Value = bsonReader.ReadDouble("value", ref read), Date = bsonReader.ReadDateTime("date", ref read), TotalDays = bsonReader.ReadInt32("tday", ref read), }; amort.Interval = bsonReader.ReadString("interval", ref read) switch { "d" => AmortizeInterval.EveryDay, "w" => AmortizeInterval.SameDayOfWeek, "W" => AmortizeInterval.LastDayOfWeek, "m" => AmortizeInterval.SameDayOfMonth, "M" => AmortizeInterval.LastDayOfMonth, "y" => AmortizeInterval.SameDayOfYear, "Y" => AmortizeInterval.LastDayOfYear, _ => amort.Interval, }; amort.Template = bsonReader.ReadDocument("template", ref read, VoucherSerializer.Deserialize); amort.Schedule = bsonReader.ReadArray("schedule", ref read, ItemSerializer.Deserialize); amort.Remark = bsonReader.ReadString("remark", ref read); bsonReader.ReadEndDocument(); return(amort); }
// private methods private CollectionNamespace DeserializeCollectionNamespace(IBsonReader reader) { string collectionName = null; string databaseName = null; reader.ReadStartDocument(); while (reader.ReadBsonType() != 0) { var fieldName = reader.ReadName(); switch (fieldName) { case "db": databaseName = reader.ReadString(); break; case "coll": collectionName = reader.ReadString(); break; default: throw new FormatException($"Invalid field name: \"{fieldName}\"."); } } reader.ReadEndDocument(); var databaseNamespace = new DatabaseNamespace(databaseName); return(new CollectionNamespace(databaseNamespace, collectionName)); }
public override Asset Deserialize(IBsonReader bsonReader) { string read = null; bsonReader.ReadStartDocument(); var asset = new Asset { ID = bsonReader.ReadGuid("_id", ref read), User = bsonReader.ReadString("user", ref read), Name = bsonReader.ReadString("name", ref read), Date = bsonReader.ReadDateTime("date", ref read), Currency = bsonReader.ReadString("currency", ref read), Value = bsonReader.ReadDouble("value", ref read), Salvge = bsonReader.ReadDouble("salvge", ref read), Life = bsonReader.ReadInt32("life", ref read), Title = bsonReader.ReadInt32("title", ref read), DepreciationTitle = bsonReader.ReadInt32("deptitle", ref read), DevaluationTitle = bsonReader.ReadInt32("devtitle", ref read), DepreciationExpenseTitle = bsonReader.ReadInt32("exptitle", ref read), DevaluationExpenseTitle = bsonReader.ReadInt32("exvtitle", ref read) }; switch (bsonReader.ReadString("method", ref read)) { case "sl": asset.Method = DepreciationMethod.StraightLine; break; case "sy": asset.Method = DepreciationMethod.SumOfTheYear; break; case "dd": asset.Method = DepreciationMethod.DoubleDeclineMethod; break; default: asset.Method = DepreciationMethod.None; break; } if (asset.DepreciationExpenseTitle > 100) { asset.DepreciationExpenseSubTitle = asset.DepreciationExpenseTitle % 100; asset.DepreciationExpenseTitle /= 100; } if (asset.DevaluationExpenseTitle > 100) { asset.DevaluationExpenseSubTitle = asset.DevaluationExpenseTitle % 100; asset.DevaluationExpenseTitle /= 100; } asset.Schedule = bsonReader.ReadArray("schedule", ref read, ItemSerializer.Deserialize); asset.Remark = bsonReader.ReadString("remark", ref read); bsonReader.ReadEndDocument(); return(asset); }
/// <summary> /// Deserializes an object from a binary source. /// </summary> /// <param name="Reader">Binary deserializer.</param> /// <param name="DataType">Optional datatype. If not provided, will be read from the binary source.</param> /// <param name="Embedded">If the object is embedded into another.</param> /// <returns>Deserialized object.</returns> public override object Deserialize(IBsonReader Reader, BsonType?DataType, bool Embedded) { if (!DataType.HasValue) { DataType = Reader.ReadBsonType(); } switch (DataType.Value) { case BsonType.DateTime: return((DateTimeOffset?)ObjectSerializer.UnixEpoch.AddMilliseconds(Reader.ReadDateTime())); case BsonType.String: return((DateTimeOffset?)DateTimeOffset.Parse(Reader.ReadString())); case BsonType.Document: DateTime TP = DateTime.MinValue; TimeSpan TZ = TimeSpan.Zero; Reader.ReadStartDocument(); while (Reader.State == BsonReaderState.Type) { BsonType BsonType = Reader.ReadBsonType(); if (BsonType == BsonType.EndOfDocument) { break; } string FieldName = Reader.ReadName(); switch (FieldName) { case "tp": TP = ObjectSerializer.UnixEpoch.AddMilliseconds(Reader.ReadDateTime()); break; case "tz": TZ = TimeSpan.Parse(Reader.ReadString()); break; } } Reader.ReadEndDocument(); return((DateTimeOffset?)new DateTimeOffset(TP, TZ)); case BsonType.MinKey: Reader.ReadMinKey(); return((DateTimeOffset?)DateTimeOffset.MinValue); case BsonType.MaxKey: Reader.ReadMaxKey(); return((DateTimeOffset?)DateTimeOffset.MaxValue); case BsonType.Null: Reader.ReadNull(); return(null); default: throw new Exception("Expected a nullable DateTimeOffset value."); } }
public override Amortization Deserialize(IBsonReader bsonReader) { string read = null; bsonReader.ReadStartDocument(); var amort = new Amortization { ID = bsonReader.ReadGuid("_id", ref read), User = bsonReader.ReadString("user", ref read), Name = bsonReader.ReadString("name", ref read), Value = bsonReader.ReadDouble("value", ref read), Date = bsonReader.ReadDateTime("date", ref read), TotalDays = bsonReader.ReadInt32("tday", ref read) }; switch (bsonReader.ReadString("interval", ref read)) { case "d": amort.Interval = AmortizeInterval.EveryDay; break; case "w": amort.Interval = AmortizeInterval.SameDayOfWeek; break; case "W": amort.Interval = AmortizeInterval.LastDayOfWeek; break; case "m": amort.Interval = AmortizeInterval.SameDayOfMonth; break; case "M": amort.Interval = AmortizeInterval.LastDayOfMonth; break; case "y": amort.Interval = AmortizeInterval.SameDayOfYear; break; case "Y": amort.Interval = AmortizeInterval.LastDayOfYear; break; } amort.Template = bsonReader.ReadDocument("template", ref read, VoucherSerializer.Deserialize); amort.Schedule = bsonReader.ReadArray("schedule", ref read, ItemSerializer.Deserialize); amort.Remark = bsonReader.ReadString("remark", ref read); bsonReader.ReadEndDocument(); return(amort); }
public override Voucher Deserialize(IBsonReader bsonReader) { string read = null; bsonReader.ReadStartDocument(); var voucher = new Voucher { ID = bsonReader.ReadObjectId("_id", ref read), Date = bsonReader.ReadDateTime("date", ref read), Type = VoucherType.Ordinary }; switch (bsonReader.ReadString("special", ref read)) { case "amorz": voucher.Type = VoucherType.Amortization; break; case "acarry": voucher.Type = VoucherType.AnnualCarry; break; case "carry": voucher.Type = VoucherType.Carry; break; case "dep": voucher.Type = VoucherType.Depreciation; break; case "dev": voucher.Type = VoucherType.Devalue; break; case "unc": voucher.Type = VoucherType.Uncertain; break; default: voucher.Type = VoucherType.Ordinary; break; } voucher.Details = bsonReader.ReadArray("detail", ref read, new VoucherDetailSerializer().Deserialize); voucher.Remark = bsonReader.ReadString("remark", ref read); bsonReader.ReadEndDocument(); return(voucher); }
/// <summary> /// Reads a date & time value with offset. /// </summary> /// <param name="Reader">Binary reader.</param> /// <param name="FieldDataType">Field data type.</param> /// <returns>DateTimeOffset value.</returns> /// <exception cref="ArgumentException">If the <paramref name="FieldDataType"/> was invalid.</exception> public static DateTimeOffset ReadDateTimeOffset(IBsonReader Reader, BsonType FieldDataType) { switch (FieldDataType) { case BsonType.DateTime: return((DateTimeOffset)ObjectSerializer.UnixEpoch.AddMilliseconds(Reader.ReadDateTime())); case BsonType.String: return(DateTimeOffset.Parse(Reader.ReadString())); case BsonType.Document: DateTime TP = DateTime.MinValue; TimeSpan TZ = TimeSpan.Zero; Reader.ReadStartDocument(); while (Reader.State == BsonReaderState.Type) { BsonType BsonType = Reader.ReadBsonType(); if (BsonType == BsonType.EndOfDocument) { break; } string FieldName = Reader.ReadName(); switch (FieldName) { case "tp": TP = ObjectSerializer.UnixEpoch.AddMilliseconds(Reader.ReadDateTime()); break; case "tz": TZ = TimeSpan.Parse(Reader.ReadString()); break; } } Reader.ReadEndDocument(); return(new DateTimeOffset(TP, TZ)); case BsonType.MinKey: Reader.ReadMinKey(); return(DateTimeOffset.MinValue); case BsonType.MaxKey: Reader.ReadMaxKey(); return(DateTimeOffset.MaxValue); default: throw new ArgumentException("Expected a date & time value with offset, but was a " + FieldDataType.ToString() + ".", nameof(FieldDataType)); } }
/// <summary> /// Reads a char value. /// </summary> /// <param name="Reader">Binary reader.</param> /// <param name="FieldDataType">Field data type.</param> /// <returns>Char value.</returns> /// <exception cref="ArgumentException">If the <paramref name="FieldDataType"/> was invalid.</exception> public static char ReadChar(IBsonReader Reader, BsonType FieldDataType) { switch (FieldDataType) { case BsonType.Decimal128: return((char)Reader.ReadDecimal128()); case BsonType.Double: return((char)Reader.ReadDouble()); case BsonType.Int32: return((char)Reader.ReadInt32()); case BsonType.Int64: return((char)Reader.ReadInt64()); case BsonType.MinKey: Reader.ReadMinKey(); return(char.MinValue); case BsonType.MaxKey: Reader.ReadMaxKey(); return(char.MaxValue); case BsonType.String: string s = Reader.ReadString(); return(string.IsNullOrEmpty(s) ? (char)0 : s[0]); default: throw new ArgumentException("Expected a char value, but was a " + FieldDataType.ToString() + ".", nameof(FieldDataType)); } }
/// <summary> /// Reads a single value. /// </summary> /// <param name="Reader">Binary reader.</param> /// <param name="FieldDataType">Field data type.</param> /// <returns>Single value.</returns> /// <exception cref="ArgumentException">If the <paramref name="FieldDataType"/> was invalid.</exception> public static float ReadSingle(IBsonReader Reader, BsonType FieldDataType) { switch (FieldDataType) { case BsonType.Boolean: return(Reader.ReadBoolean() ? (float)1 : (float)0); case BsonType.Decimal128: return((float)Reader.ReadDecimal128()); case BsonType.Double: return((float)Reader.ReadDouble()); case BsonType.Int32: return((float)Reader.ReadInt32()); case BsonType.Int64: return((float)Reader.ReadInt64()); case BsonType.String: return(float.Parse(Reader.ReadString())); case BsonType.MinKey: Reader.ReadMinKey(); return(float.MinValue); case BsonType.MaxKey: Reader.ReadMaxKey(); return(float.MaxValue); default: throw new ArgumentException("Expected a single value, but was a " + FieldDataType.ToString() + ".", nameof(FieldDataType)); } }
/// <summary> /// Reads a 64-bit unsigned integer value. /// </summary> /// <param name="Reader">Binary reader.</param> /// <param name="FieldDataType">Field data type.</param> /// <returns>64-bit unsigned integer value.</returns> /// <exception cref="ArgumentException">If the <paramref name="FieldDataType"/> was invalid.</exception> public static ulong ReadUInt64(IBsonReader Reader, BsonType FieldDataType) { switch (FieldDataType) { case BsonType.Boolean: return(Reader.ReadBoolean() ? (ulong)1 : (ulong)0); case BsonType.Decimal128: return((ulong)Reader.ReadDecimal128()); case BsonType.Double: return((ulong)Reader.ReadDouble()); case BsonType.Int32: return((ulong)Reader.ReadInt32()); case BsonType.Int64: return((ulong)Reader.ReadInt64()); case BsonType.String: return(ulong.Parse(Reader.ReadString())); case BsonType.MinKey: Reader.ReadMinKey(); return(ulong.MinValue); case BsonType.MaxKey: Reader.ReadMaxKey(); return(ulong.MaxValue); default: throw new ArgumentException("Expected a 64-bit unsigned integer value, but was a " + FieldDataType.ToString() + ".", nameof(FieldDataType)); } }
/***************************************************/ public override object Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args) { IBsonReader reader = context.Reader; BsonType currentBsonType = reader.GetCurrentBsonType(); switch (currentBsonType) { case BsonType.Array: if (context.DynamicArraySerializer != null) { return(context.DynamicArraySerializer.Deserialize(context)); } break; case BsonType.Binary: { BsonBinaryData bsonBinaryData = reader.ReadBinaryData(); BsonBinarySubType subType = bsonBinaryData.SubType; if (subType == BsonBinarySubType.UuidStandard || subType == BsonBinarySubType.UuidLegacy) { return(bsonBinaryData.ToGuid()); } break; } case BsonType.Boolean: return(reader.ReadBoolean()); case BsonType.DateTime: return(new BsonDateTime(reader.ReadDateTime()).ToUniversalTime()); case BsonType.Decimal128: return(reader.ReadDecimal128()); case BsonType.Document: return(DeserializeDiscriminatedValue(context, args)); case BsonType.Double: return(reader.ReadDouble()); case BsonType.Int32: return(reader.ReadInt32()); case BsonType.Int64: return(reader.ReadInt64()); case BsonType.Null: reader.ReadNull(); return(null); case BsonType.ObjectId: return(reader.ReadObjectId()); case BsonType.String: return(reader.ReadString()); } Engine.Reflection.Compute.RecordError($"ObjectSerializer does not support BSON type '{currentBsonType}'."); return(null); }
public Type GetActualType(IBsonReader bsonReader, Type nominalType) { if (!typeof(T).IsAssignableFrom(nominalType)) { throw new Exception($"Cannot use DiscriminatorConvention<{typeof(T).Name}> for type " + nominalType); } var ret = nominalType; var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); if (bsonReader.FindElement(ElementName)) { var value = bsonReader.ReadString(); ret = Type.GetType(value); if (ret == null) { throw new Exception("Could not find type from " + value); } if (!typeof(T).IsAssignableFrom(ret) && !ret.IsSubclassOf(typeof(T))) { throw new Exception("type is not an IRestriction"); } } bsonReader.ReturnToBookmark(bookmark); return(ret); }
public Type GetActualType(IBsonReader bsonReader, Type nominalType) { if (nominalType == typeof(OrderModel)) { var ret = nominalType; var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); if (bsonReader.FindElement(orderType)) { var value = bsonReader.ReadString(); ret = OrderTypeResolver.ResolveOrderType(value); if (ret == null) { throw new Exception("Could not find type " + value); } if (!ret.IsSubclassOf(typeof(OrderModel))) { throw new Exception("Database type does not inherit from OrderModel."); } } bsonReader.ReturnToBookmark(bookmark); return(ret); } else { return(nominalType); } }
public Type GetActualType(IBsonReader bsonReader, Type nominalType) { if (nominalType == typeof(JobTask)) { var ret = nominalType; var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); if (bsonReader.FindElement(ElementName)) { var value = bsonReader.ReadString(); ret = Type.GetType(value); if (ret == null) throw new Exception("Could not find type " + value); if (!ret.IsSubclassOf(typeof(JobTask))) throw new Exception("Database type does not inherit from JobTask."); } bsonReader.ReturnToBookmark(bookmark); return ret; } else { return nominalType; } }
static object ReadObject(IBsonReader bsonReader) //_120509_173140 keep consistent { switch (bsonReader.GetCurrentBsonType()) { case BsonType.Array: return(ReadArray(bsonReader)); // replacement case BsonType.Binary: var binary = BsonSerializer.Deserialize <BsonValue>(bsonReader); return(BsonTypeMapper.MapToDotNetValue(binary) ?? binary); // byte[] or Guid else self case BsonType.Boolean: return(bsonReader.ReadBoolean()); case BsonType.DateTime: return(BsonUtils.ToDateTimeFromMillisecondsSinceEpoch(bsonReader.ReadDateTime())); case BsonType.Document: return(ReadCustomObject(bsonReader)); // replacement case BsonType.Double: return(bsonReader.ReadDouble()); case BsonType.Int32: return(bsonReader.ReadInt32()); case BsonType.Int64: return(bsonReader.ReadInt64()); case BsonType.Null: bsonReader.ReadNull(); return(null); case BsonType.ObjectId: return(bsonReader.ReadObjectId()); case BsonType.String: return(bsonReader.ReadString()); default: return(BsonSerializer.Deserialize <BsonValue>(bsonReader)); } }
/// <summary> /// Deserializes an object from a binary source. /// </summary> /// <param name="Reader">Binary deserializer.</param> /// <param name="DataType">Optional datatype. If not provided, will be read from the binary source.</param> /// <param name="Embedded">If the object is embedded into another.</param> /// <returns>Deserialized object.</returns> public override object Deserialize(IBsonReader Reader, BsonType?DataType, bool Embedded) { if (!DataType.HasValue) { DataType = Reader.ReadBsonType(); } switch (DataType.Value) { case BsonType.Decimal128: return((char?)Reader.ReadDecimal128()); case BsonType.Double: return((char?)Reader.ReadDouble()); case BsonType.Int32: return((char?)Reader.ReadInt32()); case BsonType.Int64: return((char?)Reader.ReadInt64()); case BsonType.MinKey: Reader.ReadMinKey(); return((char?)char.MinValue); case BsonType.MaxKey: Reader.ReadMaxKey(); return((char?)char.MaxValue); case BsonType.Null: Reader.ReadNull(); return(null); case BsonType.String: string s = Reader.ReadString(); return((char?)(string.IsNullOrEmpty(s) ? (char?)0 : s[0])); default: throw new Exception("Expected a nullable char value."); } }
/// <summary> /// Deserializes an object from a binary source. /// </summary> /// <param name="Reader">Binary deserializer.</param> /// <param name="DataType">Optional datatype. If not provided, will be read from the binary source.</param> /// <param name="Embedded">If the object is embedded into another.</param> /// <returns>Deserialized object.</returns> public override object Deserialize(IBsonReader Reader, BsonType?DataType, bool Embedded) { if (!DataType.HasValue) { DataType = Reader.ReadBsonType(); } switch (DataType.Value) { case BsonType.Boolean: return(Reader.ReadBoolean() ? (byte?)1 : (byte?)0); case BsonType.Decimal128: return((byte?)Reader.ReadDecimal128()); case BsonType.Double: return((byte?)Reader.ReadDouble()); case BsonType.Int32: return((byte?)Reader.ReadInt32()); case BsonType.Int64: return((byte?)Reader.ReadInt64()); case BsonType.String: return((byte?)byte.Parse(Reader.ReadString())); case BsonType.MinKey: Reader.ReadMinKey(); return((byte?)byte.MinValue); case BsonType.MaxKey: Reader.ReadMaxKey(); return((byte?)byte.MaxValue); case BsonType.Null: Reader.ReadNull(); return(null); default: throw new Exception("Expected a nullable byte value."); } }
public override bool Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args) { IBsonReader bsonReader = context.Reader; BsonType bsonType = bsonReader.GetCurrentBsonType(); if (bsonType == BsonType.String) { string value = bsonReader.ReadString().ToLower(); if (value == "") { return(false); } return(JsonConvert.ToBoolean(bsonReader.ReadString().ToLower())); } return(base.Deserialize(context, args)); }
/// <summary> /// Deserializes an object from a binary source. /// </summary> /// <param name="Reader">Binary deserializer.</param> /// <param name="DataType">Optional datatype. If not provided, will be read from the binary source.</param> /// <param name="Embedded">If the object is embedded into another.</param> /// <returns>Deserialized object.</returns> public override object Deserialize(IBsonReader Reader, BsonType?DataType, bool Embedded) { if (!DataType.HasValue) { DataType = Reader.ReadBsonType(); } switch (DataType.Value) { case BsonType.Boolean: return(this.ToNullable(Enum.ToObject(this.enumType, Reader.ReadBoolean() ? 1 : 0))); case BsonType.Decimal128: return(this.ToNullable(Enum.ToObject(this.enumType, (int)Reader.ReadDecimal128()))); case BsonType.Double: return(this.ToNullable(Enum.ToObject(this.enumType, Reader.ReadDouble()))); case BsonType.Int32: return(this.ToNullable(Enum.ToObject(this.enumType, Reader.ReadInt32()))); case BsonType.Int64: return(this.ToNullable(Enum.ToObject(this.enumType, Reader.ReadInt64()))); case BsonType.String: return(this.ToNullable(Enum.Parse(this.enumType, Reader.ReadString()))); case BsonType.Null: Reader.ReadNull(); return(null); default: throw new Exception("Expected an enum value."); } }
/// <summary> /// Reads a string value. /// </summary> /// <param name="Reader">Binary reader.</param> /// <param name="FieldDataType">Field data type.</param> /// <returns>String value.</returns> /// <exception cref="ArgumentException">If the <paramref name="FieldDataType"/> was invalid.</exception> public static string ReadString(IBsonReader Reader, BsonType FieldDataType) { switch (FieldDataType) { case BsonType.Boolean: return(Reader.ReadBoolean().ToString()); case BsonType.DateTime: return(ObjectSerializer.UnixEpoch.AddMilliseconds(Reader.ReadDateTime()).ToString()); case BsonType.Decimal128: return(Reader.ReadDecimal128().ToString()); case BsonType.Double: return(Reader.ReadDouble().ToString()); case BsonType.Int32: return(Reader.ReadInt32().ToString()); case BsonType.Int64: return(Reader.ReadInt64().ToString()); case BsonType.JavaScript: return(Reader.ReadJavaScript()); case BsonType.JavaScriptWithScope: return(Reader.ReadJavaScriptWithScope()); case BsonType.Null: Reader.ReadNull(); return(null); case BsonType.ObjectId: return(Reader.ReadObjectId().ToString()); case BsonType.String: return(Reader.ReadString()); case BsonType.Symbol: return(Reader.ReadSymbol()); default: throw new ArgumentException("Expected a char value, but was a " + FieldDataType.ToString() + ".", nameof(FieldDataType)); } }
/// <summary> /// Positions the reader to a string element by name. /// </summary> /// <param name="reader">The reader.</param> /// <param name="name">The name of the element.</param> /// <returns>True if the element was found.</returns> public static string FindStringElement(this IBsonReader reader, string name) { BsonType bsonType; while ((bsonType = reader.ReadBsonType()) != BsonType.EndOfDocument) { if (bsonType == BsonType.String) { var elementName = reader.ReadName(); if (elementName == name) { return(reader.ReadString()); } else { reader.SkipValue(); } } else { reader.SkipName(); reader.SkipValue(); } } return(null); }
object GetDeserializedValue(Type valueType, ref IBsonReader bsonReader) { var bsonType = bsonReader.CurrentBsonType; if (bsonType == BsonType.Null) { bsonReader.ReadNull(); return(null); } if (valueType == typeof(Guid)) { var binaryData = bsonReader.ReadBinaryData(); return(binaryData.ToGuid()); } else if (valueType == typeof(double)) { return(bsonReader.ReadDouble()); } else if (valueType == typeof(float)) { return((float)bsonReader.ReadDouble()); } else if (valueType == typeof(int)) { return(bsonReader.ReadInt32()); } else if (valueType == typeof(long)) { return(bsonReader.ReadInt64()); } else if (valueType == typeof(bool)) { return(bsonReader.ReadBoolean()); } else if (valueType == typeof(string)) { return(bsonReader.ReadString()); } else if (valueType == typeof(decimal)) { return(decimal.Parse(bsonReader.ReadString(), CultureInfo.InvariantCulture)); } throw new FailedConceptSerialization($"Could not deserialize the concept value to '{valueType.FullName}'"); }
object GetDeserializedValue(Type valueType, ref IBsonReader bsonReader) { var bsonType = bsonReader.CurrentBsonType; if (bsonType == BsonType.Null) { bsonReader.ReadNull(); return(null); } if (valueType == typeof(Guid)) { var binaryData = bsonReader.ReadBinaryData(); return(binaryData.ToGuid()); } else if (valueType == typeof(double)) { return(bsonReader.ReadDouble()); } else if (valueType == typeof(float)) { return((float)bsonReader.ReadDouble()); } else if (valueType == typeof(Int32)) { return(bsonReader.ReadInt32()); } else if (valueType == typeof(Int64)) { return(bsonReader.ReadInt64()); } else if (valueType == typeof(bool)) { return(bsonReader.ReadBoolean()); } else if (valueType == typeof(string)) { return(bsonReader.ReadString()); } else if (valueType == typeof(decimal)) { return(decimal.Parse(bsonReader.ReadString())); } throw new Exception(); }
public override VoucherDetail Deserialize(IBsonReader bsonReader) { string read = null; bsonReader.ReadStartDocument(); var detail = new VoucherDetail { Currency = bsonReader.ReadString("currency", ref read), Title = bsonReader.ReadInt32("title", ref read), SubTitle = bsonReader.ReadInt32("subtitle", ref read), Content = bsonReader.ReadString("content", ref read), Fund = bsonReader.ReadDouble("fund", ref read), Remark = bsonReader.ReadString("remark", ref read) }; bsonReader.ReadEndDocument(); return(detail); }
private JToken GenerateJToken(IBsonReader reader, JToken parent) { switch (reader.CurrentBsonType) { case BsonType.Symbol: case BsonType.JavaScriptWithScope: case BsonType.JavaScript: case BsonType.ObjectId: case BsonType.RegularExpression: case BsonType.DateTime: case BsonType.Decimal128: case BsonType.MinKey: case BsonType.MaxKey: case BsonType.String: return(reader.ReadString()); case BsonType.Binary: return(reader.ReadBytes()); case BsonType.Undefined: reader.ReadUndefined(); return(JValue.CreateUndefined()); case BsonType.Boolean: return(reader.ReadBoolean()); case BsonType.Null: reader.ReadNull(); return(JValue.CreateNull()); case BsonType.Int32: return(reader.ReadInt32()); case BsonType.Int64: case BsonType.Timestamp: return(reader.ReadInt64()); case BsonType.Double: return(reader.ReadDouble()); case BsonType.Document: return(GenerateJObject(reader, parent)); case BsonType.Array: return(GenerateJArray(reader, parent)); case BsonType.EndOfDocument: break; default: break; } return(null); }
/// <summary> /// Reads a GUID value. /// </summary> /// <param name="Reader">Binary reader.</param> /// <param name="FieldDataType">Field data type.</param> /// <returns>Guid value.</returns> /// <exception cref="ArgumentException">If the <paramref name="FieldDataType"/> was invalid.</exception> public static Guid ReadGuid(IBsonReader Reader, BsonType FieldDataType) { switch (FieldDataType) { case BsonType.String: return(Guid.Parse(Reader.ReadString())); default: throw new ArgumentException("Expected a GUID value, but was a " + FieldDataType.ToString() + ".", nameof(FieldDataType)); } }
public void TestStringEmpty() { var json = "\"\""; using (_bsonReader = new JsonReader(json)) { Assert.AreEqual(BsonType.String, _bsonReader.ReadBsonType()); Assert.AreEqual("", _bsonReader.ReadString()); Assert.AreEqual(BsonReaderState.Done, _bsonReader.State); } Assert.AreEqual(json, BsonSerializer.Deserialize <string>(json).ToJson()); }
public void TestString() { var json = "\"abc\""; using (_bsonReader = new JsonReader(json)) { Assert.Equal(BsonType.String, _bsonReader.ReadBsonType()); Assert.Equal("abc", _bsonReader.ReadString()); Assert.Equal(BsonReaderState.Initial, _bsonReader.State); } Assert.Equal(json, BsonSerializer.Deserialize <string>(json).ToJson()); }
public Type GetActualType(IBsonReader bsonReader, Type nominalType) { var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); string typeValue = string.Empty; if (bsonReader.FindElement(ElementName)) typeValue = bsonReader.ReadString(); else throw new NotSupportedException(); bsonReader.ReturnToBookmark(bookmark); var retr = Type.GetType(typeValue) ?? Type.GetType("ThreeOneThree.Proxima.Core.Entities." + typeValue); return retr; }
/// <summary> /// Reads a time span value. /// </summary> /// <param name="Reader">Binary reader.</param> /// <param name="FieldDataType">Field data type.</param> /// <returns>TimeSpan value.</returns> /// <exception cref="ArgumentException">If the <paramref name="FieldDataType"/> was invalid.</exception> public static TimeSpan ReadTimeSpan(IBsonReader Reader, BsonType FieldDataType) { switch (FieldDataType) { case BsonType.String: return(TimeSpan.Parse(Reader.ReadString())); case BsonType.MinKey: Reader.ReadMinKey(); return(TimeSpan.MinValue); case BsonType.MaxKey: Reader.ReadMaxKey(); return(TimeSpan.MaxValue); default: throw new ArgumentException("Expected a time span value, but was a " + FieldDataType.ToString() + ".", nameof(FieldDataType)); } }
public Type GetActualType(IBsonReader bsonReader, Type nominalType) { var bookmark = bsonReader.GetBookmark(); bsonReader.ReadStartDocument(); var t = nominalType; if (bsonReader.FindElement(ElementName)) { var raw = bsonReader.ReadString(); var discriminator = _discriminatorMapper.Discriminator(raw); t = _discriminatorMapper.ConcreteType(discriminator); } bsonReader.ReturnToBookmark(bookmark); return(t); }
public void TestStringEmpty() { var json = "\"\""; using (_bsonReader = new JsonReader(json)) { Assert.Equal(BsonType.String, _bsonReader.ReadBsonType()); Assert.Equal("", _bsonReader.ReadString()); Assert.Equal(BsonReaderState.Initial, _bsonReader.State); } Assert.Equal(json, BsonSerializer.Deserialize<string>(json).ToJson()); }