public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) throw new PBException("serialize OXmlSimpleFieldElement value is null"); if (_trace) pb.Trace.WriteLine("OXmlSimpleFieldElementSerializer.Serialize()"); OXmlSimpleFieldElement element = (OXmlSimpleFieldElement)value; bsonWriter.WriteStartDocument(); bsonWriter.WriteString("Type", "SimpleField"); bsonWriter.WriteString("Instruction", element.Instruction); bsonWriter.WriteEndDocument(); }
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) throw new PBException("serialize OXmlOpenHeader value is null"); if (_trace) pb.Trace.WriteLine("OXmlOpenHeaderElementSerializer.Serialize()"); OXmlOpenHeaderElement element = (OXmlOpenHeaderElement)value; bsonWriter.WriteStartDocument(); bsonWriter.WriteString("Type", "OpenHeader"); bsonWriter.WriteString("HeaderType", element.HeaderType.ToString()); bsonWriter.WriteEndDocument(); }
public void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { var method = (MethodInfo)value; bsonWriter.WriteStartDocument(); bsonWriter.WriteName("Type"); bsonWriter.WriteString(method.DeclaringType.AssemblyQualifiedName); bsonWriter.WriteName("Method"); bsonWriter.WriteString(GetMethodSignature(method)); bsonWriter.WriteEndDocument(); }
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) throw new PBException("serialize OXmlParagraphElement value is null"); if (_trace) pb.Trace.WriteLine("OXmlParagraphElementSerializer.Serialize()"); OXmlParagraphElement paragraph = (OXmlParagraphElement)value; bsonWriter.WriteStartDocument(); bsonWriter.WriteString("Type", "Paragraph"); if (paragraph.Style != null) bsonWriter.WriteString("Style", paragraph.Style); bsonWriter.WriteEndDocument(); }
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) throw new PBException("serialize OXmlTextElement value is null"); if (_trace) pb.Trace.WriteLine("OXmlTextElementSerializer.Serialize()"); OXmlTextElement element = (OXmlTextElement)value; bsonWriter.WriteStartDocument(); bsonWriter.WriteString("Type", "Text"); if (element.Text != null) bsonWriter.WriteString("Text", element.Text); if (element.PreserveSpace) bsonWriter.WriteBoolean("PreserveSpace", element.PreserveSpace); bsonWriter.WriteEndDocument(); }
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { var c = (C)value; bsonWriter.WriteStartDocument(); bsonWriter.WriteString("nominalType", nominalType.Name); bsonWriter.WriteInt32("X", c.X); bsonWriter.WriteEndDocument(); }
public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options ) { var dateTime = (DateTime) value; bsonWriter.WriteString(dateTime.ToString("yyyy-MM-dd")); }
public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options ) { var type = (Type)value; bsonWriter.WriteString(type.AssemblyQualifiedName); }
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value != null) { bsonWriter.WriteString(value.ToString()); } else { bsonWriter.WriteNull(); } }
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { bsonWriter.WriteNull(); } else { var crs = (GeoJsonLinkedCoordinateReferenceSystem)value; bsonWriter.WriteStartDocument(); SerializeType(bsonWriter, crs.Type); bsonWriter.WriteStartDocument("properties"); bsonWriter.WriteString("href", crs.HRef); if (crs.HRefType != null) { bsonWriter.WriteString("type", crs.HRefType); } bsonWriter.WriteEndDocument(); bsonWriter.WriteEndDocument(); } }
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { // when entry is null, do not throw, just write null if (value == null) { bsonWriter.WriteNull(); return; } if (_failOnSerialize) throw new InvalidOperationException(); bsonWriter.WriteString((string)value); }
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { throw new PBException("error serialize UrlImage value is null"); } //bsonWriter.WriteString(((WebImage)value).Url); string url = ((WebImage)value).Url; if (url != null) bsonWriter.WriteString(url); else bsonWriter.WriteNull(); }
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { var identity = (Identity)value; var objectId = new ObjectId(identity.ToArray()); BsonType bsonType = options == null ? BsonType.ObjectId : ((RepresentationSerializationOptions)options).Representation; switch (bsonType) { case BsonType.String: bsonWriter.WriteString(objectId.ToString()); break; case BsonType.ObjectId: bsonWriter.WriteObjectId(objectId.Timestamp, objectId.Machine, objectId.Pid, objectId.Increment); break; default: throw new BsonSerializationException(string.Format("'{0}' is not a valid representation for type 'Identity'", bsonType)); } }
public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options ) { var nvc = (NameValueCollection)value; bsonWriter.WriteStartDocument(); if (nvc != null && nvc.Count > 0) { foreach (var key in nvc.AllKeys) { bsonWriter.WriteString(key.Replace(".", "__period__"), nvc[key]); } } bsonWriter.WriteEndDocument(); }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (_trace) pb.Trace.WriteLine("ZStringSerializer.Serialize()"); if (value == null) { //throw new ArgumentNullException("value"); throw new PBException("error serialize ZString value is null"); } string stringValue = ((ZString)value).Value; if (stringValue == null) bsonWriter.WriteNull(); else bsonWriter.WriteString(stringValue); }
public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options ) { var dictionary = (DynamicDictionary)value; bsonWriter.WriteStartDocument(); bsonWriter.WriteString( "_t", "DynamicDictionary" ); if( dictionary != null ) { foreach( var entry in dictionary ) { bsonWriter.WriteName( entry.Key.Replace( '.', '\x03' ) ); BsonSerializer.Serialize( bsonWriter, typeof( object ), entry.Value ); } } bsonWriter.WriteEndDocument(); }
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) throw new PBException("serialize OXmlDocDefaultsRunPropertiesElement value is null"); if (_trace) pb.Trace.WriteLine("OXmlRunPropertiesDefaultElementSerializer.Serialize()"); OXmlDocDefaultsRunPropertiesElement element = (OXmlDocDefaultsRunPropertiesElement)value; bsonWriter.WriteStartDocument(); bsonWriter.WriteString("Type", "DocDefaultsRunProperties"); if (element.RunFonts != null) { bsonWriter.WriteStartDocument("RunFonts"); OXmlCommonSerializer.WriteRunFonts(bsonWriter, element.RunFonts); bsonWriter.WriteEndDocument(); } if (element.FontSize != null) bsonWriter.WriteString("FontSize", element.FontSize); bsonWriter.WriteEndDocument(); }
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (_trace) pb.Trace.WriteLine("ZStringArraySerializer.Serialize()"); if (value == null) { throw new PBException("error serialize ZStringArray value is null"); } string[] stringValues = ((ZStringArray)value).Values; if (stringValues == null) bsonWriter.WriteNull(); else { bsonWriter.WriteStartArray(); foreach (string stringValue in stringValues) { bsonWriter.WriteString(stringValue); } bsonWriter.WriteEndArray(); } }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { var doubleValue = (double)value; var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options); switch (representationSerializationOptions.Representation) { case BsonType.Double: bsonWriter.WriteDouble(doubleValue); break; case BsonType.Int32: bsonWriter.WriteInt32(representationSerializationOptions.ToInt32(doubleValue)); break; case BsonType.Int64: bsonWriter.WriteInt64(representationSerializationOptions.ToInt64(doubleValue)); break; case BsonType.String: bsonWriter.WriteString(doubleValue.ToString("R", NumberFormatInfo.InvariantInfo)); break; default: var message = string.Format("'{0}' is not a valid Double representation.", representationSerializationOptions.Representation); throw new BsonSerializationException(message); } }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { var timeSpan = (TimeSpan)value; // support RepresentationSerializationOptions for backward compatibility var representationSerializationOptions = options as RepresentationSerializationOptions; if (representationSerializationOptions != null) { options = new TimeSpanSerializationOptions(representationSerializationOptions.Representation); } var timeSpanSerializationOptions = EnsureSerializationOptions<TimeSpanSerializationOptions>(options); switch (timeSpanSerializationOptions.Representation) { case BsonType.Double: bsonWriter.WriteDouble(ToDouble(timeSpan, timeSpanSerializationOptions.Units)); break; case BsonType.Int32: bsonWriter.WriteInt32(ToInt32(timeSpan, timeSpanSerializationOptions.Units)); break; case BsonType.Int64: bsonWriter.WriteInt64(ToInt64(timeSpan, timeSpanSerializationOptions.Units)); break; case BsonType.String: bsonWriter.WriteString(timeSpan.ToString()); // not XmlConvert.ToString (we're using .NET's format for TimeSpan) break; default: var message = string.Format("'{0}' is not a valid TimeSpan representation.", timeSpanSerializationOptions.Representation); throw new BsonSerializationException(message); } }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { // note: the DateTime portion cannot be serialized as a BsonType.DateTime because it is NOT in UTC var dateTimeOffset = (DateTimeOffset)value; var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options); switch (representationSerializationOptions.Representation) { case BsonType.Array: bsonWriter.WriteStartArray(); bsonWriter.WriteInt64(dateTimeOffset.Ticks); bsonWriter.WriteInt32((int)dateTimeOffset.Offset.TotalMinutes); bsonWriter.WriteEndArray(); break; case BsonType.Document: bsonWriter.WriteStartDocument(); bsonWriter.WriteDateTime("DateTime", BsonUtils.ToMillisecondsSinceEpoch(dateTimeOffset.UtcDateTime)); bsonWriter.WriteInt64("Ticks", dateTimeOffset.Ticks); bsonWriter.WriteInt32("Offset", (int)dateTimeOffset.Offset.TotalMinutes); bsonWriter.WriteEndDocument(); break; case BsonType.String: bsonWriter.WriteString(XmlConvert.ToString(dateTimeOffset)); break; default: var message = string.Format("'{0}' is not a valid DateTimeOffset representation.", representationSerializationOptions.Representation); throw new BsonSerializationException(message); } }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { var int16Value = (short)value; var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options); switch (representationSerializationOptions.Representation) { case BsonType.Double: bsonWriter.WriteDouble(representationSerializationOptions.ToDouble(int16Value)); break; case BsonType.Int32: bsonWriter.WriteInt32(representationSerializationOptions.ToInt32(int16Value)); break; case BsonType.Int64: bsonWriter.WriteInt64(representationSerializationOptions.ToInt64(int16Value)); break; case BsonType.String: bsonWriter.WriteString(XmlConvert.ToString(int16Value)); break; default: var message = string.Format("'{0}' is not a valid Int16 representation.", representationSerializationOptions.Representation); throw new BsonSerializationException(message); } }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { var decimalValue = (Decimal)value; var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options); switch (representationSerializationOptions.Representation) { case BsonType.Array: bsonWriter.WriteStartArray(); var bits = Decimal.GetBits(decimalValue); bsonWriter.WriteInt32(bits[0]); bsonWriter.WriteInt32(bits[1]); bsonWriter.WriteInt32(bits[2]); bsonWriter.WriteInt32(bits[3]); bsonWriter.WriteEndArray(); break; case BsonType.Double: bsonWriter.WriteDouble(representationSerializationOptions.ToDouble(decimalValue)); break; case BsonType.Int32: bsonWriter.WriteInt32(representationSerializationOptions.ToInt32(decimalValue)); break; case BsonType.Int64: bsonWriter.WriteInt64(representationSerializationOptions.ToInt64(decimalValue)); break; case BsonType.String: bsonWriter.WriteString(XmlConvert.ToString(decimalValue)); break; default: var message = string.Format("'{0}' is not a valid Decimal representation.", representationSerializationOptions.Representation); throw new BsonSerializationException(message); } }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { var objectId = (ObjectId)value; var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options); switch (representationSerializationOptions.Representation) { case BsonType.ObjectId: bsonWriter.WriteObjectId(objectId.Timestamp, objectId.Machine, objectId.Pid, objectId.Increment); break; case BsonType.String: bsonWriter.WriteString(objectId.ToString()); break; default: var message = string.Format("'{0}' is not a valid ObjectId representation.", representationSerializationOptions.Representation); throw new BsonSerializationException(message); } }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { bsonWriter.WriteNull(); } else { var stringValue = (string)value; var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options); switch (representationSerializationOptions.Representation) { case BsonType.ObjectId: var id = ObjectId.Parse(stringValue); bsonWriter.WriteObjectId(id.Timestamp, id.Machine, id.Pid, id.Increment); break; case BsonType.String: bsonWriter.WriteString(stringValue); break; case BsonType.Symbol: bsonWriter.WriteSymbol(stringValue); break; default: var message = string.Format("'{0}' is not a valid String representation.", representationSerializationOptions.Representation); throw new BsonSerializationException(message); } } }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { var guid = (Guid)value; var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options); switch (representationSerializationOptions.Representation) { case BsonType.Binary: var writerGuidRepresentation = bsonWriter.Settings.GuidRepresentation; if (writerGuidRepresentation == GuidRepresentation.Unspecified) { throw new BsonSerializationException("GuidSerializer cannot serialize a Guid when GuidRepresentation is Unspecified."); } var bytes = GuidConverter.ToBytes(guid, writerGuidRepresentation); var subType = (writerGuidRepresentation == GuidRepresentation.Standard) ? BsonBinarySubType.UuidStandard : BsonBinarySubType.UuidLegacy; bsonWriter.WriteBinaryData(bytes, subType, writerGuidRepresentation); break; case BsonType.String: bsonWriter.WriteString(guid.ToString()); break; default: var message = string.Format("'{0}' is not a valid Guid representation.", representationSerializationOptions.Representation); throw new BsonSerializationException(message); } }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { var dateTime = (DateTime)value; var dateTimeSerializationOptions = EnsureSerializationOptions<DateTimeSerializationOptions>(options); DateTime utcDateTime; if (dateTimeSerializationOptions.DateOnly) { if (dateTime.TimeOfDay != TimeSpan.Zero) { throw new BsonSerializationException("TimeOfDay component is not zero."); } utcDateTime = DateTime.SpecifyKind(dateTime, DateTimeKind.Utc); // not ToLocalTime } else { utcDateTime = BsonUtils.ToUniversalTime(dateTime); } var millisecondsSinceEpoch = BsonUtils.ToMillisecondsSinceEpoch(utcDateTime); switch (dateTimeSerializationOptions.Representation) { case BsonType.DateTime: bsonWriter.WriteDateTime(millisecondsSinceEpoch); break; case BsonType.Document: bsonWriter.WriteStartDocument(); bsonWriter.WriteDateTime("DateTime", millisecondsSinceEpoch); bsonWriter.WriteInt64("Ticks", utcDateTime.Ticks); bsonWriter.WriteEndDocument(); break; case BsonType.Int64: bsonWriter.WriteInt64(utcDateTime.Ticks); break; case BsonType.String: if (dateTimeSerializationOptions.DateOnly) { bsonWriter.WriteString(dateTime.ToString("yyyy-MM-dd")); } else { // we're not using XmlConvert.ToString because of bugs in Mono if (dateTime == DateTime.MinValue || dateTime == DateTime.MaxValue) { // serialize MinValue and MaxValue as Unspecified so we do NOT get the time zone offset dateTime = DateTime.SpecifyKind(dateTime, DateTimeKind.Unspecified); } else if (dateTime.Kind == DateTimeKind.Unspecified) { // serialize Unspecified as Local se we get the time zone offset dateTime = DateTime.SpecifyKind(dateTime, DateTimeKind.Local); } bsonWriter.WriteString(dateTime.ToString("yyyy-MM-ddTHH:mm:ss.FFFFFFFK")); } break; default: var message = string.Format("'{0}' is not a valid DateTime representation.", dateTimeSerializationOptions.Representation); throw new BsonSerializationException(message); } }
/// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { var boolValue = (bool)value; var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options); switch (representationSerializationOptions.Representation) { case BsonType.Boolean: bsonWriter.WriteBoolean(boolValue); break; case BsonType.Double: bsonWriter.WriteDouble(boolValue ? 1.0 : 0.0); break; case BsonType.Int32: bsonWriter.WriteInt32(boolValue ? 1 : 0); break; case BsonType.Int64: bsonWriter.WriteInt64(boolValue ? 1 : 0); break; case BsonType.String: bsonWriter.WriteString(XmlConvert.ToString(boolValue)); break; default: var message = string.Format("'{0}' is not a valid Boolean representation.", representationSerializationOptions.Representation); throw new BsonSerializationException(message); } }
#pragma warning restore 618 /// <summary> /// Serializes an object to a BsonWriter. /// </summary> /// <param name="bsonWriter">The BsonWriter.</param> /// <param name="nominalType">The nominal type.</param> /// <param name="value">The object.</param> /// <param name="options">The serialization options.</param> public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (value == null) { bsonWriter.WriteNull(); } else { var bitArray = (BitArray)value; var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options); switch (representationSerializationOptions.Representation) { case BsonType.Binary: if ((bitArray.Length % 8) == 0) { bsonWriter.WriteBinaryData(GetBytes(bitArray), BsonBinarySubType.Binary); } else { bsonWriter.WriteStartDocument(); bsonWriter.WriteInt32("Length", bitArray.Length); bsonWriter.WriteBinaryData("Bytes", GetBytes(bitArray), BsonBinarySubType.Binary); bsonWriter.WriteEndDocument(); } break; case BsonType.String: var sb = new StringBuilder(bitArray.Length); for (int i = 0; i < bitArray.Length; i++) { sb.Append(bitArray[i] ? '1' : '0'); } bsonWriter.WriteString(sb.ToString()); break; default: var message = string.Format("'{0}' is not a valid BitArray representation.", representationSerializationOptions.Representation); throw new BsonSerializationException(message); } } }
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { var version = (MigrationVersion) value; var versionString = string.Format("{0}.{1}.{2}", version.Major, version.Minor, version.Revision); bsonWriter.WriteString(versionString); }