public override object Deserialize(BsonReader bsonReader, Type nominalType, Type actualType, IBsonSerializationOptions options)
{
object value = null;
if (bsonReader.CurrentBsonType == BsonType.Null)
{
bsonReader.ReadNull();
}
else
{
bsonReader.ReadStartArray();
var idList = new List<ObjectId>();
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
var id = (ObjectId)BsonSerializer.Deserialize(bsonReader, typeof(ObjectId));
idList.Add(id);
}
bsonReader.ReadEndArray();
if (idList.Count > 0)
{
var cursor = MongoDbProvider.Database.GetCollection(DocumentType, DocumentType.Name)
.FindAs(DocumentType, Query.In("_id", BsonArray.Create(idList)));
var documents = (IList)Activator.CreateInstance(typeof(List<>).MakeGenericType(DocumentType));
foreach (var document in cursor)
{
documents.Add(document);
}
value = documents;
}
}
return value;
}
private static bool IsRelationalAssociation(BsonReader bsonReader, Type nominalType)
{
if (bsonReader.State != BsonReaderState.Value || bsonReader.CurrentBsonType != BsonType.ObjectId)
return false;
return IsRelationalType(nominalType);
}
// public methods
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="actualType">The actual type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public override object Deserialize(BsonReader bsonReader, Type nominalType, Type actualType, // ignored
IBsonSerializationOptions options)
{
var bsonType = bsonReader.GetCurrentBsonType();
switch (bsonType)
{
case BsonType.Array: return (BsonValue)BsonArraySerializer.Instance.Deserialize(bsonReader, typeof(BsonArray), options);
case BsonType.Binary: return (BsonValue)BsonBinaryDataSerializer.Instance.Deserialize(bsonReader, typeof(BsonBinaryData), options);
case BsonType.Boolean: return (BsonValue)BsonBooleanSerializer.Instance.Deserialize(bsonReader, typeof(BsonBoolean), options);
case BsonType.DateTime: return (BsonValue)BsonDateTimeSerializer.Instance.Deserialize(bsonReader, typeof(BsonDateTime), options);
case BsonType.Document: return (BsonValue)BsonDocumentSerializer.Instance.Deserialize(bsonReader, typeof(BsonDocument), options);
case BsonType.Double: return (BsonValue)BsonDoubleSerializer.Instance.Deserialize(bsonReader, typeof(BsonDouble), options);
case BsonType.Int32: return (BsonValue)BsonInt32Serializer.Instance.Deserialize(bsonReader, typeof(BsonInt32), options);
case BsonType.Int64: return (BsonValue)BsonInt64Serializer.Instance.Deserialize(bsonReader, typeof(BsonInt64), options);
case BsonType.JavaScript: return (BsonValue)BsonJavaScriptSerializer.Instance.Deserialize(bsonReader, typeof(BsonJavaScript), options);
case BsonType.JavaScriptWithScope: return (BsonValue)BsonJavaScriptWithScopeSerializer.Instance.Deserialize(bsonReader, typeof(BsonJavaScriptWithScope), options);
case BsonType.MaxKey: return (BsonValue)BsonMaxKeySerializer.Instance.Deserialize(bsonReader, typeof(BsonMaxKey), options);
case BsonType.MinKey: return (BsonValue)BsonMinKeySerializer.Instance.Deserialize(bsonReader, typeof(BsonMinKey), options);
case BsonType.Null: return (BsonValue)BsonNullSerializer.Instance.Deserialize(bsonReader, typeof(BsonNull), options);
case BsonType.ObjectId: return (BsonValue)BsonObjectIdSerializer.Instance.Deserialize(bsonReader, typeof(BsonObjectId), options);
case BsonType.RegularExpression: return (BsonValue)BsonRegularExpressionSerializer.Instance.Deserialize(bsonReader, typeof(BsonRegularExpression), options);
case BsonType.String: return (BsonValue)BsonStringSerializer.Instance.Deserialize(bsonReader, typeof(BsonString), options);
case BsonType.Symbol: return (BsonValue)BsonSymbolSerializer.Instance.Deserialize(bsonReader, typeof(BsonSymbol), options);
case BsonType.Timestamp: return (BsonValue)BsonTimestampSerializer.Instance.Deserialize(bsonReader, typeof(BsonTimestamp), options);
case BsonType.Undefined: return (BsonValue)BsonUndefinedSerializer.Instance.Deserialize(bsonReader, typeof(BsonUndefined), options);
default:
var message = string.Format("Invalid BsonType {0}.", bsonType);
throw new BsonInternalException(message);
}
}
public override object Deserialize(BsonReader bsonReader, Type nominalType, Type actualType, IBsonSerializationOptions options)
{
int timestamp, machine, increment;
short pid;
bsonReader.ReadObjectId(out timestamp, out machine, out pid, out increment);
return new ObjectId(timestamp, machine, pid, increment).ToString();
}
public override object Deserialize(BsonReader bsonReader, Type nominalType, Type actualType, IBsonSerializationOptions options)
{
if (_trace)
pb.Trace.WriteLine("ZStringArraySerializer.Deserialize()");
VerifyTypes(nominalType, actualType, typeof(ZStringArray));
var bsonType = bsonReader.GetCurrentBsonType();
switch (bsonType)
{
case BsonType.Array:
bsonReader.ReadStartArray();
//return new ZString(bsonReader.ReadString());
var array = new List<string>();
bsonType = bsonReader.ReadBsonType();
while (bsonType != BsonType.EndOfDocument)
{
if (bsonType != BsonType.String)
throw new PBException("error ZStringArray cannot contain value of type {0}", bsonType);
var value = bsonReader.ReadString();
array.Add(value);
bsonType = bsonReader.ReadBsonType();
}
bsonReader.ReadEndArray();
return new ZStringArray(array.ToArray());
default:
throw new PBException("error cannot deserialize ZStringArray from BsonType {0}.", bsonType);
}
}
public OXmlSimpleFieldElement _Deserialize(BsonReader bsonReader, IBsonSerializationOptions options)
{
OXmlSimpleFieldElement element = new OXmlSimpleFieldElement();
while (true)
{
BsonType bsonType = bsonReader.ReadBsonType();
if (bsonType == BsonType.EndOfDocument)
break;
string name = bsonReader.ReadName();
switch (name.ToLower())
{
case "type":
if (bsonType != BsonType.String)
throw new PBException($"wrong type value {bsonType}");
string type = bsonReader.ReadString();
if (type.ToLower() != "simplefield")
throw new PBException($"invalid Type {type} when deserialize OXmlSimpleFieldElement");
break;
case "instruction":
if (bsonType == BsonType.Null)
break;
if (bsonType != BsonType.String)
throw new PBException($"wrong Instruction value {bsonType}");
element.Instruction = bsonReader.ReadString();
break;
default:
throw new PBException($"unknow SimpleField value \"{name}\"");
}
}
return element;
}
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
IBsonSerializationOptions options
)
{
var bsonType = bsonReader.GetCurrentBsonType();
if (bsonType == BsonType.Null)
{
bsonReader.ReadNull();
return null;
}
var nvc = new NameValueCollection();
bsonReader.ReadStartArray();
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
bsonReader.ReadStartArray();
var key = (string)StringSerializer.Instance.Deserialize(bsonReader, typeof(string), options);
var val = (string)StringSerializer.Instance.Deserialize(bsonReader, typeof(string), options);
bsonReader.ReadEndArray();
nvc.Add(key, val);
}
bsonReader.ReadEndArray();
return nvc;
}
// public methods
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="actualType">The actual type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
Type actualType,
IBsonSerializationOptions options)
{
VerifyTypes(nominalType, actualType, typeof(decimal));
var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options);
var bsonType = bsonReader.GetCurrentBsonType();
switch (bsonType)
{
case BsonType.Array:
var array = (BsonArray)BsonArraySerializer.Instance.Deserialize(bsonReader, typeof(BsonArray), null);
var bits = new int[4];
bits[0] = array[0].AsInt32;
bits[1] = array[1].AsInt32;
bits[2] = array[2].AsInt32;
bits[3] = array[3].AsInt32;
return new decimal(bits);
case BsonType.Double:
return representationSerializationOptions.ToDecimal(bsonReader.ReadDouble());
case BsonType.Int32:
return representationSerializationOptions.ToDecimal(bsonReader.ReadInt32());
case BsonType.Int64:
return representationSerializationOptions.ToDecimal(bsonReader.ReadInt64());
case BsonType.String:
return XmlConvert.ToDecimal(bsonReader.ReadString());
default:
var message = string.Format("Cannot deserialize Decimal from BsonType {0}.", bsonType);
throw new FileFormatException(message);
}
}
// public methods
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="actualType">The actual type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
Type actualType,
IBsonSerializationOptions options)
{
VerifyTypes(nominalType, actualType, typeof(DateTimeOffset));
BsonType bsonType = bsonReader.GetCurrentBsonType();
long ticks;
TimeSpan offset;
switch (bsonType)
{
case BsonType.Array:
bsonReader.ReadStartArray();
ticks = bsonReader.ReadInt64();
offset = TimeSpan.FromMinutes(bsonReader.ReadInt32());
bsonReader.ReadEndArray();
return new DateTimeOffset(ticks, offset);
case BsonType.Document:
bsonReader.ReadStartDocument();
bsonReader.ReadDateTime("DateTime"); // ignore value
ticks = bsonReader.ReadInt64("Ticks");
offset = TimeSpan.FromMinutes(bsonReader.ReadInt32("Offset"));
bsonReader.ReadEndDocument();
return new DateTimeOffset(ticks, offset);
case BsonType.String:
return XmlConvert.ToDateTimeOffset(bsonReader.ReadString());
default:
var message = string.Format("Cannot deserialize DateTimeOffset from BsonType {0}.", bsonType);
throw new FileFormatException(message);
}
}
// public methods
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="actualType">The actual type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
Type actualType,
IBsonSerializationOptions options)
{
VerifyTypes(nominalType, actualType, typeof(bool));
var bsonType = bsonReader.GetCurrentBsonType();
switch (bsonType)
{
case BsonType.Boolean:
return bsonReader.ReadBoolean();
case BsonType.Double:
return bsonReader.ReadDouble() != 0.0;
case BsonType.Int32:
return bsonReader.ReadInt32() != 0;
case BsonType.Int64:
return bsonReader.ReadInt64() != 0;
case BsonType.Null:
bsonReader.ReadNull();
return false;
case BsonType.String:
return XmlConvert.ToBoolean(bsonReader.ReadString().ToLower());
default:
var message = string.Format("Cannot deserialize Boolean from BsonType {0}.", bsonType);
throw new FileFormatException(message);
}
}
// public methods
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="actualType">The actual type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>
/// An object.
/// </returns>
public override object Deserialize(BsonReader bsonReader, Type nominalType, Type actualType, IBsonSerializationOptions options)
{
if (bsonReader.GetCurrentBsonType() == BsonType.Null)
{
bsonReader.ReadNull();
return null;
}
else
{
bsonReader.ReadStartDocument();
DeserializeType(bsonReader, "link");
bsonReader.ReadName("properties");
bsonReader.ReadStartDocument();
var href = bsonReader.ReadString("href");
string hrefType = null;
if (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
hrefType = bsonReader.ReadString("type");
}
bsonReader.ReadEndDocument();
bsonReader.ReadEndDocument();
return new GeoJsonLinkedCoordinateReferenceSystem(href, hrefType);
}
}
public object Deserialize(BsonReader bsonReader, Type nominalType, Type actualType, IBsonSerializationOptions options)
{
object value = null;
var valueType = actualType.GetConceptValueType();
if (valueType == typeof(Guid)) {
var guidBytes = new byte[16];
BsonBinarySubType subType;
bsonReader.ReadBinaryData (out guidBytes, out subType);
value = new Guid (guidBytes);
} else if (valueType == typeof(double))
value = bsonReader.ReadDouble ();
else if (valueType == typeof(float))
value = (float)bsonReader.ReadDouble ();
else if (valueType == typeof(Int32))
value = bsonReader.ReadInt32 ();
else if (valueType == typeof(Int64))
value = bsonReader.ReadInt64 ();
else if (valueType == typeof(bool))
value = bsonReader.ReadBoolean ();
else if (valueType == typeof(string))
value = bsonReader.ReadString ();
else if (valueType == typeof(decimal))
value = decimal.Parse (bsonReader.ReadString ());
var concept = ConceptFactory.CreateConceptInstance(actualType, value);
return concept;
}
object IBsonSerializable.Deserialize(
BsonReader bsonReader,
Type nominalType,
IBsonSerializationOptions options
) {
throw new InvalidOperationException();
}
// public methods
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="actualType">The actual type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
Type actualType,
IBsonSerializationOptions options)
{
VerifyTypes(nominalType, actualType, typeof(double));
var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options);
var bsonType = bsonReader.GetCurrentBsonType();
switch (bsonType)
{
case BsonType.Double:
return bsonReader.ReadDouble();
case BsonType.Int32:
return representationSerializationOptions.ToDouble(bsonReader.ReadInt32());
case BsonType.Int64:
return representationSerializationOptions.ToDouble(bsonReader.ReadInt64());
case BsonType.String:
return XmlConvert.ToDouble(bsonReader.ReadString());
default:
var message = string.Format("Cannot deserialize Double from BsonType {0}.", bsonType);
throw new FileFormatException(message);
}
}
private static OXmlPageSize ReadPageSize(BsonReader bsonReader)
{
bsonReader.ReadStartDocument();
OXmlPageSize value = new OXmlPageSize();
while (true)
{
BsonType bsonType = bsonReader.ReadBsonType();
if (bsonType == BsonType.EndOfDocument)
break;
string name = bsonReader.ReadName();
switch (name.ToLower())
{
case "width":
if (bsonType == BsonType.Null)
break;
if (bsonType != BsonType.Int32)
throw new PBException($"wrong PageSize width value {bsonType}");
value.Width = bsonReader.ReadInt32();
break;
case "height":
if (bsonType == BsonType.Null)
break;
if (bsonType != BsonType.Int32)
throw new PBException($"wrong PageSize height value {bsonType}");
value.Height = bsonReader.ReadInt32();
break;
default:
throw new PBException($"unknow PageSize value \"{name}\"");
}
}
bsonReader.ReadEndDocument();
return value;
}
// public methods
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="actualType">The actual type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
Type actualType,
IBsonSerializationOptions options)
{
VerifyTypes(nominalType, actualType, typeof(CultureInfo));
var bsonType = bsonReader.GetCurrentBsonType();
switch (bsonType)
{
case BsonType.Null:
bsonReader.ReadNull();
return null;
case BsonType.Document:
bsonReader.ReadStartDocument();
var name = bsonReader.ReadString("Name");
var useUserOverride = bsonReader.ReadBoolean("UseUserOverride");
bsonReader.ReadEndDocument();
return new CultureInfo(name, useUserOverride);
case BsonType.String:
return new CultureInfo(bsonReader.ReadString());
default:
var message = string.Format("Cannot deserialize CultureInfo from BsonType {0}.", bsonType);
throw new FileFormatException(message);
}
}
public override object Deserialize(BsonReader bsonReader, Type nominalType, Type actualType, IBsonSerializationOptions options)
{
if (bsonReader.CurrentBsonType == BsonType.Int32)
return bsonReader.ReadInt32().ToString();
throw new InvalidOperationException();
}
public OXmlOpenHeaderElement _Deserialize(BsonReader bsonReader, IBsonSerializationOptions options)
{
OXmlOpenHeaderElement element = new OXmlOpenHeaderElement();
while (true)
{
BsonType bsonType = bsonReader.ReadBsonType();
if (bsonType == BsonType.EndOfDocument)
break;
string name = bsonReader.ReadName();
switch (name.ToLower())
{
case "type":
if (bsonType != BsonType.String)
throw new PBException($"wrong type value {bsonType}");
string type = bsonReader.ReadString();
//"openfooter"
if (type.ToLower() != "openheader")
throw new PBException($"invalid Type {type} when deserialize OXmlOpenHeader");
break;
case "headertype":
if (bsonType == BsonType.Null)
break;
if (bsonType != BsonType.String)
throw new PBException($"wrong HeaderType value {bsonType}");
element.HeaderType = bsonReader.ReadString().zParseEnum<HeaderFooterValues>();
break;
default:
//OpenHeaderFooter
throw new PBException($"unknow OpenHeader value \"{name}\"");
}
}
return element;
}
public object Deserialize(
BsonReader bsonReader,
Type nominalType
)
{
throw new InvalidOperationException("Deserialize not valid for BsonDocumentWrapper");
}
public OXmlParagraphElement _Deserialize(BsonReader bsonReader, IBsonSerializationOptions options)
{
OXmlParagraphElement paragraph = new OXmlParagraphElement();
while (true)
{
BsonType bsonType = bsonReader.ReadBsonType();
if (bsonType == BsonType.EndOfDocument)
break;
//if (bsonType != BsonType.String)
// throw new PBException("error ZStringArray cannot contain value of type {0}", bsonType);
//var value = bsonReader.ReadString();
string name = bsonReader.ReadName();
switch (name.ToLower())
{
case "type":
if (bsonType != BsonType.String)
throw new PBException($"wrong type value {bsonType}");
string type = bsonReader.ReadString();
if (type.ToLower() != "paragraph")
throw new PBException($"invalid Type {type} when deserialize OXmlParagraphElement");
break;
case "style":
if (bsonType == BsonType.Null)
break;
if (bsonType != BsonType.String)
throw new PBException($"wrong style value {bsonType}");
paragraph.Style = bsonReader.ReadString();
break;
default:
throw new PBException($"unknow Paragraph value \"{name}\"");
}
}
return paragraph;
}
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
IBsonSerializationOptions options
) {
return XmlConvert.ToDateTime(bsonReader.ReadString(), XmlDateTimeSerializationMode.RoundtripKind);
}
public void TestBookmark() {
var json = "{ \"x\" : 1, \"y\" : 2 }";
using (bsonReader = BsonReader.Create(json)) {
// do everything twice returning to bookmark in between
var bookmark = bsonReader.GetBookmark();
Assert.AreEqual(BsonType.Document, bsonReader.ReadBsonType());
bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual(BsonType.Document, bsonReader.ReadBsonType());
bookmark = bsonReader.GetBookmark();
bsonReader.ReadStartDocument();
bsonReader.ReturnToBookmark(bookmark);
bsonReader.ReadStartDocument();
bookmark = bsonReader.GetBookmark();
Assert.AreEqual(BsonType.Int32, bsonReader.ReadBsonType());
bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual(BsonType.Int32, bsonReader.ReadBsonType());
bookmark = bsonReader.GetBookmark();
Assert.AreEqual("x", bsonReader.ReadName());
bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual("x", bsonReader.ReadName());
bookmark = bsonReader.GetBookmark();
Assert.AreEqual(1, bsonReader.ReadInt32());
bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual(1, bsonReader.ReadInt32());
bookmark = bsonReader.GetBookmark();
Assert.AreEqual(BsonType.Int32, bsonReader.ReadBsonType());
bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual(BsonType.Int32, bsonReader.ReadBsonType());
bookmark = bsonReader.GetBookmark();
Assert.AreEqual("y", bsonReader.ReadName());
bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual("y", bsonReader.ReadName());
bookmark = bsonReader.GetBookmark();
Assert.AreEqual(2, bsonReader.ReadInt32());
bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual(2, bsonReader.ReadInt32());
bookmark = bsonReader.GetBookmark();
Assert.AreEqual(BsonType.EndOfDocument, bsonReader.ReadBsonType());
bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual(BsonType.EndOfDocument, bsonReader.ReadBsonType());
bookmark = bsonReader.GetBookmark();
bsonReader.ReadEndDocument();
bsonReader.ReturnToBookmark(bookmark);
bsonReader.ReadEndDocument();
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize<BsonDocument>(new StringReader(json)).ToJson());
}
public override object Deserialize(BsonReader bsonReader, Type nominalType, IBsonSerializationOptions options)
{
// read an ObjectId from the database but convert it to a string before returning it
int timestamp, machine, increment;
short pid;
bsonReader.ReadObjectId(out timestamp, out machine, out pid, out increment);
return new ObjectId(timestamp, machine, pid, increment).ToString();
}
public bool Read()
{
Index++;
if (Index >= Cursor.Count())
return false;
m_reader = BsonReader.Create(Cursor.ElementAt(Index));
return true;
}
// public methods
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="actualType">The actual type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
Type actualType,
IBsonSerializationOptions options)
{
throw new NotSupportedException();
}
public object Deserialize(
BsonReader bsonReader,
Type nominalType
)
{
var message = string.Format("Deserialize method cannot be called on a {0}", this.GetType().Name);
throw new InvalidOperationException(message);
}
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="actualType">The actual type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public object Deserialize(
BsonReader bsonReader,
Type nominalType,
Type actualType,
IBsonSerializationOptions options)
{
var value = (IBsonSerializable)Activator.CreateInstance(actualType, true); // private default constructor OK
return value.Deserialize(bsonReader, nominalType, options);
}
// protected methods
protected void DeserializeType(BsonReader bsonReader, string expectedType)
{
var type = bsonReader.ReadString("type");
if (type != expectedType)
{
var message = string.Format("Expected type to be '{0}'.", expectedType);
throw new FormatException(message);
}
}
// public methods
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="actualType">The actual type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
Type actualType,
IBsonSerializationOptions options)
{
var arraySerializationOptions = EnsureSerializationOptions<ArraySerializationOptions>(options);
var itemSerializationOptions = arraySerializationOptions.ItemSerializationOptions;
var bsonType = bsonReader.GetCurrentBsonType();
switch (bsonType)
{
case BsonType.Null:
bsonReader.ReadNull();
return null;
case BsonType.Array:
var instance = CreateInstance(actualType);
var itemDiscriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(typeof(object));
Type lastItemType = null;
IBsonSerializer lastItemSerializer = null;
bsonReader.ReadStartArray();
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
var itemType = itemDiscriminatorConvention.GetActualType(bsonReader, typeof(object));
IBsonSerializer itemSerializer;
if (itemType == lastItemType)
{
itemSerializer = lastItemSerializer;
}
else
{
itemSerializer = BsonSerializer.LookupSerializer(itemType);
lastItemType = itemType;
lastItemSerializer = itemSerializer;
}
var item = itemSerializer.Deserialize(bsonReader, typeof(object), itemType, itemSerializationOptions);
AddItem(instance, item);
}
bsonReader.ReadEndArray();
return FinalizeResult(instance, actualType);
case BsonType.Document:
bsonReader.ReadStartDocument();
bsonReader.ReadString("_t"); // skip over discriminator
bsonReader.ReadName("_v");
var value = Deserialize(bsonReader, actualType, actualType, options);
bsonReader.ReadEndDocument();
return value;
default:
var message = string.Format("Can't deserialize a {0} from BsonType {1}.", nominalType.FullName, bsonType);
throw new FileFormatException(message);
}
}
public void TestArrayEmpty() {
var json = "[]";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.Array, bsonReader.ReadBsonType());
bsonReader.ReadStartArray();
Assert.AreEqual(BsonType.EndOfDocument, bsonReader.ReadBsonType());
bsonReader.ReadEndArray();
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize<BsonArray>(new StringReader(json)).ToJson());
}
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="actualType">The actual type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
Type actualType,
IBsonSerializationOptions options
)
{
VerifyTypes(nominalType, actualType, typeof(T[, , ]));
var bsonType = bsonReader.CurrentBsonType;
string message;
switch (bsonType)
{
case BsonType.Null:
bsonReader.ReadNull();
return(null);
case BsonType.Array:
bsonReader.ReadStartArray();
var outerList = new List <List <List <T> > >();
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
bsonReader.ReadStartArray();
var middleList = new List <List <T> >();
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
bsonReader.ReadStartArray();
var innerList = new List <T>();
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
var element = BsonSerializer.Deserialize <T>(bsonReader);
innerList.Add(element);
}
bsonReader.ReadEndArray();
middleList.Add(innerList);
}
bsonReader.ReadEndArray();
outerList.Add(middleList);
}
bsonReader.ReadEndArray();
var length1 = outerList.Count;
var length2 = (length1 == 0) ? 0 : outerList[0].Count;
var length3 = (length2 == 0) ? 0 : outerList[0][0].Count;
var array = new T[length1, length2, length3];
for (int i = 0; i < length1; i++)
{
var middleList = outerList[i];
if (middleList.Count != length2)
{
message = string.Format("Middle list {0} is of length {1} but should be of length {2}.", i, middleList.Count, length2);
throw new FileFormatException(message);
}
for (int j = 0; j < length2; j++)
{
var innerList = middleList[j];
if (innerList.Count != length3)
{
message = string.Format("Inner list {0} is of length {1} but should be of length {2}.", j, innerList.Count, length3);
throw new FileFormatException(message);
}
for (int k = 0; k < length3; k++)
{
array[i, j, k] = innerList[k];
}
}
}
return(array);
case BsonType.Document:
bsonReader.ReadStartDocument();
bsonReader.ReadString("_t"); // skip over discriminator
bsonReader.ReadName("_v");
var value = Deserialize(bsonReader, actualType, actualType, options);
bsonReader.ReadEndDocument();
return(value);
default:
message = string.Format("Can't deserialize a {0} from BsonType {1}.", actualType.FullName, bsonType);
throw new FileFormatException(message);
}
}
//public static WebHeaderSerializer Instance { get { return __instance; } }
public override object Deserialize(BsonReader bsonReader, Type nominalType, Type actualType, IBsonSerializationOptions options)
{
if (_trace)
{
pb.Trace.WriteLine("WebHeaderSerializer.Deserialize()");
}
var bsonType = bsonReader.GetCurrentBsonType();
if (bsonType == BsonType.Null)
{
bsonReader.ReadNull();
return(null);
}
else if (bsonType == BsonType.Document)
{
if (nominalType == typeof(object))
{
bsonReader.ReadStartDocument();
bsonReader.ReadString("_t"); // skip over discriminator
bsonReader.ReadName("_v");
var value = Deserialize(bsonReader, actualType, options); // recursive call replacing nominalType with actualType
bsonReader.ReadEndDocument();
return(value);
}
var headers = new WebHeaderCollection();
bsonReader.ReadStartDocument();
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
string key = bsonReader.ReadName();
bsonType = bsonReader.GetCurrentBsonType();
if (bsonType == BsonType.String)
{
string value = bsonReader.ReadString();
headers.Add(key, value);
}
else if (bsonType == BsonType.Array)
{
bsonReader.ReadStartArray();
bsonType = bsonReader.ReadBsonType();
while (bsonType != BsonType.EndOfDocument)
{
if (bsonType != BsonType.String)
{
throw new PBException("invalid BsonType {0} for header array \"{1}\" value deserialize WebHeaderCollection.", bsonType, key);
}
string value = bsonReader.ReadString();
headers.Add(key, value);
bsonType = bsonReader.ReadBsonType();
}
bsonReader.ReadEndArray();
}
else
{
throw new PBException("error deserialize WebHeaderCollection, invalid BsonType {0} for \"{1}\".", bsonType, key);
}
}
bsonReader.ReadEndDocument();
return(headers);
}
else
{
throw new PBException("Can't deserialize a {0} from BsonType {1}.", nominalType.FullName, bsonType);
}
}
public static int b2j(string bfile, string jfile)
{
try
{
Stream textReader = File.OpenRead(bfile);
bool need_root = false;
if (!arguments.ContainsKey("noroot"))
{
using (BsonReader reader = new BsonReader(textReader))
{
while (reader.Read())
{
if (reader.TokenType != JsonToken.PropertyName && reader.TokenType == JsonToken.StartObject)
{
continue;
}
if ((string)reader.Value != "root")
{
need_root = true;
}
break;
}
}
}
textReader.Close();
textReader = File.OpenRead(bfile);
using (BsonReader reader = new BsonReader(textReader))
{
var outFile = jfile;
reader.Encoding = Encoding.GetEncoding(1251);
if (jfile == null)
{
outFile = bfile.Replace(".bson", ".json");
}
TextWriter stm = new StreamWriter(outFile, false, Encoding.GetEncoding(1251));
using (JsonTextWriter jsonWriter = new JsonTextWriter(stm))
{
jsonWriter.Formatting = Formatting.Indented;
if (need_root)
{
jsonWriter.WriteStartObject();
jsonWriter.WritePropertyName("root");
}
while (reader.Read())
{
jsonWriter.WriteToken(reader);
}
if (need_root)
{
jsonWriter.WriteEndObject();
}
}
}
}
catch (Exception ex)
{
Console.WriteLine("Exception: " + ex.Message);
return(2);
}
return(0);
}
public override IXPloitSocketMsg Deserialize(Type type, Encoding codec, byte[] data, int index, int length)
{
using (MemoryStream ms = new MemoryStream(data, index, length))
using (BsonReader read = new BsonReader(ms))
return((IXPloitSocketMsg)Serializer.Deserialize(read, type));
}
public void WriteValues()
{
byte[] data = MiscellaneousUtils.HexToBytes("8C-00-00-00-12-30-00-FF-FF-FF-FF-FF-FF-FF-7F-12-31-00-FF-FF-FF-FF-FF-FF-FF-7F-10-32-00-FF-FF-FF-7F-10-33-00-FF-FF-FF-7F-10-34-00-FF-00-00-00-10-35-00-7F-00-00-00-02-36-00-02-00-00-00-61-00-01-37-00-00-00-00-00-00-00-F0-45-01-38-00-FF-FF-FF-FF-FF-FF-EF-7F-01-39-00-00-00-00-E0-FF-FF-EF-47-08-31-30-00-01-05-31-31-00-05-00-00-00-02-00-01-02-03-04-09-31-32-00-40-C5-E2-BA-E3-00-00-00-09-31-33-00-40-C5-E2-BA-E3-00-00-00-00");
MemoryStream ms = new MemoryStream(data);
BsonReader reader = new BsonReader(ms);
reader.ReadRootValueAsArray = true;
reader.DateTimeKindHandling = DateTimeKind.Utc;
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.StartArray, reader.TokenType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
Assert.AreEqual(long.MaxValue, reader.Value);
Assert.AreEqual(typeof(long), reader.ValueType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
Assert.AreEqual(long.MaxValue, reader.Value);
Assert.AreEqual(typeof(long), reader.ValueType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
Assert.AreEqual(int.MaxValue, reader.Value);
Assert.AreEqual(typeof(long), reader.ValueType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
Assert.AreEqual(int.MaxValue, reader.Value);
Assert.AreEqual(typeof(long), reader.ValueType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
Assert.AreEqual(byte.MaxValue, reader.Value);
Assert.AreEqual(typeof(long), reader.ValueType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Integer, reader.TokenType);
Assert.AreEqual(sbyte.MaxValue, reader.Value);
Assert.AreEqual(typeof(long), reader.ValueType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.String, reader.TokenType);
Assert.AreEqual("a", reader.Value);
Assert.AreEqual(typeof(string), reader.ValueType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Float, reader.TokenType);
Assert.AreEqual(decimal.MaxValue, reader.Value);
Assert.AreEqual(typeof(double), reader.ValueType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Float, reader.TokenType);
Assert.AreEqual(double.MaxValue, reader.Value);
Assert.AreEqual(typeof(double), reader.ValueType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Float, reader.TokenType);
Assert.AreEqual(float.MaxValue, reader.Value);
Assert.AreEqual(typeof(double), reader.ValueType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Boolean, reader.TokenType);
Assert.AreEqual(true, reader.Value);
Assert.AreEqual(typeof(bool), reader.ValueType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Bytes, reader.TokenType);
Assert.AreEqual(new byte[] { 0, 1, 2, 3, 4 }, reader.Value);
Assert.AreEqual(typeof(byte[]), reader.ValueType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Date, reader.TokenType);
Assert.AreEqual(new DateTime(2000, 12, 29, 12, 30, 0, DateTimeKind.Utc), reader.Value);
Assert.AreEqual(typeof(DateTime), reader.ValueType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.Date, reader.TokenType);
Assert.AreEqual(new DateTime(2000, 12, 29, 12, 30, 0, DateTimeKind.Utc), reader.Value);
Assert.AreEqual(typeof(DateTime), reader.ValueType);
Assert.IsTrue(reader.Read());
Assert.AreEqual(JsonToken.EndArray, reader.TokenType);
Assert.IsFalse(reader.Read());
}
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <typeparam name="TNominalType">The nominal type of the object.</typeparam>
/// <param name="bsonReader">The BsonReader.</param>
/// <returns>A TNominalType.</returns>
public static TNominalType Deserialize <TNominalType>(BsonReader bsonReader)
{
return((TNominalType)Deserialize(bsonReader, typeof(TNominalType)));
}
public static Response Decode(int code, byte[] arr)
{
MemoryStream ms = new MemoryStream(arr);
BsonReader reader = new BsonReader(ms);
JsonSerializer serializer = new JsonSerializer();
Response response = null;
switch (code)
{
case SignupResponse.MESSAGE_CODE:
response = serializer.Deserialize <SignupResponse>(reader);
break;
case LoginResponse.MESSAGE_CODE:
response = serializer.Deserialize <LoginResponse>(reader);
break;
case GetStatisticsResponse.MESSAGE_CODE:
response = serializer.Deserialize <GetStatisticsResponse>(reader);
break;
case BestScoresResponse.MESSAGE_CODE:
response = serializer.Deserialize <BestScoresResponse>(reader);
break;
case LogoutResponse.MESSAGE_CODE:
response = serializer.Deserialize <LogoutResponse>(reader);
break;
case CreateRoomResponse.MESSAGE_CODE:
response = serializer.Deserialize <CreateRoomResponse>(reader);
break;
case GetRoomsResponse.MESSAGE_CODE:
response = serializer.Deserialize <GetRoomsResponse>(reader);
break;
case JoinRoomResponse.MESSAGE_CODE:
response = serializer.Deserialize <JoinRoomResponse>(reader);
break;
case GetRoomStateResponse.MESSAGE_CODE:
response = serializer.Deserialize <GetRoomStateResponse>(reader);
break;
case CloseRoomResponse.MESSAGE_CODE:
response = serializer.Deserialize <CloseRoomResponse>(reader);
break;
case LeaveRoomResponse.MESSAGE_CODE:
response = serializer.Deserialize <LeaveRoomResponse>(reader);
break;
case StartGameResponse.MESSAGE_CODE:
response = serializer.Deserialize <StartGameResponse>(reader);
break;
case GetQuestionResponse.MESSAGE_CODE:
response = serializer.Deserialize <GetQuestionResponse>(reader);
break;
case SubmitAnswerResponse.MESSAGE_CODE:
response = serializer.Deserialize <SubmitAnswerResponse>(reader);
break;
case GetGameResultResponse.MESSAGE_CODE:
response = serializer.Deserialize <GetGameResultResponse>(reader);
break;
case LeaveGameResponse.MESSAGE_CODE:
response = serializer.Deserialize <LeaveGameResponse>(reader);
break;
default:
break;
}
return(response);
}
public object Deserialize(BsonReader bsonReader, Type nominalType, IBsonSerializationOptions options)
{
return(Deserialize(bsonReader));
}
// public methods
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="actualType">The actual type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
Type actualType,
IBsonSerializationOptions options)
{
VerifyTypes(nominalType, actualType, typeof(KeyValuePair <TKey, TValue>));
var keyValuePairSerializationOptions = EnsureSerializationOptions <KeyValuePairSerializationOptions>(options);
var keyDiscriminatorConvention = GetKeyDiscriminatorConvention();
var valueDiscriminatorConvention = GetValueDiscriminatorConvention();
TKey key;
TValue value;
var bsonType = bsonReader.GetCurrentBsonType();
if (bsonType == BsonType.Array)
{
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);
bsonReader.ReadEndArray();
}
else if (bsonType == BsonType.Document)
{
bsonReader.ReadStartDocument();
key = default(TKey);
value = default(TValue);
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);
keyFound = true;
}
else
{
var valueType = valueDiscriminatorConvention.GetActualType(bsonReader, typeof(TValue));
var valueSerializer = GetValueSerializer(valueType);
value = (TValue)valueSerializer.Deserialize(bsonReader, typeof(TValue), valueType, keyValuePairSerializationOptions.ValueSerializationOptions);
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.");
}
if (!valueFound)
{
throw new FileFormatException("KeyValuePair item was missing the 'v' element.");
}
}
else
{
var message = string.Format(
"Cannot deserialize '{0}' from BsonType {1}.",
BsonUtils.GetFriendlyTypeName(typeof(KeyValuePair <TKey, TValue>)),
bsonType);
throw new FileFormatException(message);
}
return(new KeyValuePair <TKey, TValue>(key, value));
}
public async Task Attachments()
{
var destination = new DatabaseDestination(Database);
var options = new DatabaseSmugglerOptionsServerSide
{
OperateOnTypes = DatabaseItemType.Attachments,
SkipRevisionCreation = true
};
destination.Initialize(options, null, buildVersion: default);
using (var documentActions = destination.Documents())
using (var buffered = new BufferedStream(RequestBodyStream()))
#pragma warning disable CS0618 // Type or member is obsolete
using (var reader = new BsonReader(buffered))
#pragma warning restore CS0618 // Type or member is obsolete
{
var result = LegacyAttachmentUtils.GetObject(reader);
const string idProperty = "@id";
const string etagProperty = "@etag";
const string metadataProperty = "@metadata";
const string dataProperty = "data";
string lastAttachmentEtag = null;
var progress = new SmugglerProgressBase.CountsWithLastEtagAndAttachments();
foreach (var attachmentObject in result.Values)
{
if (!(attachmentObject is Dictionary <string, object> attachmentDictionary))
{
throw new InvalidDataException("attachmentObject isn't a Dictionary<string, object>");
}
if (attachmentDictionary.TryGetValue(idProperty, out var attachmentKeyObject) == false)
{
throw new InvalidDataException($"{idProperty} doesn't exist");
}
if (!(attachmentKeyObject is string attachmentKey))
{
throw new InvalidDataException($"{idProperty} isn't of type string");
}
if (attachmentDictionary.TryGetValue(etagProperty, out var lastAttachmentEtagObject) == false)
{
throw new InvalidDataException($"{etagProperty} doesn't exist");
}
if (!(lastAttachmentEtagObject is byte[] lastAttachmentEtagByteArray))
{
throw new InvalidDataException($"{etagProperty} isn't of type byte[]");
}
lastAttachmentEtag = LegacyAttachmentUtils.ByteArrayToEtagString(lastAttachmentEtagByteArray);
if (attachmentDictionary.TryGetValue(metadataProperty, out object metadataObject) == false)
{
throw new InvalidDataException($"{metadataProperty} doesn't exist");
}
if (!(metadataObject is Dictionary <string, object> metadata))
{
throw new InvalidDataException($"{idProperty} isn't of type string");
}
if (metadata.TryGetValue("Raven-Delete-Marker", out var deletedObject) && deletedObject is bool deletedObjectAsBool && deletedObjectAsBool)
{
var id = StreamSource.GetLegacyAttachmentId(attachmentKey);
documentActions.DeleteDocument(id);
continue;
}
var djv = new DynamicJsonValue();
foreach (var keyValue in metadata)
{
var key = keyValue.Key;
if (key.Equals("Raven-Replication-Source") ||
key.Equals("Raven-Replication-Version") ||
key.Equals("Raven-Replication-History"))
{
continue;
}
djv[key] = keyValue.Value;
}
var contextToUse = documentActions.GetContextForNewDocument();
var metadataBlittable = contextToUse.ReadObject(djv, "metadata");
if (attachmentDictionary.TryGetValue(dataProperty, out object dataObject) == false)
{
throw new InvalidDataException($"{dataProperty} doesn't exist");
}
if (!(dataObject is byte[] data))
{
throw new InvalidDataException($"{dataProperty} isn't of type byte[]");
}
using (var dataStream = new MemoryStream(data))
{
var attachment = new DocumentItem.AttachmentStream
{
Stream = documentActions.GetTempStream()
};
var attachmentDetails = StreamSource.GenerateLegacyAttachmentDetails(contextToUse, dataStream, attachmentKey, metadataBlittable, ref attachment);
var documentItem = new DocumentItem
{
Document = new Document
{
Data = StreamSource.WriteDummyDocumentForAttachment(contextToUse, attachmentDetails),
Id = attachmentDetails.Id,
ChangeVector = string.Empty,
Flags = DocumentFlags.HasAttachments,
LastModified = Database.Time.GetUtcNow()
},
Attachments = new List <DocumentItem.AttachmentStream>
{
attachment
}
};
documentActions.WriteDocument(documentItem, progress);
}
}
using (ContextPool.AllocateOperationContext(out DocumentsOperationContext context))
{
var replicationSource = GetSourceReplicationInformation(context, GetRemoteServerInstanceId(), out var documentId);
replicationSource.LastAttachmentEtag = lastAttachmentEtag;
replicationSource.Source = GetFromServer();
replicationSource.LastModified = DateTime.UtcNow;
await SaveSourceReplicationInformation(replicationSource, context, documentId);
}
}
}
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="actualType">The actual type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public object Deserialize(
BsonReader bsonReader,
Type nominalType,
Type actualType,
IBsonSerializationOptions options
)
{
VerifyNominalType(nominalType);
if (bsonReader.CurrentBsonType == Bson.BsonType.Null)
{
bsonReader.ReadNull();
return(null);
}
else
{
if (actualType.IsValueType)
{
var message = string.Format("Value class {0} cannot be deserialized.", actualType.FullName);
throw new BsonSerializationException(message);
}
var classMap = BsonClassMap.LookupClassMap(actualType);
if (classMap.IsAnonymous)
{
throw new InvalidOperationException("Anonymous class cannot be deserialized.");
}
var obj = classMap.CreateInstance();
bsonReader.ReadStartDocument();
var missingElementMemberMaps = new HashSet <BsonMemberMap>(classMap.MemberMaps); // make a copy!
var discriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(nominalType);
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
var elementName = bsonReader.ReadName();
if (elementName == discriminatorConvention.ElementName)
{
bsonReader.SkipValue(); // skip over discriminator
continue;
}
var memberMap = classMap.GetMemberMapForElement(elementName);
if (memberMap != null && memberMap != classMap.ExtraElementsMemberMap)
{
DeserializeMember(bsonReader, obj, memberMap);
missingElementMemberMaps.Remove(memberMap);
}
else
{
if (classMap.ExtraElementsMemberMap != null)
{
DeserializeExtraElement(bsonReader, obj, elementName, classMap.ExtraElementsMemberMap);
}
else if (classMap.IgnoreExtraElements)
{
bsonReader.SkipValue();
}
else
{
string message = string.Format("Unexpected element '{0}'.", elementName);
throw new FileFormatException(message);
}
}
}
bsonReader.ReadEndDocument();
foreach (var memberMap in missingElementMemberMaps)
{
if (memberMap.IsRequired)
{
var message = string.Format("Required element '{0}' is missing.", memberMap.ElementName);
throw new FileFormatException(message);
}
if (memberMap.HasDefaultValue)
{
memberMap.ApplyDefaultValue(obj);
}
}
return(obj);
}
}
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="actualType">The actual type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
Type actualType,
IBsonSerializationOptions options
)
{
VerifyTypes(nominalType, actualType, typeof(DateTime));
var dateTimeOptions = (options == null) ? DateTimeSerializationOptions.Defaults : (DateTimeSerializationOptions)options;
DateTime value;
var bsonType = bsonReader.CurrentBsonType;
switch (bsonType)
{
case BsonType.DateTime:
// use an intermediate BsonDateTime so MinValue and MaxValue are handled correctly
value = BsonDateTime.Create(bsonReader.ReadDateTime()).Value;
break;
case BsonType.Document:
bsonReader.ReadStartDocument();
bsonReader.ReadDateTime("DateTime"); // ignore value (use Ticks instead)
value = new DateTime(bsonReader.ReadInt64("Ticks"), DateTimeKind.Utc);
bsonReader.ReadEndDocument();
break;
case BsonType.Int64:
value = DateTime.SpecifyKind(new DateTime(bsonReader.ReadInt64()), DateTimeKind.Utc);
break;
case BsonType.String:
// note: we're not using XmlConvert because of bugs in Mono
if (dateTimeOptions.DateOnly)
{
value = DateTime.SpecifyKind(DateTime.ParseExact(bsonReader.ReadString(), "yyyy-MM-dd", null), DateTimeKind.Utc);
}
else
{
var formats = new string[] {
"yyyy-MM-ddK",
"yyyy-MM-ddTHH:mm:ssK",
"yyyy-MM-ddTHH:mm:ss.FFFFFFFK",
};
value = DateTime.ParseExact(bsonReader.ReadString(), formats, null, DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeUniversal);
}
break;
default:
var message = string.Format("Cannot deserialize DateTime from BsonType {0}.", bsonType);
throw new FileFormatException(message);
}
if (dateTimeOptions.DateOnly)
{
if (value.TimeOfDay != TimeSpan.Zero)
{
throw new FileFormatException("TimeOfDay component for DateOnly DateTime value is not zero.");
}
value = DateTime.SpecifyKind(value, dateTimeOptions.Kind); // not ToLocalTime or ToUniversalTime!
}
else
{
switch (dateTimeOptions.Kind)
{
case DateTimeKind.Local:
case DateTimeKind.Unspecified:
value = BsonUtils.ToLocalTime(value, dateTimeOptions.Kind);
break;
case DateTimeKind.Utc:
value = BsonUtils.ToUniversalTime(value);
break;
}
}
return(value);
}
// public methods
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="actualType">The actual type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
Type actualType,
IBsonSerializationOptions options)
{
VerifyTypes(nominalType, actualType, typeof(T[, ]));
var arraySerializationOptions = EnsureSerializationOptions <ArraySerializationOptions>(options);
var itemSerializationOptions = arraySerializationOptions.ItemSerializationOptions;
var bsonType = bsonReader.GetCurrentBsonType();
string message;
switch (bsonType)
{
case BsonType.Null:
bsonReader.ReadNull();
return(null);
case BsonType.Array:
var itemNominalType = typeof(T);
var itemNominalTypeIsValueType = itemNominalType.IsValueType;
var itemNominalTypeSerializer = BsonSerializer.LookupSerializer(itemNominalType);
var itemDiscriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(itemNominalType);
Type lastItemType = null;
IBsonSerializer lastItemSerializer = null;
// if itemNominalType is a value type then these assignments are final
var itemActualType = itemNominalType;
var itemActualTypeSerializer = itemNominalTypeSerializer;
bsonReader.ReadStartArray();
var outerList = new List <List <T> >();
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
bsonReader.ReadStartArray();
var innerList = new List <T>();
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
if (!itemNominalTypeIsValueType)
{
itemActualType = itemDiscriminatorConvention.GetActualType(bsonReader, itemNominalType);
if (itemActualType == itemNominalType)
{
itemActualTypeSerializer = itemNominalTypeSerializer;
}
else if (itemActualType == lastItemType)
{
itemActualTypeSerializer = lastItemSerializer;
}
else
{
itemActualTypeSerializer = BsonSerializer.LookupSerializer(itemActualType);
lastItemType = itemActualType;
lastItemSerializer = itemActualTypeSerializer;
}
}
var item = (T)itemActualTypeSerializer.Deserialize(bsonReader, itemNominalType, itemActualType, itemSerializationOptions);
innerList.Add(item);
}
bsonReader.ReadEndArray();
outerList.Add(innerList);
}
bsonReader.ReadEndArray();
var length1 = outerList.Count;
var length2 = (length1 == 0) ? 0 : outerList[0].Count;
var array = new T[length1, length2];
for (int i = 0; i < length1; i++)
{
var innerList = outerList[i];
if (innerList.Count != length2)
{
message = string.Format("Inner list {0} is of length {1} but should be of length {2}.", i, innerList.Count, length2);
throw new Exception(message);
}
for (int j = 0; j < length2; j++)
{
array[i, j] = innerList[j];
}
}
return(array);
case BsonType.Document:
bsonReader.ReadStartDocument();
bsonReader.ReadString("_t"); // skip over discriminator
bsonReader.ReadName("_v");
var value = Deserialize(bsonReader, actualType, actualType, options);
bsonReader.ReadEndDocument();
return(value);
default:
message = string.Format("Can't deserialize a {0} from BsonType {1}.", actualType.FullName, bsonType);
throw new Exception(message);
}
}
public object Deserialize(BsonReader bsonReader, Type nominalType, IBsonSerializationOptions options)
{
throw new NotImplementedException();
}
public bool selectAllInto(JArray results, string query)
{
if (_connection != null)
{
try
{
var cmd = _connection.CreateCommand(query);
var stmt = SQLite3.Prepare2(_connection.Handle, cmd.CommandText);
try
{
while (SQLite3.Step(stmt) == SQLite3.Result.Row)
{
int colCount = SQLite3.ColumnCount(stmt);
if (colCount <= 0)
{
return(false);
}
JObject jsonObj = new JObject();
for (int i = 0; i < colCount; i++)
{
string columnName = SQLite3.ColumnName16(stmt, i);
if (columnName.Equals(FIELD_JSON))
{
MemoryStream ms = new MemoryStream(SQLite3.ColumnByteArray(stmt, i));
using (BsonReader reader = new BsonReader(ms))
{
jsonObj.Add(FIELD_JSON, JToken.ReadFrom(reader));
}
}
else if (columnName.Equals(FIELD_ID))
{
jsonObj.Add(FIELD_ID, Int32.Parse(SQLite3.ColumnString(stmt, i)));
}
else
{
if (isJSONCreatedColumn(columnName))
{
jsonObj.Add(columnName, SQLite3.ColumnString(stmt, i));
}
else
{
jsonObj.Add(columnName.Replace('_', '.'), SQLite3.ColumnString(stmt, i));
}
}
}
results.Add(jsonObj);
}
}
finally
{
SQLite3.Finalize(stmt);
}
return(true);
}
catch (Exception e)
{
lastErrorMsg = e.ToString();
}
}
return(false);
}
// public methods
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="actualType">The actual type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
Type actualType,
IBsonSerializationOptions options)
{
var dictionarySerializationOptions = EnsureSerializationOptions(options);
var dictionaryRepresentation = dictionarySerializationOptions.Representation;
var keyValuePairSerializationOptions = dictionarySerializationOptions.KeyValuePairSerializationOptions;
var bsonType = bsonReader.GetCurrentBsonType();
if (bsonType == BsonType.Null)
{
bsonReader.ReadNull();
return(null);
}
else if (bsonType == BsonType.Document)
{
if (nominalType == typeof(object))
{
bsonReader.ReadStartDocument();
bsonReader.ReadString("_t"); // skip over discriminator
bsonReader.ReadName("_v");
var value = Deserialize(bsonReader, actualType, options); // recursive call replacing nominalType with actualType
bsonReader.ReadEndDocument();
return(value);
}
var dictionary = CreateInstance(actualType);
var valueDiscriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(typeof(object));
bsonReader.ReadStartDocument();
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
var key = bsonReader.ReadName();
var valueType = valueDiscriminatorConvention.GetActualType(bsonReader, typeof(object));
var valueSerializer = BsonSerializer.LookupSerializer(valueType);
var value = valueSerializer.Deserialize(bsonReader, typeof(object), valueType, keyValuePairSerializationOptions.ValueSerializationOptions);
dictionary.Add(key, value);
}
bsonReader.ReadEndDocument();
return(dictionary);
}
else if (bsonType == BsonType.Array)
{
var dictionary = CreateInstance(actualType);
bsonReader.ReadStartArray();
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
var keyValuePair = (KeyValuePair <object, object>)_keyValuePairSerializer.Deserialize(
bsonReader,
typeof(KeyValuePair <object, object>),
keyValuePairSerializationOptions);
dictionary.Add(keyValuePair.Key, keyValuePair.Value);
}
bsonReader.ReadEndArray();
return(dictionary);
}
else
{
var message = string.Format("Can't deserialize a {0} from BsonType {1}.", nominalType.FullName, bsonType);
throw new FileFormatException(message);
}
}
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <returns>An object.</returns>
public static object Deserialize(BsonReader bsonReader, Type nominalType)
{
return(Deserialize(bsonReader, nominalType, null));
}
// public methods
/// <summary>
/// Gets the actual type of an object by reading the discriminator from a BsonReader.
/// </summary>
/// <param name="bsonReader">The reader.</param>
/// <param name="nominalType">The nominal type.</param>
/// <returns>The actual type.</returns>
public Type GetActualType(BsonReader bsonReader, Type nominalType)
{
// the BsonReader is sitting at the value whose actual type needs to be found
var bsonType = bsonReader.GetCurrentBsonType();
if (bsonReader.State == BsonReaderState.Value)
{
Type primitiveType = null;
switch (bsonType)
{
case BsonType.Boolean: primitiveType = typeof(bool); break;
case BsonType.Binary:
var bookmark = bsonReader.GetBookmark();
byte[] bytes;
BsonBinarySubType subType;
bsonReader.ReadBinaryData(out bytes, out subType);
if (subType == BsonBinarySubType.UuidStandard || subType == BsonBinarySubType.UuidLegacy)
{
primitiveType = typeof(Guid);
}
bsonReader.ReturnToBookmark(bookmark);
break;
case BsonType.DateTime: primitiveType = typeof(DateTime); break;
case BsonType.Double: primitiveType = typeof(double); break;
case BsonType.Int32: primitiveType = typeof(int); break;
case BsonType.Int64: primitiveType = typeof(long); break;
case BsonType.ObjectId: primitiveType = typeof(ObjectId); break;
case BsonType.String: primitiveType = typeof(string); break;
}
if (primitiveType != null && nominalType.IsAssignableFrom(primitiveType))
{
return(primitiveType);
}
}
if (bsonType == BsonType.Document)
{
// ensure KnownTypes of nominalType are registered (so IsTypeDiscriminated returns correct answer)
BsonDefaultSerializer.EnsureKnownTypesAreRegistered(nominalType);
// we can skip looking for a discriminator if nominalType has no discriminated sub types
if (BsonDefaultSerializer.IsTypeDiscriminated(nominalType))
{
var bookmark = bsonReader.GetBookmark();
bsonReader.ReadStartDocument();
var actualType = nominalType;
if (bsonReader.FindElement(_elementName))
{
var discriminator = BsonValue.ReadFrom(bsonReader);
if (discriminator.IsBsonArray)
{
discriminator = discriminator.AsBsonArray.Last(); // last item is leaf class discriminator
}
actualType = BsonDefaultSerializer.LookupActualType(nominalType, discriminator);
}
bsonReader.ReturnToBookmark(bookmark);
return(actualType);
}
}
return(nominalType);
}
public override object Deserialize(BsonReader bsonReader, Type nominalType, Type actualType, IBsonSerializationOptions options)
{
return(Deserialize(bsonReader, nominalType, options));
}
public object Deserialize(BsonReader bsonReader, Type nominalType, IBsonSerializationOptions options)
{
serializer.Deserialize(bsonReader, typeof(object), options);
return((Func <object, T>)Get);
}
private object Deserialize(BsonReader bsonReader, IBsonSerializationOptions options)
{
var enumerable = (IEnumerable <T>)_enumerableSerializer.Deserialize(bsonReader, typeof(ISet <T>), typeof(HashSet <T>), options);
return(new Collection.HashSet <T>(enumerable));
}
public void SerializeGoogleGeoCode()
{
string json = @"{
""name"": ""1600 Amphitheatre Parkway, Mountain View, CA, USA"",
""Status"": {
""code"": 200,
""request"": ""geocode""
},
""Placemark"": [
{
""address"": ""1600 Amphitheatre Pkwy, Mountain View, CA 94043, USA"",
""AddressDetails"": {
""Country"": {
""CountryNameCode"": ""US"",
""AdministrativeArea"": {
""AdministrativeAreaName"": ""CA"",
""SubAdministrativeArea"": {
""SubAdministrativeAreaName"": ""Santa Clara"",
""Locality"": {
""LocalityName"": ""Mountain View"",
""Thoroughfare"": {
""ThoroughfareName"": ""1600 Amphitheatre Pkwy""
},
""PostalCode"": {
""PostalCodeNumber"": ""94043""
}
}
}
}
},
""Accuracy"": 8
},
""Point"": {
""coordinates"": [-122.083739, 37.423021, 0]
}
}
]
}";
GoogleMapGeocoderStructure jsonGoogleMapGeocoder = JsonConvert.DeserializeObject <GoogleMapGeocoderStructure>(json);
MemoryStream ms = new MemoryStream();
BsonWriter writer = new BsonWriter(ms);
JsonSerializer serializer = new JsonSerializer();
serializer.Serialize(writer, jsonGoogleMapGeocoder);
ms.Seek(0, SeekOrigin.Begin);
BsonReader reader = new BsonReader(ms);
GoogleMapGeocoderStructure bsonGoogleMapGeocoder = (GoogleMapGeocoderStructure)serializer.Deserialize(reader, typeof(GoogleMapGeocoderStructure));
Assert.IsNotNull(bsonGoogleMapGeocoder);
Assert.AreEqual("1600 Amphitheatre Parkway, Mountain View, CA, USA", bsonGoogleMapGeocoder.Name);
Assert.AreEqual("200", bsonGoogleMapGeocoder.Status.Code);
Assert.AreEqual("geocode", bsonGoogleMapGeocoder.Status.Request);
IList <Placemark> placemarks = bsonGoogleMapGeocoder.Placemark;
Assert.IsNotNull(placemarks);
Assert.AreEqual(1, placemarks.Count);
Placemark placemark = placemarks[0];
Assert.AreEqual("1600 Amphitheatre Pkwy, Mountain View, CA 94043, USA", placemark.Address);
Assert.AreEqual(8, placemark.AddressDetails.Accuracy);
Assert.AreEqual("US", placemark.AddressDetails.Country.CountryNameCode);
Assert.AreEqual("CA", placemark.AddressDetails.Country.AdministrativeArea.AdministrativeAreaName);
Assert.AreEqual("Santa Clara", placemark.AddressDetails.Country.AdministrativeArea.SubAdministrativeArea.SubAdministrativeAreaName);
Assert.AreEqual("Mountain View", placemark.AddressDetails.Country.AdministrativeArea.SubAdministrativeArea.Locality.LocalityName);
Assert.AreEqual("1600 Amphitheatre Pkwy", placemark.AddressDetails.Country.AdministrativeArea.SubAdministrativeArea.Locality.Thoroughfare.ThoroughfareName);
Assert.AreEqual("94043", placemark.AddressDetails.Country.AdministrativeArea.SubAdministrativeArea.Locality.PostalCode.PostalCodeNumber);
Assert.AreEqual(-122.083739m, placemark.Point.Coordinates[0]);
Assert.AreEqual(37.423021m, placemark.Point.Coordinates[1]);
Assert.AreEqual(0m, placemark.Point.Coordinates[2]);
}
// public methods
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public object Deserialize(BsonReader bsonReader, Type nominalType, IBsonSerializationOptions options)
{
var value = (IBsonSerializable)Activator.CreateInstance(nominalType, true); // private default constructor OK
return(value.Deserialize(bsonReader, nominalType, options));
}
// -----------------------------------------------------------------
/// <summary>
///
/// </summary>
// -----------------------------------------------------------------
public static RequestBase DeserializeFromBinaryStream(Stream bstream)
{
BsonReader bson = new BsonReader(bstream);
return(DeserializeFromReader(bson));
}
public void ReadEndOfStream()
{
BsonReader reader = new BsonReader(new MemoryStream());
Assert.IsFalse(reader.Read());
}
// public methods
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public virtual object Deserialize(BsonReader bsonReader, Type nominalType, IBsonSerializationOptions options)
{
// override this method to determine actualType if your serializer handles polymorphic data types
return(Deserialize(bsonReader, nominalType, nominalType, options));
}
public override T Deserialize <T>(Stream input)
{
var reader = new BsonReader(input, IsArray(typeof(T)), DateTimeKind.Utc);
return(Deserialize <T>(reader));
}
/// <inheritdoc />
public virtual IDictionary <string, object> LoadTempData([NotNull] HttpContext context)
{
if (!IsSessionEnabled(context))
{
// Session middleware is not enabled. No-op
return(null);
}
var tempDataDictionary = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
var session = context.Session;
byte[] value;
if (session != null && session.TryGetValue(TempDataSessionStateKey, out value))
{
using (var memoryStream = new MemoryStream(value))
using (var writer = new BsonReader(memoryStream))
{
tempDataDictionary = _jsonSerializer.Deserialize <Dictionary <string, object> >(writer);
}
var convertedDictionary = new Dictionary <string, object>(tempDataDictionary, StringComparer.OrdinalIgnoreCase);
foreach (var item in tempDataDictionary)
{
var jArrayValue = item.Value as JArray;
if (jArrayValue != null && jArrayValue.Count > 0)
{
var arrayType = jArrayValue[0].Type;
Type returnType;
if (_tokenTypeLookup.TryGetValue(arrayType, out returnType))
{
var arrayConverter = _arrayConverters.GetOrAdd(returnType, type =>
{
return((Func <JArray, object>)_convertArrayMethodInfo.MakeGenericMethod(type).CreateDelegate(typeof(Func <JArray, object>)));
});
var result = arrayConverter(jArrayValue);
convertedDictionary[item.Key] = result;
}
else
{
var message = Resources.FormatTempData_CannotDeserializeToken(nameof(JToken), arrayType);
throw new InvalidOperationException(message);
}
}
else
{
var jObjectValue = item.Value as JObject;
if (jObjectValue == null)
{
continue;
}
else if (!jObjectValue.HasValues)
{
convertedDictionary[item.Key] = null;
continue;
}
var jTokenType = jObjectValue.Properties().First().Value.Type;
Type valueType;
if (_tokenTypeLookup.TryGetValue(jTokenType, out valueType))
{
var dictionaryConverter = _dictionaryConverters.GetOrAdd(valueType, type =>
{
return((Func <JObject, object>)_convertDictMethodInfo.MakeGenericMethod(type).CreateDelegate(typeof(Func <JObject, object>)));
});
var result = dictionaryConverter(jObjectValue);
convertedDictionary[item.Key] = result;
}
else
{
var message = Resources.FormatTempData_CannotDeserializeToken(nameof(JToken), jTokenType);
throw new InvalidOperationException(message);
}
}
}
tempDataDictionary = convertedDictionary;
// If we got it from Session, remove it so that no other request gets it
session.Remove(TempDataSessionStateKey);
}
else
{
// Since we call Save() after the response has been sent, we need to initialize an empty session
// so that it is established before the headers are sent.
session[TempDataSessionStateKey] = new byte[] { };
}
return(tempDataDictionary);
}
// public methods
/// <summary>
/// Deserializes an object from a BsonReader.
/// </summary>
/// <param name="bsonReader">The BsonReader.</param>
/// <param name="nominalType">The nominal type of the object.</param>
/// <param name="actualType">The actual type of the object.</param>
/// <param name="options">The serialization options.</param>
/// <returns>An object.</returns>
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
Type actualType,
IBsonSerializationOptions options)
{
VerifyTypes(nominalType, actualType, typeof(Version));
BsonType bsonType = bsonReader.GetCurrentBsonType();
string message;
switch (bsonType)
{
case BsonType.Null:
bsonReader.ReadNull();
return(null);
case BsonType.Document:
bsonReader.ReadStartDocument();
int major = -1, minor = -1, build = -1, revision = -1;
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
var name = bsonReader.ReadName();
switch (name)
{
case "Major": major = bsonReader.ReadInt32(); break;
case "Minor": minor = bsonReader.ReadInt32(); break;
case "Build": build = bsonReader.ReadInt32(); break;
case "Revision": revision = bsonReader.ReadInt32(); break;
default:
message = string.Format("Unrecognized element '{0}' while deserializing a Version value.", name);
throw new FileFormatException(message);
}
}
bsonReader.ReadEndDocument();
if (major == -1)
{
message = string.Format("Version missing Major element.");
throw new FileFormatException(message);
}
else if (minor == -1)
{
message = string.Format("Version missing Minor element.");
throw new FileFormatException(message);
}
else if (build == -1)
{
return(new Version(major, minor));
}
else if (revision == -1)
{
return(new Version(major, minor, build));
}
else
{
return(new Version(major, minor, build, revision));
}
case BsonType.String:
return(new Version(bsonReader.ReadString()));
default:
message = string.Format("Cannot deserialize Version from BsonType {0}.", bsonType);
throw new FileFormatException(message);
}
}
public void TestBookmark()
{
var json = "{ \"x\" : 1, \"y\" : 2 }";
using (_bsonReader = BsonReader.Create(json))
{
// do everything twice returning to bookmark in between
var bookmark = _bsonReader.GetBookmark();
Assert.AreEqual(BsonType.Document, _bsonReader.ReadBsonType());
_bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual(BsonType.Document, _bsonReader.ReadBsonType());
bookmark = _bsonReader.GetBookmark();
_bsonReader.ReadStartDocument();
_bsonReader.ReturnToBookmark(bookmark);
_bsonReader.ReadStartDocument();
bookmark = _bsonReader.GetBookmark();
Assert.AreEqual(BsonType.Int32, _bsonReader.ReadBsonType());
_bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual(BsonType.Int32, _bsonReader.ReadBsonType());
bookmark = _bsonReader.GetBookmark();
Assert.AreEqual("x", _bsonReader.ReadName());
_bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual("x", _bsonReader.ReadName());
bookmark = _bsonReader.GetBookmark();
Assert.AreEqual(1, _bsonReader.ReadInt32());
_bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual(1, _bsonReader.ReadInt32());
bookmark = _bsonReader.GetBookmark();
Assert.AreEqual(BsonType.Int32, _bsonReader.ReadBsonType());
_bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual(BsonType.Int32, _bsonReader.ReadBsonType());
bookmark = _bsonReader.GetBookmark();
Assert.AreEqual("y", _bsonReader.ReadName());
_bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual("y", _bsonReader.ReadName());
bookmark = _bsonReader.GetBookmark();
Assert.AreEqual(2, _bsonReader.ReadInt32());
_bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual(2, _bsonReader.ReadInt32());
bookmark = _bsonReader.GetBookmark();
Assert.AreEqual(BsonType.EndOfDocument, _bsonReader.ReadBsonType());
_bsonReader.ReturnToBookmark(bookmark);
Assert.AreEqual(BsonType.EndOfDocument, _bsonReader.ReadBsonType());
bookmark = _bsonReader.GetBookmark();
_bsonReader.ReadEndDocument();
_bsonReader.ReturnToBookmark(bookmark);
_bsonReader.ReadEndDocument();
Assert.AreEqual(BsonReaderState.Done, _bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize <BsonDocument>(new StringReader(json)).ToJson());
}