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());
}
