// protected methods
/// <summary>
/// Deserializes a value.
/// </summary>
/// <param name="context">The deserialization context.</param>
/// <returns>The value.</returns>
protected override MongoDBRef DeserializeValue(BsonDeserializationContext context)
{
var bsonReader = context.Reader;
string databaseName = null;
string collectionName = null;
BsonValue id = null;
_helper.DeserializeMembers(context, (elementName, flag) =>
{
switch (flag)
{
case Flags.CollectionName: collectionName = bsonReader.ReadString(); break;
case Flags.Id: id = context.DeserializeWithChildContext(BsonValueSerializer.Instance); break;
case Flags.DatabaseName: databaseName = bsonReader.ReadString(); break;
}
});
return(new MongoDBRef(databaseName, collectionName, id));
}
// public methods
/// <summary>
/// Deserializes a value.
/// </summary>
/// <param name="context">The deserialization context.</param>
/// <returns>An object.</returns>
public override TValue Deserialize(BsonDeserializationContext context)
{
var bsonReader = context.Reader;
var bsonType = bsonReader.GetCurrentBsonType();
switch (bsonType)
{
case BsonType.Null:
bsonReader.ReadNull();
return(null);
case BsonType.Array:
bsonReader.ReadStartArray();
var accumulator = CreateAccumulator();
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
var item = context.DeserializeWithChildContext(_itemSerializer);
AddItem(accumulator, item);
}
bsonReader.ReadEndArray();
return(FinalizeResult(accumulator));
case BsonType.Document:
var serializer = new DiscriminatedWrapperSerializer <TValue>(_discriminatorConvention, this);
if (serializer.IsPositionedAtDiscriminatedWrapper(context))
{
return((TValue)serializer.Deserialize(context));
}
else
{
goto default;
}
default:
throw CreateCannotDeserializeFromBsonTypeException(bsonType);
}
}
// methods
public override TValue Deserialize(BsonDeserializationContext context)
{
TValue value = default(TValue);
var reader = context.Reader;
reader.ReadStartDocument();
while (reader.ReadBsonType() != 0)
{
var elementName = reader.ReadName();
if (elementName == _elementName && (reader.CurrentBsonType != BsonType.Null || _deserializeNull))
{
value = context.DeserializeWithChildContext <TValue>(_valueSerializer);
}
else
{
reader.SkipValue();
}
}
reader.ReadEndDocument();
return(value);
}
// public methods
/// <summary>
/// Deserializes a value.
/// </summary>
/// <param name="context">The deserialization context.</param>
/// <returns>An object.</returns>
public override DateTime Deserialize(BsonDeserializationContext context)
{
var bsonReader = context.Reader;
DateTime value;
var bsonType = bsonReader.GetCurrentBsonType();
switch (bsonType)
{
case BsonType.DateTime:
// use an intermediate BsonDateTime so MinValue and MaxValue are handled correctly
value = new BsonDateTime(bsonReader.ReadDateTime()).ToUniversalTime();
break;
case BsonType.Document:
value = default(DateTime);
_helper.DeserializeMembers(context, (elementName, flag) =>
{
switch (flag)
{
case Flags.DateTime: bsonReader.SkipValue(); break; // ignore value (use Ticks instead)
case Flags.Ticks: value = new DateTime(context.DeserializeWithChildContext(_int64Serializer), DateTimeKind.Utc); break;
}
});
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 (_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:
throw CreateCannotDeserializeFromBsonTypeException(bsonType);
}
if (_dateOnly)
{
if (value.TimeOfDay != TimeSpan.Zero)
{
throw new FileFormatException("TimeOfDay component for DateOnly DateTime value is not zero.");
}
value = DateTime.SpecifyKind(value, _kind); // not ToLocalTime or ToUniversalTime!
}
else
{
switch (_kind)
{
case DateTimeKind.Local:
case DateTimeKind.Unspecified:
value = DateTime.SpecifyKind(BsonUtils.ToLocalTime(value), _kind);
break;
case DateTimeKind.Utc:
value = BsonUtils.ToUniversalTime(value);
break;
}
}
return(value);
}
// private methods
private GeoJsonLineStringCoordinates <TCoordinates> DeserializeCoordinates(BsonDeserializationContext context)
{
return(context.DeserializeWithChildContext(_coordinatesSerializer));
}
private GeoJsonCoordinateReferenceSystem DeserializeCoordinateReferenceSystem(BsonDeserializationContext context)
{
return(context.DeserializeWithChildContext(_coordinateReferenceSystemSerializer));
}
// private methods
private GeoJsonBoundingBox <TCoordinates> DeserializeBoundingBox(BsonDeserializationContext context)
{
return(context.DeserializeWithChildContext(_boundingBoxSerializer));
}
private BsonValue DeserializeId(BsonDeserializationContext context)
{
return(context.DeserializeWithChildContext(BsonValueSerializer.Instance));
}
// private methods
private GeoJsonGeometry <TCoordinates> DeserializeGeometry(BsonDeserializationContext context)
{
return(context.DeserializeWithChildContext(_geometrySerializer));
}
private BsonDocument DeserializeProperties(BsonDeserializationContext context)
{
return(context.DeserializeWithChildContext(BsonDocumentSerializer.Instance));
}
// methods
public override TResult Deserialize(BsonDeserializationContext context)
{
return(context.DeserializeWithChildContext <TResult>(_resultSerializer));
}
// private methods
private TCoordinates DeserializeCoordinates(BsonDeserializationContext context)
{
return(context.DeserializeWithChildContext(_coordinatesSerializer));
}
