public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options ) { if (value == null) { bsonWriter.WriteNull(); return; } var nvc = (NameValueCollection)value; bsonWriter.WriteStartArray(); foreach (var key in nvc.AllKeys) { foreach (var val in nvc.GetValues(key)) { bsonWriter.WriteStartArray(); StringSerializer.Instance.Serialize(bsonWriter, typeof(string), key, options); StringSerializer.Instance.Serialize(bsonWriter, typeof(string), val, options); bsonWriter.WriteEndArray(); } } bsonWriter.WriteEndArray(); }
public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { var dateTimeOffset = (DateTimeOffset)value; var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options); switch (representationSerializationOptions.Representation) { case BsonType.Array: bsonWriter.WriteStartArray(); bsonWriter.WriteInt64(dateTimeOffset.UtcTicks); 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.UtcTicks); bsonWriter.WriteInt32("Offset", (int)dateTimeOffset.Offset.TotalMinutes); bsonWriter.WriteEndDocument(); 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) { if (value == null) { bsonWriter.WriteNull(); } else { var coordinates = (GeoJson2DCoordinates)value; bsonWriter.WriteStartArray(); bsonWriter.WriteDouble(coordinates.X); bsonWriter.WriteDouble(coordinates.Y); bsonWriter.WriteEndArray(); } }
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { bsonWriter.WriteStartArray(); if (value != null) { var array = value as IEnumerable; if (array != null) { foreach (var id in from object arrayItem in array select IdentifierFinder.GetId(arrayItem)) { BsonSerializer.Serialize(bsonWriter, id.GetType(), id); } } } 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) { if (value == null) { bsonWriter.WriteNull(); } else { var coordinates = (GeoJson3DProjectedCoordinates)value; bsonWriter.WriteStartArray(); bsonWriter.WriteDouble(coordinates.Easting); bsonWriter.WriteDouble(coordinates.Northing); bsonWriter.WriteDouble(coordinates.Altitude); bsonWriter.WriteEndArray(); } }
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) { if (value == null) { bsonWriter.WriteNull(); } else { var actualType = value.GetType(); var discriminator = GetDiscriminator(nominalType, actualType); if (discriminator != null) { bsonWriter.WriteStartDocument(); bsonWriter.WriteString("_t", discriminator); bsonWriter.WriteName("_v"); Serialize(bsonWriter, actualType, value, options); bsonWriter.WriteEndDocument(); return; } var arraySerializationOptions = EnsureSerializationOptions<ArraySerializationOptions>(options); var itemSerializationOptions = arraySerializationOptions.ItemSerializationOptions; Type lastItemType = null; IBsonSerializer lastItemSerializer = null; bsonWriter.WriteStartArray(); foreach (var item in EnumerateItemsInSerializationOrder(value)) { var itemType = (item == null) ? typeof(object) : item.GetType(); IBsonSerializer itemSerializer; if (itemType == lastItemType) { itemSerializer = lastItemSerializer; } else { itemSerializer = BsonSerializer.LookupSerializer(itemType); lastItemType = itemType; lastItemSerializer = itemSerializer; } itemSerializer.Serialize(bsonWriter, typeof(object), item, itemSerializationOptions); } 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) { if (value == null) { bsonWriter.WriteNull(); } else { var dictionary = (IDictionary)value; if (nominalType == typeof(object)) { var actualType = value.GetType(); bsonWriter.WriteStartDocument(); bsonWriter.WriteString("_t", BsonClassMap.GetTypeNameDiscriminator(actualType)); bsonWriter.WriteName("_v"); Serialize(bsonWriter, actualType, value, options); // recursive call replacing nominalType with actualType bsonWriter.WriteEndDocument(); return; } var dictionaryOptions = options as DictionarySerializationOptions; if (dictionaryOptions == null) { // support RepresentationSerializationOptions for backward compatibility var representationOptions = options as RepresentationSerializationOptions; if (representationOptions != null) { switch (representationOptions.Representation) { case BsonType.Array: dictionaryOptions = DictionarySerializationOptions.ArrayOfArrays; break; case BsonType.Document: dictionaryOptions = DictionarySerializationOptions.Document; break; default: var message = string.Format("BsonType {0} is not a valid representation for a Dictionary.", representationOptions.Representation); throw new BsonSerializationException(message); } } if (dictionaryOptions == null) { dictionaryOptions = DictionarySerializationOptions.Defaults; } } var representation = dictionaryOptions.Representation; if (representation == DictionaryRepresentation.Dynamic) { representation = DictionaryRepresentation.Document; foreach (object key in dictionary.Keys) { var name = key as string; // check for null and type string at the same time if (name == null || name.StartsWith("$") || name.Contains(".")) { representation = DictionaryRepresentation.ArrayOfArrays; break; } } } switch (representation) { case DictionaryRepresentation.Document: bsonWriter.WriteStartDocument(); foreach (DictionaryEntry entry in dictionary) { bsonWriter.WriteName((string)entry.Key); BsonSerializer.Serialize(bsonWriter, typeof(object), entry.Value); } bsonWriter.WriteEndDocument(); break; case DictionaryRepresentation.ArrayOfArrays: bsonWriter.WriteStartArray(); foreach (DictionaryEntry entry in dictionary) { bsonWriter.WriteStartArray(); BsonSerializer.Serialize(bsonWriter, typeof(object), entry.Key); BsonSerializer.Serialize(bsonWriter, typeof(object), entry.Value); bsonWriter.WriteEndArray(); } bsonWriter.WriteEndArray(); break; case DictionaryRepresentation.ArrayOfDocuments: bsonWriter.WriteStartArray(); foreach (DictionaryEntry entry in dictionary) { bsonWriter.WriteStartDocument(); bsonWriter.WriteName("k"); BsonSerializer.Serialize(bsonWriter, typeof(object), entry.Key); bsonWriter.WriteName("v"); BsonSerializer.Serialize(bsonWriter, typeof(object), entry.Value); bsonWriter.WriteEndDocument(); } bsonWriter.WriteEndArray(); break; default: var message = string.Format("'{0}' is not a valid representation for type IDictionary.", representation); throw new BsonSerializationException(message); } } }
private static void WriteStyleParagraphProperties(BsonWriter bsonWriter, OXmlStyleParagraphProperties element) { if (element.AdjustRightIndent != null) bsonWriter.WriteBoolean("AdjustRightIndent", (bool)element.AdjustRightIndent); if (element.AutoSpaceDE != null) bsonWriter.WriteBoolean("AutoSpaceDE", (bool)element.AutoSpaceDE); if (element.AutoSpaceDN != null) bsonWriter.WriteBoolean("AutoSpaceDN", (bool)element.AutoSpaceDN); if (element.BiDi != null) bsonWriter.WriteBoolean("BiDi", (bool)element.BiDi); if (element.ContextualSpacing != null) bsonWriter.WriteBoolean("ContextualSpacing", (bool)element.ContextualSpacing); if (element.Justification != null) bsonWriter.WriteString("Justification", element.Justification.ToString()); if (element.KeepLines != null) bsonWriter.WriteBoolean("KeepLines", (bool)element.KeepLines); if (element.KeepNext != null) bsonWriter.WriteBoolean("KeepNext", (bool)element.KeepNext); if (element.Kinsoku != null) bsonWriter.WriteBoolean("Kinsoku", (bool)element.Kinsoku); if (element.MirrorIndents != null) bsonWriter.WriteBoolean("MirrorIndents", (bool)element.MirrorIndents); if (element.OutlineLevel != null) bsonWriter.WriteInt32("OutlineLevel", (int)element.OutlineLevel); if (element.OverflowPunctuation != null) bsonWriter.WriteBoolean("OverflowPunctuation", (bool)element.OverflowPunctuation); if (element.PageBreakBefore != null) bsonWriter.WriteBoolean("PageBreakBefore", (bool)element.PageBreakBefore); if (element.SnapToGrid != null) bsonWriter.WriteBoolean("SnapToGrid", (bool)element.SnapToGrid); if (element.SpacingBetweenLines != null) { bsonWriter.WriteStartDocument("SpacingBetweenLines"); WriteSpacingBetweenLines(bsonWriter, element.SpacingBetweenLines); bsonWriter.WriteEndDocument(); } if (element.SuppressAutoHyphens != null) bsonWriter.WriteBoolean("SuppressAutoHyphens", (bool)element.SuppressAutoHyphens); if (element.SuppressLineNumbers != null) bsonWriter.WriteBoolean("SuppressLineNumbers", (bool)element.SuppressLineNumbers); if (element.SuppressOverlap != null) bsonWriter.WriteBoolean("SuppressOverlap", (bool)element.SuppressOverlap); if (element.Tabs != null) { bsonWriter.WriteStartArray("Tabs"); WriteTabs(bsonWriter, element.Tabs); bsonWriter.WriteEndArray(); } if (element.TextAlignment != null) bsonWriter.WriteString("TextAlignment", element.TextAlignment.ToString()); if (element.TextBoxTightWrap != null) bsonWriter.WriteString("TextBoxTightWrap", element.TextBoxTightWrap.ToString()); if (element.TextDirection != null) bsonWriter.WriteString("TextDirection", element.TextDirection.ToString()); if (element.TopLinePunctuation != null) bsonWriter.WriteBoolean("TopLinePunctuation", (bool)element.TopLinePunctuation); if (element.WidowControl != null) bsonWriter.WriteBoolean("WidowControl", (bool)element.WidowControl); if (element.WordWrap != null) bsonWriter.WriteBoolean("WordWrap", (bool)element.WordWrap); }
//private KeyValuePair<string, string> DeserializeNameValue(BsonReader bsonReader) //{ // string key = null; // string value = null; // var bsonType = bsonReader.GetCurrentBsonType(); // if (bsonType == BsonType.Array) // { // // [["toto1", "tata1"], ["toto2", "tata2"]] // bsonReader.ReadStartArray(); // //bsonReader.ReadBsonType(); // //var keyType = keyDiscriminatorConvention.GetActualType(bsonReader, typeof(TKey)); // //var keySerializer = GetKeySerializer(keyType); // //key = (TKey)keySerializer.Deserialize(bsonReader, typeof(TKey), keyType, keyValuePairSerializationOptions.KeySerializationOptions); // //bsonReader.ReadBsonType(); // //var valueType = valueDiscriminatorConvention.GetActualType(bsonReader, typeof(TValue)); // //var valueSerializer = GetValueSerializer(valueType); // //value = (TValue)valueSerializer.Deserialize(bsonReader, typeof(TValue), valueType, keyValuePairSerializationOptions.ValueSerializationOptions); // key = bsonReader.ReadString(); // value = bsonReader.ReadString(); // bsonReader.ReadEndArray(); // } // else if (bsonType == BsonType.Document) // { // // [{ "k" : "toto1", "v" : "tata1" }, { "k" : "toto2", "v" : "tata2" }] // bsonReader.ReadStartDocument(); // var bsonTrie = new BsonTrie<bool>(); // bsonTrie.Add("k", true); // is key // bsonTrie.Add("v", false); // bool keyFound = false, valueFound = false; // bool elementFound; // bool elementIsKey; // while (bsonReader.ReadBsonType(bsonTrie, out elementFound, out elementIsKey) != BsonType.EndOfDocument) // { // var name = bsonReader.ReadName(); // if (elementFound) // { // if (elementIsKey) // { // //var keyType = keyDiscriminatorConvention.GetActualType(bsonReader, typeof(TKey)); // //var keySerializer = GetValueSerializer(keyType); // //key = (TKey)keySerializer.Deserialize(bsonReader, typeof(TKey), keyType, keyValuePairSerializationOptions.KeySerializationOptions); // key = bsonReader.ReadString(); // keyFound = true; // } // else // { // //var valueType = valueDiscriminatorConvention.GetActualType(bsonReader, typeof(TValue)); // //var valueSerializer = GetValueSerializer(valueType); // //value = (TValue)valueSerializer.Deserialize(bsonReader, typeof(TValue), valueType, keyValuePairSerializationOptions.ValueSerializationOptions); // value = bsonReader.ReadString(); // valueFound = true; // } // } // else // { // var message = string.Format("Element '{0}' is not valid for KeyValuePairs (expecting 'k' or 'v').", name); // throw new BsonSerializationException(message); // } // } // bsonReader.ReadEndDocument(); // if (!keyFound) // { // //throw new FileFormatException("KeyValuePair item was missing the 'k' element."); // throw new PBException("KeyValuePair item was missing the 'k' element."); // } // if (!valueFound) // { // //throw new FileFormatException("KeyValuePair item was missing the 'v' element."); // throw new PBException("KeyValuePair item was missing the 'v' element."); // } // } // else // { // //var message = string.Format("Cannot deserialize '{0}' from BsonType {1}.", BsonUtils.GetFriendlyTypeName(typeof(KeyValuePair<string, string>)), bsonType); // //throw new FileFormatException(message); // throw new PBException("Cannot deserialize '{0}' from BsonType {1}.", BsonUtils.GetFriendlyTypeName(typeof(KeyValuePair<string, string>)), bsonType); // } // return new KeyValuePair<string, string>(key, value); //} /// <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("NameValueCollectionSerializer.Serialize()"); if (value == null) { bsonWriter.WriteNull(); } else { // dont know why nominalType can be an object if (nominalType == typeof(object)) { var actualType = value.GetType(); bsonWriter.WriteStartDocument(); bsonWriter.WriteString("_t", TypeNameDiscriminator.GetDiscriminator(actualType)); bsonWriter.WriteName("_v"); Serialize(bsonWriter, actualType, value, options); // recursive call replacing nominalType with actualType bsonWriter.WriteEndDocument(); return; } // json Dictionary // { "toto1" : "tata1", "toto2" : "tata2" } //var dictionary = (IDictionary)value; NameValueCollection nameValueCollection = (NameValueCollection)value; var dictionarySerializationOptions = EnsureSerializationOptions(options); var dictionaryRepresentation = dictionarySerializationOptions.Representation; var keyValuePairSerializationOptions = dictionarySerializationOptions.KeyValuePairSerializationOptions; if (dictionaryRepresentation == DictionaryRepresentation.Dynamic) { // if some keys contain '$', '.' or '\0' serialize as ArrayOfArrays otherwise serialize as Document dictionaryRepresentation = DictionaryRepresentation.Document; foreach (string key in nameValueCollection.Keys) { //var name = key as string; // key might not be a string if (string.IsNullOrEmpty(key) || key[0] == '$' || key.IndexOf('.') != -1 || key.IndexOf('\0') != -1) { dictionaryRepresentation = DictionaryRepresentation.ArrayOfArrays; break; } } } switch (dictionaryRepresentation) { case DictionaryRepresentation.Document: bsonWriter.WriteStartDocument(); //foreach (DictionaryEntry dictionaryEntry in dictionary) //{ // bsonWriter.WriteName((string)dictionaryEntry.Key); // BsonSerializer.Serialize(bsonWriter, typeof(object), dictionaryEntry.Value, keyValuePairSerializationOptions.ValueSerializationOptions); //} for (int i = 0; i < nameValueCollection.Count; i++) { bsonWriter.WriteString(nameValueCollection.GetKey(i), nameValueCollection.Get(i)); } bsonWriter.WriteEndDocument(); break; case DictionaryRepresentation.ArrayOfArrays: case DictionaryRepresentation.ArrayOfDocuments: // override KeyValuePair representation if necessary var keyValuePairRepresentation = (dictionaryRepresentation == DictionaryRepresentation.ArrayOfArrays) ? BsonType.Array : BsonType.Document; if (keyValuePairSerializationOptions.Representation != keyValuePairRepresentation) { keyValuePairSerializationOptions = new KeyValuePairSerializationOptions(keyValuePairRepresentation, keyValuePairSerializationOptions.KeySerializationOptions, keyValuePairSerializationOptions.ValueSerializationOptions); } bsonWriter.WriteStartArray(); //foreach (DictionaryEntry dictionaryEntry in dictionary) for (int i = 0; i < nameValueCollection.Count; i++) { //var keyValuePair = new KeyValuePair<object, object>(dictionaryEntry.Key, dictionaryEntry.Value); var keyValuePair = new KeyValuePair<string, string>(nameValueCollection.GetKey(i), nameValueCollection.Get(i)); //_keyValuePairSerializer.Serialize(bsonWriter, typeof(KeyValuePair<object, object>), keyValuePair, keyValuePairSerializationOptions); _keyValuePairSerializer.Serialize(bsonWriter, typeof(KeyValuePair<string, string>), keyValuePair, keyValuePairSerializationOptions); } bsonWriter.WriteEndArray(); //bsonWriter.WriteStartArray(); //for (int i = 0; i < nameValueCollection.Count; i++) //{ // bsonWriter.WriteStartArray(); // bsonWriter.WriteString(nameValueCollection.GetKey(i), nameValueCollection.Get(i)); // bsonWriter.WriteEndArray(); //} //bsonWriter.WriteEndArray(); break; //case DictionaryRepresentation.ArrayOfDocuments: // bsonWriter.WriteStartArray(); // for (int i = 0; i < nameValueCollection.Count; i++) // { // bsonWriter.WriteStartDocument(); // bsonWriter.WriteString(nameValueCollection.GetKey(i), nameValueCollection.Get(i)); // bsonWriter.WriteEndDocument(); // } // bsonWriter.WriteEndArray(); // break; default: var message = string.Format("'{0}' is not a valid IDictionary representation.", dictionaryRepresentation); 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 { if (nominalType == typeof(object)) { var actualType = value.GetType(); bsonWriter.WriteStartDocument(); bsonWriter.WriteString("_t", TypeNameDiscriminator.GetDiscriminator(actualType)); bsonWriter.WriteName("_v"); Serialize(bsonWriter, actualType, value, options); bsonWriter.WriteEndDocument(); return; } var items = ((Stack)value).ToArray(); // convert to array to allow efficient access in reverse order var arraySerializationOptions = EnsureSerializationOptions<ArraySerializationOptions>(options); var itemSerializationOptions = arraySerializationOptions.ItemSerializationOptions; // serialize first pushed item first (reverse of enumeration order) bsonWriter.WriteStartArray(); for (var i = items.Length - 1; i >= 0; i--) { BsonSerializer.Serialize(bsonWriter, typeof(object), items[i], itemSerializationOptions); } bsonWriter.WriteEndArray(); } }
public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, bool serializeIdFirst ) { // note: the DateTime portion cannot be serialized as a BsonType.DateTime because it is NOT in UTC var dateTimeOffset = (DateTimeOffset) value; switch (representation) { case BsonType.Array: bsonWriter.WriteStartArray(); bsonWriter.WriteInt64("0", dateTimeOffset.DateTime.Ticks); bsonWriter.WriteInt32("1", (int) dateTimeOffset.Offset.TotalMinutes); bsonWriter.WriteEndArray(); break; case BsonType.String: bsonWriter.WriteString(XmlConvert.ToString(dateTimeOffset)); break; default: throw new BsonInternalException("Unexpected representation"); } }
/// <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) { throw new ArgumentNullException("value"); } var array = (BsonArray)value; bsonWriter.WriteStartArray(); for (int i = 0; i < array.Count; i++) { BsonValueSerializer.Instance.Serialize(bsonWriter, typeof(BsonValue), array[i], null); } 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) { if (value == null) { bsonWriter.WriteNull(); } else { if (nominalType == typeof(object)) { var actualType = value.GetType(); bsonWriter.WriteStartDocument(); bsonWriter.WriteString("_t", TypeNameDiscriminator.GetDiscriminator(actualType)); bsonWriter.WriteName("_v"); Serialize(bsonWriter, actualType, value, options); bsonWriter.WriteEndDocument(); return; } var items = (Queue)value; var arraySerializationOptions = EnsureSerializationOptions<ArraySerializationOptions>(options); var itemSerializationOptions = arraySerializationOptions.ItemSerializationOptions; bsonWriter.WriteStartArray(); foreach (var item in items) { BsonSerializer.Serialize(bsonWriter, typeof(object), item, itemSerializationOptions); } bsonWriter.WriteEndArray(); } }
public override void Serialize(BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options) { if (_trace) pb.Trace.WriteLine("WebHeaderSerializer.Serialize()"); if (value == null) { bsonWriter.WriteNull(); } else { if (nominalType == typeof(object)) { var actualType = value.GetType(); bsonWriter.WriteStartDocument(); bsonWriter.WriteString("_t", TypeNameDiscriminator.GetDiscriminator(actualType)); bsonWriter.WriteName("_v"); Serialize(bsonWriter, actualType, value, options); // recursive call replacing nominalType with actualType bsonWriter.WriteEndDocument(); return; } var headers = (WebHeaderCollection)value; bsonWriter.WriteStartDocument(); for (int i = 0; i < headers.Count; i++) { bsonWriter.WriteName(headers.GetKey(i)); string[] headerValues = headers.GetValues(i); if (headerValues.Length == 1) bsonWriter.WriteString(headerValues[0]); else { bsonWriter.WriteStartArray(); foreach (string headerValue in headerValues) { bsonWriter.WriteString(headerValue); } bsonWriter.WriteEndArray(); } } bsonWriter.WriteEndDocument(); } }
private static void SerializePolygon(BsonWriter bsonWriter, OXmlPolygon polygon) { bsonWriter.WriteStartDocument("Polygon"); if (polygon.StartPoint != null) { bsonWriter.WriteInt64("StartPointX", polygon.StartPoint.X); bsonWriter.WriteInt64("StartPointY", polygon.StartPoint.Y); } bsonWriter.WriteStartArray("LinesTo"); foreach (OXmlPoint2DType lineTo in polygon.LinesTo) { bsonWriter.WriteStartDocument(); bsonWriter.WriteInt64("X", lineTo.X); bsonWriter.WriteInt64("Y", lineTo.Y); bsonWriter.WriteEndDocument(); } bsonWriter.WriteEndArray(); if (polygon.Edited != null) bsonWriter.WriteBoolean("Edited", (bool)polygon.Edited); 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 (value == null) { bsonWriter.WriteNull(); } else { bsonWriter.WriteStartArray(); foreach (var element in (Queue)value) { BsonSerializer.Serialize(bsonWriter, typeof(object), element); } bsonWriter.WriteEndArray(); } }
public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, bool serializeIdFirst ) { if (value == null) { bsonWriter.WriteNull(); } else { bsonWriter.WriteStartArray(); int index = 0; foreach (var element in (IEnumerable) value) { bsonWriter.WriteName(index.ToString()); BsonSerializer.Serialize(bsonWriter, typeof(object), element); index++; } bsonWriter.WriteEndArray(); } }
public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, bool serializeIdFirst ) { if (value == null) { bsonWriter.WriteNull(); } else { bsonWriter.WriteStartArray(); var outputOrder = new ArrayList((Stack) value); // serialize first pushed item first (reverse of enumerator order) outputOrder.Reverse(); int index = 0; foreach (var element in outputOrder) { bsonWriter.WriteName(index.ToString()); BsonSerializer.Serialize(bsonWriter, typeof(object), element); index++; } bsonWriter.WriteEndArray(); } }
public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, bool serializeIdFirst ) { var @decimal = (Decimal) value; switch (representation) { case BsonType.Array: bsonWriter.WriteStartArray(); var bits = Decimal.GetBits(@decimal); bsonWriter.WriteInt32("0", bits[0]); bsonWriter.WriteInt32("1", bits[1]); bsonWriter.WriteInt32("2", bits[2]); bsonWriter.WriteInt32("3", bits[3]); bsonWriter.WriteEndArray(); break; case BsonType.String: bsonWriter.WriteString(XmlConvert.ToString(@decimal)); break; default: throw new BsonInternalException("Unexpected representation"); } }
/// <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 { if (nominalType == typeof(object)) { var actualType = value.GetType(); bsonWriter.WriteStartDocument(); bsonWriter.WriteString("_t", TypeNameDiscriminator.GetDiscriminator(actualType)); bsonWriter.WriteName("_v"); Serialize(bsonWriter, actualType, value, options); // recursive call replacing nominalType with actualType bsonWriter.WriteEndDocument(); return; } var dictionary = (IDictionary)value; var dictionarySerializationOptions = EnsureSerializationOptions(options); var dictionaryRepresentation = dictionarySerializationOptions.Representation; var keyValuePairSerializationOptions = dictionarySerializationOptions.KeyValuePairSerializationOptions; if (dictionaryRepresentation == DictionaryRepresentation.Dynamic) { dictionaryRepresentation = DictionaryRepresentation.Document; foreach (object key in dictionary.Keys) { var name = key as string; // key might not be a string if (name == null || (name.Length > 0 && name[0] == '$') || name.IndexOf('.') != -1) { dictionaryRepresentation = DictionaryRepresentation.ArrayOfArrays; break; } } } switch (dictionaryRepresentation) { case DictionaryRepresentation.Document: bsonWriter.WriteStartDocument(); foreach (DictionaryEntry dictionaryEntry in dictionary) { bsonWriter.WriteName((string)dictionaryEntry.Key); BsonSerializer.Serialize(bsonWriter, typeof(object), dictionaryEntry.Value, keyValuePairSerializationOptions.ValueSerializationOptions); } bsonWriter.WriteEndDocument(); break; case DictionaryRepresentation.ArrayOfArrays: case DictionaryRepresentation.ArrayOfDocuments: // override KeyValuePair representation if necessary var keyValuePairRepresentation = (dictionaryRepresentation == DictionaryRepresentation.ArrayOfArrays) ? BsonType.Array : BsonType.Document; if (keyValuePairSerializationOptions.Representation != keyValuePairRepresentation) { keyValuePairSerializationOptions = new KeyValuePairSerializationOptions( keyValuePairRepresentation, keyValuePairSerializationOptions.KeySerializationOptions, keyValuePairSerializationOptions.ValueSerializationOptions); } bsonWriter.WriteStartArray(); foreach (DictionaryEntry dictionaryEntry in dictionary) { var keyValuePair = new KeyValuePair<object, object>(dictionaryEntry.Key, dictionaryEntry.Value); _keyValuePairSerializer.Serialize( bsonWriter, typeof(KeyValuePair<object, object>), keyValuePair, keyValuePairSerializationOptions); } bsonWriter.WriteEndArray(); break; default: var message = string.Format("'{0}' is not a valid IDictionary representation.", dictionaryRepresentation); throw new BsonSerializationException(message); } } }
public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options ) { if (value == null) { bsonWriter.WriteNull(); } else { var dictionary = (IDictionary) value; if (dictionary.Keys.Cast<object>().All(o => o.GetType() == typeof(string))) { bsonWriter.WriteStartDocument(); int index = 0; foreach (DictionaryEntry entry in dictionary) { bsonWriter.WriteName((string) entry.Key); BsonSerializer.Serialize(bsonWriter, typeof(object), entry.Value); index++; } bsonWriter.WriteEndDocument(); } else { bsonWriter.WriteStartArray(); foreach (DictionaryEntry entry in dictionary) { bsonWriter.WriteStartArray(); BsonSerializer.Serialize(bsonWriter, typeof(object), entry.Key); BsonSerializer.Serialize(bsonWriter, typeof(object), entry.Value); bsonWriter.WriteEndArray(); } 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 ) { if (value == null) { bsonWriter.WriteNull(); } else { var dictionary = (IDictionary) value; var representationOptions = options as RepresentationSerializationOptions; BsonType representation; if (representationOptions == null) { representation = BsonType.Document; foreach (object key in dictionary.Keys) { var name = key as string; // check for null and type string at the same time if (name == null || name.StartsWith("$") || name.Contains(".")) { representation = BsonType.Array; break; } } } else { representation = representationOptions.Representation; } switch (representation) { case BsonType.Document: bsonWriter.WriteStartDocument(); foreach (DictionaryEntry entry in dictionary) { bsonWriter.WriteName((string) entry.Key); BsonSerializer.Serialize(bsonWriter, typeof(object), entry.Value); } bsonWriter.WriteEndDocument(); break; case BsonType.Array: bsonWriter.WriteStartArray(); foreach (DictionaryEntry entry in dictionary) { bsonWriter.WriteStartArray(); BsonSerializer.Serialize(bsonWriter, typeof(object), entry.Key); BsonSerializer.Serialize(bsonWriter, typeof(object), entry.Value); bsonWriter.WriteEndArray(); } bsonWriter.WriteEndArray(); break; default: var message = string.Format("'{0}' is not a valid representation for type IDictionary.", 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 { if (nominalType == typeof(object)) { var actualType = value.GetType(); bsonWriter.WriteStartDocument(); bsonWriter.WriteString("_t", TypeNameDiscriminator.GetDiscriminator(actualType)); bsonWriter.WriteName("_v"); Serialize(bsonWriter, actualType, value, options); // recursive call replacing nominalType with actualType bsonWriter.WriteEndDocument(); return; } var dictionary = (IDictionary)value; var dictionarySerializationOptions = EnsureSerializationOptions(options); var representation = dictionarySerializationOptions.Representation; var itemSerializationOptions = dictionarySerializationOptions.ItemSerializationOptions; if (representation == DictionaryRepresentation.Dynamic) { representation = DictionaryRepresentation.Document; foreach (object key in dictionary.Keys) { var name = key as string; // check for null and type string at the same time if (name == null || name[0] == '$' || name.IndexOf('.') != -1) { representation = DictionaryRepresentation.ArrayOfArrays; break; } } } switch (representation) { case DictionaryRepresentation.Document: bsonWriter.WriteStartDocument(); foreach (DictionaryEntry entry in dictionary) { bsonWriter.WriteName((string)entry.Key); BsonSerializer.Serialize(bsonWriter, typeof(object), entry.Value, itemSerializationOptions); } bsonWriter.WriteEndDocument(); break; case DictionaryRepresentation.ArrayOfArrays: bsonWriter.WriteStartArray(); foreach (DictionaryEntry entry in dictionary) { bsonWriter.WriteStartArray(); BsonSerializer.Serialize(bsonWriter, typeof(object), entry.Key, null); // no serialization options for key BsonSerializer.Serialize(bsonWriter, typeof(object), entry.Value, itemSerializationOptions); bsonWriter.WriteEndArray(); } bsonWriter.WriteEndArray(); break; case DictionaryRepresentation.ArrayOfDocuments: bsonWriter.WriteStartArray(); foreach (DictionaryEntry entry in dictionary) { bsonWriter.WriteStartDocument(); bsonWriter.WriteName("k"); BsonSerializer.Serialize(bsonWriter, typeof(object), entry.Key, null); // no serialization options for key bsonWriter.WriteName("v"); BsonSerializer.Serialize(bsonWriter, typeof(object), entry.Value, itemSerializationOptions); bsonWriter.WriteEndDocument(); } bsonWriter.WriteEndArray(); break; default: var message = string.Format("'{0}' is not a valid IDictionary representation.", 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 { bsonWriter.WriteStartArray(); var outputOrder = new ArrayList((Stack)value); // serialize first pushed item first (reverse of enumerator order) outputOrder.Reverse(); foreach (var element in outputOrder) { BsonSerializer.Serialize(bsonWriter, typeof(object), element); } bsonWriter.WriteEndArray(); } }
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 representation = (options == null) ? BsonType.Array : ((RepresentationSerializationOptions) options).Representation; switch (representation) { case BsonType.Array: bsonWriter.WriteStartArray(); bsonWriter.WriteInt64("0", dateTimeOffset.Ticks); bsonWriter.WriteInt32("1", (int) dateTimeOffset.Offset.TotalMinutes); bsonWriter.WriteEndArray(); break; case BsonType.Document: bsonWriter.WriteStartDocument(); bsonWriter.WriteDateTime("DateTime", 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 representation for type 'DateTimeOffset'", 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); } }
public override void Serialize( BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options ) { var decimalValue = (Decimal) value; var representation = (options == null) ? BsonType.String : ((RepresentationSerializationOptions) options).Representation; switch (representation) { case BsonType.Array: bsonWriter.WriteStartArray(); var bits = Decimal.GetBits(decimalValue); bsonWriter.WriteInt32("0", bits[0]); bsonWriter.WriteInt32("1", bits[1]); bsonWriter.WriteInt32("2", bits[2]); bsonWriter.WriteInt32("3", bits[3]); bsonWriter.WriteEndArray(); break; case BsonType.String: bsonWriter.WriteString(XmlConvert.ToString(decimalValue)); break; default: var message = string.Format("'{0}' is not a valid representation for type 'Decimal'", representation); throw new BsonSerializationException(message); } }