// 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(BsonRegularExpression));
var bsonType = bsonReader.GetCurrentBsonType();
switch (bsonType)
{
case BsonType.RegularExpression:
return bsonReader.ReadRegularExpression();
default:
var message = string.Format("Cannot deserialize BsonRegularExpression 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(BsonRegularExpression));
var bsonType = bsonReader.GetCurrentBsonType();
if (bsonType == BsonType.Null)
{
bsonReader.ReadNull();
return null;
}
else
{
return bsonReader.ReadRegularExpression();
}
}
public void TestRegularExpressionStrict() {
var json = "{ \"$regex\" : \"pattern\", \"$options\" : \"imxs\" }";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.RegularExpression, bsonReader.ReadBsonType());
string pattern, options;
bsonReader.ReadRegularExpression(out pattern, out options);
Assert.AreEqual("pattern", pattern);
Assert.AreEqual("imxs", options);
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
var settings = new JsonWriterSettings { OutputMode = JsonOutputMode.Strict };
Assert.AreEqual(json, BsonSerializer.Deserialize<BsonRegularExpression>(new StringReader(json)).ToJson(settings));
}
public void TestRegularExpressionShell() {
var json = "/pattern/imxs";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.RegularExpression, bsonReader.ReadBsonType());
string pattern, options;
bsonReader.ReadRegularExpression(out pattern, out options);
Assert.AreEqual("pattern", pattern);
Assert.AreEqual("imxs", options);
Assert.AreEqual(BsonReaderState.Done, bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize<BsonRegularExpression>(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="options">The serialization options.</param>
/// <returns>An object.</returns>
public override object Deserialize(
BsonReader bsonReader,
Type nominalType,
IBsonSerializationOptions options
) {
var bsonType = bsonReader.CurrentBsonType;
if (bsonType == BsonType.Null) {
bsonReader.ReadNull();
return null;
} else {
string regexPattern, regexOptions;
bsonReader.ReadRegularExpression(out regexPattern, out regexOptions);
return new BsonRegularExpression(regexPattern, regexOptions);
}
}
public void TestRegularExpressionTenGen()
{
var json = "/pattern/gim";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.RegularExpression, bsonReader.ReadBsonType());
string pattern, options;
bsonReader.ReadRegularExpression(out pattern, out options);
Assert.AreEqual("pattern", pattern);
Assert.AreEqual("gim", options);
Assert.AreEqual(BsonReadState.Done, bsonReader.ReadState);
}
var tenGen = new BsonJsonWriterSettings { OutputMode = BsonJsonOutputMode.TenGen };
Assert.AreEqual(json, BsonSerializer.Deserialize<BsonRegularExpression>(new StringReader(json)).ToJson(tenGen));
}
public void TestRegularExpressionStrict()
{
var json = "{ \"$regex\" : \"pattern\", \"$options\" : \"gim\" }";
using (bsonReader = BsonReader.Create(json)) {
Assert.AreEqual(BsonType.RegularExpression, bsonReader.ReadBsonType());
string pattern, options;
bsonReader.ReadRegularExpression(out pattern, out options);
Assert.AreEqual("pattern", pattern);
Assert.AreEqual("gim", options);
Assert.AreEqual(BsonReadState.Done, bsonReader.ReadState);
}
Assert.AreEqual(json, BsonSerializer.Deserialize<BsonRegularExpression>(new StringReader(json)).ToJson());
}
public void TestRegularExpressionStrict()
{
var json = "{ \"$regex\" : \"pattern\", \"$options\" : \"imxs\" }";
using (_bsonReader = new JsonReader(json))
{
Assert.AreEqual(BsonType.RegularExpression, _bsonReader.ReadBsonType());
var regex = _bsonReader.ReadRegularExpression();
Assert.AreEqual("pattern", regex.Pattern);
Assert.AreEqual("imxs", regex.Options);
Assert.AreEqual(BsonReaderState.Done, _bsonReader.State);
}
var settings = new JsonWriterSettings { OutputMode = JsonOutputMode.Strict };
Assert.AreEqual(json, BsonSerializer.Deserialize<BsonRegularExpression>(json).ToJson(settings));
}
public void TestRegularExpressionShell()
{
var json = "/pattern/imxs";
using (_bsonReader = new JsonReader(json))
{
Assert.AreEqual(BsonType.RegularExpression, _bsonReader.ReadBsonType());
var regex = _bsonReader.ReadRegularExpression();
Assert.AreEqual("pattern", regex.Pattern);
Assert.AreEqual("imxs", regex.Options);
Assert.AreEqual(BsonReaderState.Done, _bsonReader.State);
}
Assert.AreEqual(json, BsonSerializer.Deserialize<BsonRegularExpression>(json).ToJson());
}
public override object Deserialize(
BsonReader bsonReader,
Type nominalType
)
{
var bsonType = bsonReader.CurrentBsonType;
if (bsonType == BsonType.Null) {
bsonReader.ReadNull();
return null;
} else {
string pattern, options;
bsonReader.ReadRegularExpression(out pattern, out options);
return new BsonRegularExpression(pattern, options);
}
}
