static object ReadObject(BsonReader bsonReader) //_120509_173140 keep consistent
{
switch (bsonReader.GetCurrentBsonType())
{
case BsonType.Array: return(ReadArray(bsonReader)); // replacement
case BsonType.Binary: var binary = BsonSerializer.Deserialize <BsonValue>(bsonReader); return(BsonTypeMapper.MapToDotNetValue(binary) ?? binary); // byte[] or Guid else self
case BsonType.Boolean: return(bsonReader.ReadBoolean());
case BsonType.DateTime: return(BsonUtils.ToDateTimeFromMillisecondsSinceEpoch(bsonReader.ReadDateTime()));
case BsonType.Document: return(ReadCustomObject(bsonReader)); // replacement
case BsonType.Double: return(bsonReader.ReadDouble());
case BsonType.Int32: return(bsonReader.ReadInt32());
case BsonType.Int64: return(bsonReader.ReadInt64());
case BsonType.Null: bsonReader.ReadNull(); return(null);
case BsonType.ObjectId: return(bsonReader.ReadObjectId());
case BsonType.String: return(bsonReader.ReadString());
default: return(BsonSerializer.Deserialize <BsonValue>(bsonReader));
}
}
/// <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 override object Deserialize(
BsonReader bsonReader,
Type nominalType,
IBsonSerializationOptions options
)
{
BsonType bsonType = bsonReader.CurrentBsonType;
switch (bsonType)
{
case BsonType.ObjectId:
int timestamp;
int machine;
short pid;
int increment;
bsonReader.ReadObjectId(out timestamp, out machine, out pid, out increment);
return(new ObjectId(timestamp, machine, pid, increment));
case BsonType.String:
return(ObjectId.Parse(bsonReader.ReadString()));
default:
var message = string.Format("Cannot deserialize ObjectId from BsonType: {0}", bsonType);
throw new FileFormatException(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 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(string));
var bsonType = bsonReader.CurrentBsonType;
if (bsonType == BsonType.Null)
{
bsonReader.ReadNull();
return(null);
}
else
{
var representation = (options == null) ? BsonType.String : ((RepresentationSerializationOptions)options).Representation;
switch (representation)
{
case BsonType.ObjectId:
int timestamp, machine, increment;
short pid;
bsonReader.ReadObjectId(out timestamp, out machine, out pid, out increment);
var objectId = new ObjectId(timestamp, machine, pid, increment);
return(objectId.ToString());
case BsonType.String:
return(bsonReader.ReadString());
case BsonType.Symbol:
return(bsonReader.ReadSymbol());
default:
var message = string.Format("Cannot deserialize string from BsonType {0}.", bsonType);
throw new FileFormatException(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, 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 void TestObjectIdShell()
{
var json = "ObjectId(\"4d0ce088e447ad08b4721a37\")";
using (_bsonReader = BsonReader.Create(json))
{
Assert.AreEqual(BsonType.ObjectId, _bsonReader.ReadBsonType());
var objectId = _bsonReader.ReadObjectId();
Assert.AreEqual("4d0ce088e447ad08b4721a37", objectId.ToString());
Assert.AreEqual(BsonReaderState.Done, _bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize <ObjectId>(new StringReader(json)).ToJson());
}
public object Deserialize(BsonReader bsonReader, Type nominalType, IBsonSerializationOptions options)
{
EvaluationResult er = new EvaluationResult();
bsonReader.ReadStartDocument();
er.Id = bsonReader.ReadObjectId();
er.DurationInSeconds = bsonReader.ReadDouble();
er.startTime = BsonUtils.ToDateTimeFromMillisecondsSinceEpoch(bsonReader.ReadDateTime());
er.endTime = BsonUtils.ToDateTimeFromMillisecondsSinceEpoch(bsonReader.ReadDateTime());
er.Result = EvaluationStatus.Parse(bsonReader.ReadString());
er.JSON = bsonReader.ReadString();
bsonReader.ReadEndDocument();
return(er);
}
public void TestObjectIdShell()
{
var json = "ObjectId(\"4d0ce088e447ad08b4721a37\")";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.ObjectId, bsonReader.ReadBsonType());
int timestamp, machine, increment;
short pid;
bsonReader.ReadObjectId(out timestamp, out machine, out pid, out increment);
var objectId = new ObjectId(timestamp, machine, pid, increment);
Assert.AreEqual("4d0ce088e447ad08b4721a37", objectId.ToString());
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize <ObjectId>(new StringReader(json)).ToJson());
}
public override object Deserialize(BsonReader bsonReader, Type nominalType, IBsonSerializationOptions options)
{
switch (bsonReader.CurrentBsonType)
{
case BsonType.ObjectId:
return(bsonReader.ReadObjectId());
case BsonType.String:
return(new ObjectId(bsonReader.ReadString()));
case BsonType.Null:
return(null);
default:
throw new FormatException(string.Format("Cannot deserialize Identity from BsonType: {0}", bsonReader.CurrentBsonType));
}
}
public void TestObjectIdStrict()
{
var json = "{ \"$oid\" : \"4d0ce088e447ad08b4721a37\" }";
using (_bsonReader = new JsonReader(json))
{
Assert.AreEqual(BsonType.ObjectId, _bsonReader.ReadBsonType());
var objectId = _bsonReader.ReadObjectId();
Assert.AreEqual("4d0ce088e447ad08b4721a37", objectId.ToString());
Assert.AreEqual(BsonReaderState.Done, _bsonReader.State);
}
var jsonSettings = new JsonWriterSettings {
OutputMode = JsonOutputMode.Strict
};
Assert.AreEqual(json, BsonSerializer.Deserialize <ObjectId>(json).ToJson(jsonSettings));
}
public void TestObjectIdTenGen()
{
var json = "ObjectId(\"4d0ce088e447ad08b4721a37\")";
using (_bsonReader = BsonReader.Create(json))
{
Assert.AreEqual(BsonType.ObjectId, _bsonReader.ReadBsonType());
var objectId = _bsonReader.ReadObjectId();
Assert.AreEqual("4d0ce088e447ad08b4721a37", objectId.ToString());
Assert.AreEqual(BsonReaderState.Done, _bsonReader.State);
}
var settings = new JsonWriterSettings {
OutputMode = JsonOutputMode.TenGen
};
Assert.AreEqual(json, BsonSerializer.Deserialize <ObjectId>(new StringReader(json)).ToJson(settings));
}
// 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(BsonObjectId));
var bsonType = bsonReader.GetCurrentBsonType();
switch (bsonType)
{
case BsonType.ObjectId:
return new BsonObjectId(bsonReader.ReadObjectId());
default:
var message = string.Format("Cannot deserialize BsonObjectId from BsonType {0}.", bsonType);
throw new FileFormatException(message);
}
}
public void TestObjectIdStrict()
{
var json = "{ \"$oid\" : \"4d0ce088e447ad08b4721a37\" }";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.ObjectId, bsonReader.ReadBsonType());
int timestamp, machine, increment;
short pid;
bsonReader.ReadObjectId(out timestamp, out machine, out pid, out increment);
var objectId = new ObjectId(timestamp, machine, pid, increment);
Assert.AreEqual("4d0ce088e447ad08b4721a37", objectId.ToString());
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
var jsonSettings = new JsonWriterSettings {
OutputMode = JsonOutputMode.Strict
};
Assert.AreEqual(json, BsonSerializer.Deserialize <ObjectId>(new StringReader(json)).ToJson(jsonSettings));
}
// 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(string));
var representationSerializationOptions = EnsureSerializationOptions <RepresentationSerializationOptions>(options);
var bsonType = bsonReader.GetCurrentBsonType();
if (bsonType == BsonType.Null)
{
bsonReader.ReadNull();
return(null);
}
else
{
switch (bsonType)
{
case BsonType.ObjectId:
if (representationSerializationOptions.Representation == BsonType.ObjectId)
{
return(bsonReader.ReadObjectId().ToString());
}
else
{
goto default;
}
case BsonType.String:
return(bsonReader.ReadString());
case BsonType.Symbol:
return(bsonReader.ReadSymbol());
default:
var message = string.Format("Cannot deserialize string from BsonType {0}.", bsonType);
throw new FileFormatException(message);
}
}
}
public override object Deserialize(BsonReader bsonReader, Type nominalType, IBsonSerializationOptions options)
{
switch (bsonReader.CurrentBsonType)
{
case BsonType.ObjectId:
int timestamp;
int machine;
short pid;
int increment;
bsonReader.ReadObjectId(out timestamp, out machine, out pid, out increment);
var id = new ObjectId(timestamp, machine, pid, increment);
return(new Identity(id.ToByteArray()));
case BsonType.String:
return(new Identity(bsonReader.ReadString()));
default:
throw new FormatException(string.Format("Cannot deserialize Identity from BsonType: {0}", bsonReader.CurrentBsonType));
}
}
// 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(BsonObjectId));
var bsonType = bsonReader.GetCurrentBsonType();
switch (bsonType)
{
case BsonType.ObjectId:
return(new BsonObjectId(bsonReader.ReadObjectId()));
default:
var message = string.Format("Cannot deserialize BsonObjectId 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(string));
var representationSerializationOptions = EnsureSerializationOptions<RepresentationSerializationOptions>(options);
var bsonType = bsonReader.GetCurrentBsonType();
if (bsonType == BsonType.Null)
{
bsonReader.ReadNull();
return null;
}
else
{
switch (bsonType)
{
case BsonType.ObjectId:
if (representationSerializationOptions.Representation == BsonType.ObjectId)
{
int timestamp, machine, increment;
short pid;
bsonReader.ReadObjectId(out timestamp, out machine, out pid, out increment);
var objectId = new ObjectId(timestamp, machine, pid, increment);
return objectId.ToString();
}
else
{
goto default;
}
case BsonType.String:
return bsonReader.ReadString();
case BsonType.Symbol:
return bsonReader.ReadSymbol();
default:
var message = string.Format("Cannot deserialize string from BsonType {0}.", bsonType);
throw new FileFormatException(message);
}
}
}
public override object Deserialize(BsonReader bsonReader, Type nominalType, Type actualType, IBsonSerializationOptions options)
{
return bsonReader.ReadObjectId().ToString();
}
// 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(ObjectId));
BsonType bsonType = bsonReader.GetCurrentBsonType();
switch (bsonType)
{
case BsonType.ObjectId:
int timestamp;
int machine;
short pid;
int increment;
bsonReader.ReadObjectId(out timestamp, out machine, out pid, out increment);
return new ObjectId(timestamp, machine, pid, increment);
case BsonType.String:
return ObjectId.Parse(bsonReader.ReadString());
default:
var message = string.Format("Cannot deserialize ObjectId from BsonType {0}.", bsonType);
throw new FileFormatException(message);
}
}
private void ReadValue()
{
//bool value = true;
_type = PBBsonReaderType.Value;
switch (_bsonType)
{
case BsonType.Document:
WriteLine(2, "ReadStartDocument");
WriteLine(1, "{");
//_indent += 2;
Indent(2);
_reader.ReadStartDocument();
_type = PBBsonReaderType.Document;
//value = false;
break;
case BsonType.Array:
WriteLine(2, "ReadStartArray");
WriteLine(1, "[");
//_indent += 2;
Indent(2);
_reader.ReadStartArray();
_type = PBBsonReaderType.Array;
//value = false;
break;
case BsonType.Binary:
_value = BsonValue.Create(_reader.ReadBytes());
break;
case BsonType.Boolean:
_value = BsonValue.Create(_reader.ReadBoolean());
break;
case BsonType.DateTime:
_value = BsonValue.Create(_reader.ReadDateTime());
break;
case BsonType.Double:
_value = BsonValue.Create(_reader.ReadDouble());
break;
case BsonType.Int32:
_value = BsonValue.Create(_reader.ReadInt32());
break;
case BsonType.Int64:
_value = BsonValue.Create(_reader.ReadInt64());
break;
case BsonType.JavaScript:
_value = BsonValue.Create(_reader.ReadJavaScript());
break;
case BsonType.JavaScriptWithScope:
_value = BsonValue.Create(_reader.ReadJavaScriptWithScope());
break;
case BsonType.MaxKey:
_reader.ReadMaxKey();
_value = BsonMaxKey.Value;
break;
case BsonType.MinKey:
_reader.ReadMinKey();
_value = BsonMinKey.Value;
break;
case BsonType.Null:
_reader.ReadNull();
_value = BsonNull.Value;
break;
case BsonType.ObjectId:
_value = BsonValue.Create(_reader.ReadObjectId());
break;
case BsonType.RegularExpression:
_value = BsonValue.Create(_reader.ReadRegularExpression());
break;
case BsonType.String:
_value = BsonValue.Create(_reader.ReadString());
break;
case BsonType.Symbol:
_value = BsonValue.Create(_reader.ReadSymbol());
break;
case BsonType.Timestamp:
_value = BsonValue.Create(_reader.ReadTimestamp());
break;
case BsonType.Undefined:
_reader.ReadUndefined();
_value = BsonUndefined.Value;
break;
default:
throw new PBException("error unable to read value type {0}", _bsonType);
}
//return value;
}
public override object Deserialize(BsonReader bsonReader, Type nominalType, Type actualType, IBsonSerializationOptions options)
{
return(bsonReader.ReadObjectId().ToString());
}
object IBsonSerializable.Deserialize(
BsonReader bsonReader,
Type nominalType,
IBsonSerializationOptions options
)
{
if (bsonReader.CurrentBsonType == Bson.BsonType.Null) {
bsonReader.ReadNull();
return null;
} else {
bsonReader.ReadStartDocument();
string message;
BsonType bsonType;
while ((bsonType = bsonReader.ReadBsonType()) != BsonType.EndOfDocument) {
var name = bsonReader.ReadName();
switch (name) {
case "$ref":
collectionName = bsonReader.ReadString();
break;
case "$id":
switch (bsonType) {
case BsonType.Binary:
byte[] bytes;
BsonBinarySubType subType;
bsonReader.ReadBinaryData(out bytes, out subType);
if (bytes.Length == 16 && subType == BsonBinarySubType.Uuid) {
id = new Guid(bytes);
} else {
throw new FileFormatException("Binary data is not valid for Guid");
}
break;
case BsonType.Int32:
id = bsonReader.ReadInt32();
break;
case BsonType.Int64:
id = bsonReader.ReadInt64();
break;
case BsonType.ObjectId:
int timestamp;
int machine;
short pid;
int increment;
bsonReader.ReadObjectId(out timestamp, out machine, out pid, out increment);
id = new ObjectId(timestamp, machine, pid, increment);
break;
case BsonType.String:
id = bsonReader.ReadString();
break;
default:
message = string.Format("Unsupported BsonType for $id element of a DBRef: {0}", bsonType);
throw new MongoException(message);
}
break;
case "$db":
databaseName = bsonReader.ReadString();
break;
default:
message = string.Format("Invalid element for DBRef: {0}", name);
throw new FileFormatException(message);
}
}
bsonReader.ReadEndDocument();
return this;
}
}
