public void DeserializeFromBSON(BSONSerializer serializer, BSONDocument doc, ref object context)
{
m_Guid = doc.TryGetObjectValueOf(serializer.PKFieldName).AsGUID(Guid.Empty);
m_RelatedTo = doc.TryGetObjectValueOf(BSON_FLD_RELATED_TO).AsGUID(Guid.Empty);
m_Type = doc.TryGetObjectValueOf(BSON_FLD_TYPE).AsEnum(MessageType.Info);
m_Source = doc.TryGetObjectValueOf(BSON_FLD_SOURCE).AsInt();
m_TimeStamp = doc.TryGetObjectValueOf(BSON_FLD_TIMESTAMP).AsDateTime(App.TimeSource.UTCNow);
m_Host = doc.TryGetObjectValueOf(BSON_FLD_HOST).AsString();
m_From = doc.TryGetObjectValueOf(BSON_FLD_FROM).AsString();
m_Topic = doc.TryGetObjectValueOf(BSON_FLD_TOPIC).AsString();
m_Text = doc.TryGetObjectValueOf(BSON_FLD_TEXT).AsString();
m_Parameters = doc.TryGetObjectValueOf(BSON_FLD_PARAMETERS).AsString();
m_ArchiveDimensions = doc.TryGetObjectValueOf(BSON_FLD_ARCHIVE_DIMENSIONS).AsString();
m_Channel = doc.TryGetObjectValueOf(BSON_FLD_CHANNEL).AsString();
var ee = doc[BSON_FLD_EXCEPTION] as BSONDocumentElement;
if (ee == null)
{
return;
}
m_Exception = WrappedException.MakeFromBSON(serializer, ee.Value);
}
public void SerializeToBSON(BSONSerializer serializer, BSONDocument doc, IBSONSerializable parent, ref object context)
{
serializer.AddTypeIDField(doc, parent, this, context);
var skipNull = (serializer.Flags ^ BSONSerializationFlags.KeepNull) == 0;
doc.Add(serializer.PKFieldName, m_Guid, required: true)
.Add(BSON_FLD_RELATED_TO, m_RelatedTo, skipNull)
.Add(BSON_FLD_TYPE, m_Type.ToString(), skipNull, required: true)
.Add(BSON_FLD_SOURCE, m_Source, skipNull)
.Add(BSON_FLD_TIMESTAMP, m_TimeStamp.ToUniversalTime(), skipNull)
.Add(BSON_FLD_HOST, m_Host, skipNull)
.Add(BSON_FLD_FROM, m_From, skipNull)
.Add(BSON_FLD_TOPIC, m_Topic, skipNull)
.Add(BSON_FLD_TEXT, m_Text, skipNull)
.Add(BSON_FLD_PARAMETERS, m_Parameters, skipNull)
.Add(BSON_FLD_ARCHIVE_DIMENSIONS, m_ArchiveDimensions, skipNull)
.Add(BSON_FLD_CHANNEL, m_Channel, skipNull);
if (m_Exception == null)
{
return;
}
var we = m_Exception as WrappedException;
if (we == null)
{
we = WrappedException.ForException(m_Exception);
}
doc.Add(BSON_FLD_EXCEPTION, serializer.Serialize(we, parent: this), skipNull);
}
public void SerializeDeserializeLogMessage_withException()
{
var ser = new BSONSerializer(new BSONTypeResolver(typeof(Message)));
var msg = new Azos.Log.Message
{
Type = MessageType.DebugGlue,
UTCTimeStamp = Ambient.UTCNow,
Channel = "MTV",
From = "Zhaba",
Topic = "App",
Text = "Hello text",
Source = 12345,
Parameters = "aaaaa",
ArchiveDimensions = "a=1 b=2",
Exception = WrappedException.ForException(new Exception("It is an error!!!"))
};
var doc = ser.Serialize(msg);
Console.WriteLine(doc.ToJSON(JSONWritingOptions.PrettyPrint));
var got = ser.Deserialize(doc) as Azos.Log.Message;
testMsgEquWoError(msg, got);
Aver.IsTrue(got.Exception is WrappedException);
Aver.AreEqual(msg.Exception.Message, got.Exception.Message);
Aver.AreEqual(((WrappedException)msg.Exception).Wrapped.Message, ((WrappedException)got.Exception).Wrapped.Message);
}
public void SerializeDeserializeLogMessage_KnownTypes()
{
var ser = new BSONSerializer();//notice no resolver
var msg = new NFX.Log.Message
{
Type = MessageType.DebugGlue,
TimeStamp = App.TimeSource.UTCNow,
Channel = "MTV",
From = "Zhaba",
Topic = "App",
Text = "Hello text",
Source = 12345,
Parameters = "aaaaa",
ArchiveDimensions = "a=1 b=2"
};
var doc = ser.Serialize(msg, new BSONParentKnownTypes(typeof(Message)));
Console.WriteLine(doc.ToJSON(JSONWritingOptions.PrettyPrint));
Aver.IsFalse(doc.IndexOfName(ser.TypeIDFieldName) >= 0); //field was NOT added as the root type is known
var got = new NFX.Log.Message(); //pre-allocate before deserialize, as __t was not emitted
Aver.IsNotNull(ser.Deserialize(doc, result: got) as NFX.Log.Message);
testMsgEquWoError(msg, got);
}
public void SerializeDeserializeLogMessage()
{
var ser = new BSONSerializer(new BSONTypeResolver(typeof(Message)));
var msg = new NFX.Log.Message
{
Type = MessageType.DebugGlue,
TimeStamp = App.TimeSource.UTCNow,
Channel = "MTV",
From = "Zhaba",
Topic = "App",
Text = "Hello text",
Source = 12345,
Parameters = "aaaaa",
ArchiveDimensions = "a=1 b=2"
};
var doc = ser.Serialize(msg);
Console.WriteLine(doc.ToJSON(JSONWritingOptions.PrettyPrint));
Aver.IsTrue(doc.IndexOfName(ser.TypeIDFieldName) >= 0);//field was added
var got = ser.Deserialize(doc) as NFX.Log.Message;
testMsgEquWoError(msg, got);
}
public void SerializeDeserializeLogMessage_withNestedException()
{
var ser = new BSONSerializer(new BSONTypeResolver(typeof(Message)));
var msg = new NFX.Log.Message
{
Type = MessageType.DebugGlue,
TimeStamp = App.TimeSource.UTCNow,
Channel = "MTV",
From = "Zhaba",
Topic = "App",
Text = "Hello text in Chinese: 中原千军逐蒋",
Source = 0,
Parameters = new string('a', 128000),
ArchiveDimensions = "a=1 b=2",
Exception = WrappedException.ForException(new Exception("It is an error!!!", new Exception("Inside")))
};
var doc = ser.Serialize(msg);
Console.WriteLine(doc.ToJSON(JSONWritingOptions.PrettyPrint));
var got = ser.Deserialize(doc) as NFX.Log.Message;
testMsgEquWoError(msg, got);
Aver.IsTrue(got.Exception is WrappedException);
Aver.AreEqual(msg.Exception.Message, got.Exception.Message);
Aver.AreEqual(((WrappedException)msg.Exception).Wrapped.Message, ((WrappedException)got.Exception).Wrapped.Message);
Aver.IsNotNull(((WrappedException)msg.Exception).Wrapped.InnerException);
Aver.AreEqual(((WrappedException)msg.Exception).Wrapped.InnerException.Message, ((WrappedException)got.Exception).Wrapped.InnerException.Message);
}
public static WrappedException MakeFromBSON(BSONSerializer serializer, BSONDocument doc)
{
var wrp = doc["wrp"] as BSONDocumentElement;
var result = wrp == null ? new WrappedException() : new WrappedException(wrp.Value.TryGetObjectValueOf("msg").AsString());
serializer.Deserialize(doc, result);
return(result);
}
/// <summary>
/// Serializes the instance as base64-encoded BSON data. This method complements .FromBase64(string)
/// </summary>
public string ToBase64()
{
var ser = new BSONSerializer();
var doc = ser.Serialize(this);
var bin = doc.WriteAsBSONToNewArray();
return(Convert.ToBase64String(bin, Base64FormattingOptions.None));
}
public MongoLogArchiveStore(LogReceiverService director, LogArchiveDimensionsMapper mapper, IConfigSectionNode node) : base(director, mapper, node)
{
var cstring = ConfigStringBuilder.Build(node, CONFIG_MONGO_SECTION);
m_Database = App.GetMongoDatabaseFromConnectString(cstring);
m_DefaultChannel = node.AttrByName(CONFIG_DEFAULT_CHANNEL_ATTR).ValueAsAtom(DEFAULT_CHANNEL);
m_Serializer = new BSONSerializer(node);
m_Serializer.PKFieldName = Query._ID;
}
public MongoTelemetryArchiveStore(TelemetryReceiverService director, IConfigSectionNode node) : base(director, node)
{
var cstring = ConfigStringBuilder.Build(node, CONFIG_MONGO_SECTION);
m_Database = MongoClient.DatabaseFromConnectString(cstring);
m_DefaultChannel = node.AttrByName(CONFIG_DEFAULT_CHANNEL_ATTR).ValueAsString(DEFAULT_CHANNEL);
m_Serializer = new BSONSerializer(node);
m_Serializer.PKFieldName = Query._ID;
}
public override void DeserializeFromBSON(BSONSerializer serializer, BSONDocument doc, ref object context)
{
base.DeserializeFromBSON(serializer, doc, ref context);
m_Entity = doc.TryGetObjectValueOf(BSON_FLD_ENTITY).AsString();
m_G_Shard = doc.TryGetObjectValueOf(BSON_FLD_G_SHARD).AsGDID();
m_G_Entity = doc.TryGetObjectValueOf(BSON_FLD_G_ENTITY).AsGDID();
m_Dimensions = doc.TryGetObjectValueOf(BSON_FLD_DIMS).AsString();
}
public override void SerializeToBSON(BSONSerializer serializer, BSONDocument doc, IBSONSerializable parent, ref object context)
{
base.SerializeToBSON(serializer, doc, parent, ref context);
doc.Add(BSON_FLD_ENTITY, m_Entity);
doc.Add(BSON_FLD_G_SHARD, m_G_Shard.ToString());
doc.Add(BSON_FLD_G_ENTITY, m_G_Entity.ToString());
doc.Add(BSON_FLD_DIMS, m_Dimensions);
}
public virtual void DeserializeFromBSON(BSONSerializer serializer, BSONDocument doc, ref object context)
{
m_Count = doc.TryGetObjectValueOf(BSON_FLD_COUNT).AsInt();
m_UTCTime = doc.TryGetObjectValueOf(BSON_FLD_TIME).AsDateTime();
if (m_Count > 0)
{
m_UTCEndTime = doc.TryGetObjectValueOf(BSON_FLD_END_TIME).AsDateTime();
}
m_Source = doc.TryGetObjectValueOf(BSON_FLD_SOURCE).AsString();
}
/// <summary>
/// Creates an instance of WrappedExceptionData saturating it from base64-encoded BSON data.
/// This method complements .ToBase64()
/// </summary>
public static WrappedExceptionData FromBase64(string base64)
{
var bin = Convert.FromBase64String(base64);
var doc = BSONDocument.FromArray(bin);
var ser = new BSONSerializer();
var result = new WrappedExceptionData();
object ctx = null;
result.DeserializeFromBSON(ser, doc, ref ctx);
return(result);
}
public void DeserializeFromBSON(BSONSerializer serializer, BSONDocument doc, ref object context)
{
var iv = doc["wrp"] as BSONDocumentElement;
if (iv == null)
{
return;
}
m_Wrapped = new WrappedExceptionData();
serializer.Deserialize(iv.Value, m_Wrapped);
}
public void SerializeToBSON(BSONSerializer serializer, BSONDocument doc, IBSONSerializable parent, ref object context)
{
serializer.AddTypeIDField(doc, parent, this, context);
doc.Add(serializer.PKFieldName, Guid, required: true);
doc.Add(BSON_FLD_TRUE, True);
doc.Add(BSON_FLD_FALSE, False);
doc.Add(BSON_FLD_CHARMIN, CharMin);
doc.Add(BSON_FLD_CHARMAX, CharMax);
doc.Add(BSON_FLD_SBYTEMIN, SByteMin);
doc.Add(BSON_FLD_SBYTEMAX, SByteMax);
doc.Add(BSON_FLD_BYTEMIN, ByteMin);
doc.Add(BSON_FLD_BYTEMAX, ByteMax);
doc.Add(BSON_FLD_INT16MIN, Int16Min);
doc.Add(BSON_FLD_INT16MAX, Int16Max);
doc.Add(BSON_FLD_UINT16MIN, UInt16Min);
doc.Add(BSON_FLD_UINT16MAX, UInt16Max);
doc.Add(BSON_FLD_INT32MIN, Int32Min);
doc.Add(BSON_FLD_INT32MAX, Int32Max);
doc.Add(BSON_FLD_UINT32MIN, UInt32Min);
doc.Add(BSON_FLD_UINT32MAX, UInt32Max);
doc.Add(BSON_FLD_INT64MIN, Int64Min);
doc.Add(BSON_FLD_INT64MAX, Int64Max);
doc.Add(BSON_FLD_UINT64MIN, UInt64Min);
doc.Add(BSON_FLD_UINT64MAX, UInt64Max);
doc.Add(BSON_FLD_SINGLEEPS, SingleEps);
doc.Add(BSON_FLD_SINGLEMIN, SingleMin);
doc.Add(BSON_FLD_SINGLEMAX, SingleMax);
doc.Add(BSON_FLD_SINGLENAN, SingleNaN);
doc.Add(BSON_FLD_SINGLEPOSINF, SinglePosInf);
doc.Add(BSON_FLD_SINGLENEGINF, SingleNegInf);
doc.Add(BSON_FLD_DOUBLEEPS, DoubleEps);
doc.Add(BSON_FLD_DOUBLEMIN, DoubleMin);
doc.Add(BSON_FLD_DOUBLEMAX, DoubleMax);
doc.Add(BSON_FLD_DOUBLENAN, DoubleNaN);
doc.Add(BSON_FLD_DOUBLEPOSINF, DoublePosInf);
doc.Add(BSON_FLD_DOUBLENEGINF, DoubleNegInf);
doc.Add(BSON_FLD_DECIMALMIN, DecimalMin);
doc.Add(BSON_FLD_DECIMALMAX, DecimalMax);
doc.Add(BSON_FLD_DECIMALZERO, DecimalZero);
doc.Add(BSON_FLD_DECIMALONE, DecimalOne);
doc.Add(BSON_FLD_DECIMALMONE, DecimalMOne);
doc.Add(BSON_FLD_DATETIMEMIN, DateTimeMin);
doc.Add(BSON_FLD_DATETIMEMAX, DateTimeMax);
doc.Add(BSON_FLD_DATETIMENOW, DateTimeNow);
doc.Add(BSON_FLD_DATETIMEUTC, DateTimeUtc);
doc.Add(BSON_FLD_TIMESPANMIN, TimeSpanMin);
doc.Add(BSON_FLD_TIMESPANMAX, TimeSpanMax);
doc.Add(BSON_FLD_STRINGEMPTY, StringEmpty);
doc.Add(BSON_FLD_STRINGNULL, StringNull);
doc.Add(BSON_FLD_STRING, String);
}
public void DeserializeFromBSON(BSONSerializer serializer, BSONDocument doc, ref object context)
{
Guid = doc.TryGetObjectValueOf(serializer.PKFieldName).AsGUID(Guid.Empty);
True = doc.TryGetObjectValueOf(BSON_FLD_TRUE).AsBool();
False = doc.TryGetObjectValueOf(BSON_FLD_FALSE).AsBool();
CharMin = doc.TryGetObjectValueOf(BSON_FLD_CHARMIN).AsChar();
CharMax = doc.TryGetObjectValueOf(BSON_FLD_CHARMAX).AsChar();
SByteMin = doc.TryGetObjectValueOf(BSON_FLD_SBYTEMIN).AsSByte();
SByteMax = doc.TryGetObjectValueOf(BSON_FLD_SBYTEMAX).AsSByte();
ByteMin = doc.TryGetObjectValueOf(BSON_FLD_BYTEMIN).AsByte();
ByteMax = doc.TryGetObjectValueOf(BSON_FLD_BYTEMAX).AsByte();
Int16Min = doc.TryGetObjectValueOf(BSON_FLD_INT16MIN).AsShort();
Int16Max = doc.TryGetObjectValueOf(BSON_FLD_INT16MAX).AsShort();
UInt16Min = doc.TryGetObjectValueOf(BSON_FLD_UINT16MIN).AsUShort();
UInt16Max = doc.TryGetObjectValueOf(BSON_FLD_UINT16MAX).AsUShort();
Int32Min = doc.TryGetObjectValueOf(BSON_FLD_INT32MIN).AsInt();
Int32Max = doc.TryGetObjectValueOf(BSON_FLD_INT32MAX).AsInt();
UInt32Min = doc.TryGetObjectValueOf(BSON_FLD_UINT32MIN).AsUInt();
UInt32Max = doc.TryGetObjectValueOf(BSON_FLD_UINT32MAX).AsUInt();
Int64Min = doc.TryGetObjectValueOf(BSON_FLD_INT64MIN).AsLong();
Int64Max = doc.TryGetObjectValueOf(BSON_FLD_INT64MAX).AsLong();
UInt64Min = doc.TryGetObjectValueOf(BSON_FLD_UINT64MIN).AsULong();
UInt64Max = doc.TryGetObjectValueOf(BSON_FLD_UINT64MAX).AsULong();
SingleEps = doc.TryGetObjectValueOf(BSON_FLD_SINGLEEPS).AsFloat();
SingleMin = doc.TryGetObjectValueOf(BSON_FLD_SINGLEMIN).AsFloat();
SingleMax = doc.TryGetObjectValueOf(BSON_FLD_SINGLEMAX).AsFloat();
SingleNaN = doc.TryGetObjectValueOf(BSON_FLD_SINGLENAN).AsFloat();
SinglePosInf = doc.TryGetObjectValueOf(BSON_FLD_SINGLEPOSINF).AsFloat();
SingleNegInf = doc.TryGetObjectValueOf(BSON_FLD_SINGLENEGINF).AsFloat();
DoubleEps = doc.TryGetObjectValueOf(BSON_FLD_DOUBLEEPS).AsDouble();
DoubleMin = doc.TryGetObjectValueOf(BSON_FLD_DOUBLEMIN).AsDouble();
DoubleMax = doc.TryGetObjectValueOf(BSON_FLD_DOUBLEMAX).AsDouble();
DoubleNaN = doc.TryGetObjectValueOf(BSON_FLD_DOUBLENAN).AsDouble();
DoublePosInf = doc.TryGetObjectValueOf(BSON_FLD_DOUBLEPOSINF).AsDouble();
DoubleNegInf = doc.TryGetObjectValueOf(BSON_FLD_DOUBLENEGINF).AsDouble();
DecimalMin = RowConverter.Decimal_BSONtoCLR(doc[BSON_FLD_DECIMALMIN]);
DecimalMax = RowConverter.Decimal_BSONtoCLR(doc[BSON_FLD_DECIMALMAX]);
DecimalZero = RowConverter.Decimal_BSONtoCLR(doc[BSON_FLD_DECIMALZERO]);
DecimalOne = RowConverter.Decimal_BSONtoCLR(doc[BSON_FLD_DECIMALONE]);
DecimalMOne = RowConverter.Decimal_BSONtoCLR(doc[BSON_FLD_DECIMALMONE]);
DateTimeMin = doc.TryGetObjectValueOf(BSON_FLD_DATETIMEMIN).AsDateTime();
DateTimeMax = doc.TryGetObjectValueOf(BSON_FLD_DATETIMEMAX).AsDateTime();
DateTimeNow = doc.TryGetObjectValueOf(BSON_FLD_DATETIMENOW).AsDateTime();
DateTimeUtc = doc.TryGetObjectValueOf(BSON_FLD_DATETIMEUTC).AsDateTime();
TimeSpanMin = doc.TryGetObjectValueOf(BSON_FLD_TIMESPANMIN).AsTimeSpan();
TimeSpanMax = doc.TryGetObjectValueOf(BSON_FLD_TIMESPANMAX).AsTimeSpan();
StringEmpty = doc.TryGetObjectValueOf(BSON_FLD_STRINGEMPTY).AsString();
StringNull = doc.TryGetObjectValueOf(BSON_FLD_STRINGNULL).AsString();
String = doc.TryGetObjectValueOf(BSON_FLD_STRING).AsString();
}
public virtual void SerializeToBSON(BSONSerializer serializer, BSONDocument doc, IBSONSerializable parent, ref object context)
{
serializer.AddTypeIDField(doc, parent, this, context);
doc.Add(BSON_FLD_COUNT, m_Count)
.Add(BSON_FLD_TIME, m_UTCTime);
if (m_Count > 0)
{
doc.Add(BSON_FLD_END_TIME, m_UTCEndTime);
}
if ((serializer.Flags & BSONSerializationFlags.UIOnly) == 0)
{
doc.Add(BSON_FLD_SOURCE, Source);
}
}
public void DeserializeFromBSON(BSONSerializer serializer, BSONDocument doc, ref object context)
{
m_TypeName = doc.TryGetObjectValueOf("tname").AsString();
m_Message = doc.TryGetObjectValueOf("msg").AsString();
m_Code = doc.TryGetObjectValueOf("code").AsInt();
m_ApplicationName = doc.TryGetObjectValueOf("app").AsString();
m_Source = doc.TryGetObjectValueOf("src").AsString();
m_StackTrace = doc.TryGetObjectValueOf("trace").AsString();
m_WrappedData = doc.TryGetObjectValueOf("wdata").AsString();
var iv = doc["inner"] as BSONDocumentElement;
if (iv == null)
{
return;
}
m_InnerException = new WrappedExceptionData();
serializer.Deserialize(iv.Value, m_InnerException);
}
public void Benchmark_BSON(int cnt, bool error)
{
var msg = error ? withError() : withoutError();
var ser = new BSONSerializer();
var writer = SlimFormat.Instance.MakeWritingStreamer();
using (var ms = new MemoryStream())
{
writer.BindStream(ms);
var sw = Stopwatch.StartNew();
for (var i = 0; i < cnt; i++)
{
var doc = ser.Serialize(msg);
doc.WriteAsBSON(ms);
}
sw.Stop();
Console.WriteLine("Wrote {0:n2} BSON bytes for {1:n0} in {2:n0}ms at {3:n0} ops/sec".Args(ms.Position, cnt, sw.ElapsedMilliseconds, cnt / (sw.ElapsedMilliseconds / 1000d)));
}
}
public void SerializeToBSON(BSONSerializer serializer, BSONDocument doc, IBSONSerializable parent, ref object context)
{
serializer.AddTypeIDField(doc, parent, this, context);
doc.Set(new BSONStringElement("tname", TypeName))
.Set(new BSONStringElement("msg", Message))
.Set(new BSONInt32Element("code", Code))
.Set(new BSONStringElement("app", ApplicationName))
.Set(new BSONStringElement("src", Source))
.Set(new BSONStringElement("trace", StackTrace));
if (WrappedData != null)
{
doc.Set(new BSONStringElement("wdata", WrappedData));
}
if (m_InnerException == null)
{
return;
}
doc.Set(new BSONDocumentElement("inner", serializer.Serialize(m_InnerException, parent: this)));
}
public override void DeserializeFromBSON(BSONSerializer serializer, BSONDocument doc, ref object context)
{
base.DeserializeFromBSON(serializer, doc, ref context);
m_Value = RowConverter.Decimal_BSONtoCLR(doc[BSON_FLD_VALUE]);
}
public void SerializeTypicalData()
{
var ser = new BSONSerializer(new BSONTypeResolver(typeof(TypicalData)));
var data = new TypicalData
{
Guid = Guid.NewGuid(),
True = true,
False = false,
CharMin = Char.MinValue,
CharMax = Char.MaxValue,
SByteMin = SByte.MinValue,
SByteMax = SByte.MaxValue,
ByteMin = Byte.MinValue,
ByteMax = Byte.MaxValue,
Int16Min = Int16.MinValue,
Int16Max = Int16.MaxValue,
UInt16Min = UInt16.MinValue,
UInt16Max = UInt16.MaxValue,
Int32Min = Int32.MinValue,
Int32Max = Int32.MaxValue,
UInt32Min = UInt32.MinValue,
UInt32Max = UInt32.MaxValue,
Int64Min = Int64.MinValue,
Int64Max = Int64.MaxValue,
UInt64Min = UInt64.MinValue,
UInt64Max = UInt64.MaxValue,
SingleEps = Single.Epsilon,
SingleMin = Single.MinValue,
SingleMax = Single.MaxValue,
SingleNaN = Single.NaN,
SinglePosInf = Single.PositiveInfinity,
SingleNegInf = Single.NegativeInfinity,
DoubleEps = Double.Epsilon,
DoubleMin = Double.MinValue,
DoubleMax = Double.MaxValue,
DoubleNaN = Double.NaN,
DoublePosInf = Double.PositiveInfinity,
DoubleNegInf = Double.NegativeInfinity,
DecimalMin = RowConverter.MIN_DECIMAL,
DecimalMax = RowConverter.MAX_DECIMAL,
DecimalZero = Decimal.Zero,
DecimalOne = Decimal.One,
DecimalMOne = Decimal.MinusOne,
DateTimeMin = DateTime.MinValue,
DateTimeMax = DateTime.MaxValue,
DateTimeNow = DateTime.Now,
DateTimeUtc = DateTime.UtcNow,
TimeSpanMin = TimeSpan.MinValue,
TimeSpanMax = TimeSpan.MaxValue,
StringEmpty = String.Empty,
StringNull = null,
String = "TypicalString",
};
var doc = ser.Serialize(data);
Console.WriteLine(doc.ToJSON(JSONWritingOptions.PrettyPrint));
Aver.IsTrue(doc.IndexOfName(ser.TypeIDFieldName) >= 0);
var got = ser.Deserialize(doc) as TypicalData;
averDataAreEqual(data, got);
}
public override void SerializeToBSON(BSONSerializer serializer, BSONDocument doc, IBSONSerializable parent, ref object context)
{
base.SerializeToBSON(serializer, doc, parent, ref context);
doc.Add(BSON_FLD_EXCEPTION_TYPE, m_ExceptionType);
}
public override void SerializeToBSON(BSONSerializer serializer, BSONDocument doc, IBSONSerializable parent, ref object context)
{
base.SerializeToBSON(serializer, doc, parent, ref context);
doc.Set(DataDocConverter.Amount_CLRtoBSON(BSON_FLD_VALUE, m_Value));
}
public void SerializeToBSON(BSONSerializer serializer, BSONDocument doc, IBSONSerializable parent, ref object context)
{
serializer.AddTypeIDField(doc, parent, this, context);
doc.Set(new BSONDocumentElement("wrp", serializer.Serialize(m_Wrapped, parent: this)));
}
public override void DeserializeFromBSON(BSONSerializer serializer, BSONDocument doc, ref object context)
{
base.DeserializeFromBSON(serializer, doc, ref context);
m_Value = DataDocConverter.Amount_BSONtoCLR((BSONDocumentElement)doc[BSON_FLD_VALUE]);
}
public override void SerializeToBSON(BSONSerializer serializer, BSONDocument doc, IBSONSerializable parent, ref object context)
{
base.SerializeToBSON(serializer, doc, parent, ref context);
doc.Add(BSON_FLD_VALUE, m_Value);
}
public override void DeserializeFromBSON(BSONSerializer serializer, BSONDocument doc, ref object context)
{
m_Value = doc.TryGetObjectValueOf(BSON_FLD_VALUE).AsLong();
base.DeserializeFromBSON(serializer, doc, ref context);
}
