private JToken GenerateJToken(IBsonReader reader, JToken parent)
{
switch (reader.CurrentBsonType)
{
case BsonType.Symbol:
case BsonType.JavaScriptWithScope:
case BsonType.JavaScript:
case BsonType.ObjectId:
case BsonType.RegularExpression:
case BsonType.DateTime:
case BsonType.Decimal128:
case BsonType.MinKey:
case BsonType.MaxKey:
case BsonType.String:
return(reader.ReadString());
case BsonType.Binary:
return(reader.ReadBytes());
case BsonType.Undefined:
reader.ReadUndefined();
return(JValue.CreateUndefined());
case BsonType.Boolean:
return(reader.ReadBoolean());
case BsonType.Null:
reader.ReadNull();
return(JValue.CreateNull());
case BsonType.Int32:
return(reader.ReadInt32());
case BsonType.Int64:
case BsonType.Timestamp:
return(reader.ReadInt64());
case BsonType.Double:
return(reader.ReadDouble());
case BsonType.Document:
return(GenerateJObject(reader, parent));
case BsonType.Array:
return(GenerateJArray(reader, parent));
case BsonType.EndOfDocument:
break;
default:
break;
}
return(null);
}
public void TestUndefinedKeyword()
{
var json = "undefined";
using (_bsonReader = new JsonReader(json))
{
Assert.Equal(BsonType.Undefined, _bsonReader.ReadBsonType());
_bsonReader.ReadUndefined();
Assert.Equal(BsonReaderState.Initial, _bsonReader.State);
}
Assert.Equal(json, BsonSerializer.Deserialize <BsonUndefined>(json).ToJson());
}
public void TestUndefinedExtendedJson()
{
var json = "{ \"$undefined\" : true }";
using (_bsonReader = new JsonReader(json))
{
Assert.Equal(BsonType.Undefined, _bsonReader.ReadBsonType());
_bsonReader.ReadUndefined();
Assert.Equal(BsonReaderState.Initial, _bsonReader.State);
}
var canonicalJson = "undefined";
Assert.Equal(canonicalJson, BsonSerializer.Deserialize <BsonUndefined>(new StringReader(json)).ToJson());
}
/// <summary>
/// 做安全读入指定字段之前的准备工作
/// </summary>
/// <param name="bsonReader">Bson读取器</param>
/// <param name="expected">字段名</param>
/// <param name="read">字段名缓存</param>
/// <returns>是否可以继续读入</returns>
private static bool ReadPrep(this IBsonReader bsonReader, string expected, ref string read)
{
if (!bsonReader.ReadName(expected, ref read))
{
return(false);
}
switch (bsonReader.CurrentBsonType)
{
case BsonType.Null:
bsonReader.ReadNull();
return(false);
case BsonType.Undefined:
bsonReader.ReadUndefined();
return(false);
}
return(true);
}
/// <summary>
/// Reads a BSON undefined element from the reader.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="name">The name of the element.</param>
public static void ReadUndefined(this IBsonReader reader, string name)
{
VerifyName(reader, name);
reader.ReadUndefined();
}
// private methods
private void ReadValue()
{
object jsonDotNetValue;
switch (_wrappedReader.GetCurrentBsonType())
{
case BsonType.Array:
_wrappedReader.ReadStartArray();
SetCurrentToken(Newtonsoft.Json.JsonToken.StartArray);
return;
case BsonType.Binary:
var bsonBinaryData = _wrappedReader.ReadBinaryData();
switch (bsonBinaryData.SubType)
{
case BsonBinarySubType.UuidLegacy:
var guidRepresentation = GuidRepresentation.Unspecified;
var bsonReader = _wrappedReader as BsonReader;
if (bsonReader != null)
{
guidRepresentation = bsonReader.Settings.GuidRepresentation;
}
jsonDotNetValue = GuidConverter.FromBytes(bsonBinaryData.Bytes, guidRepresentation);
break;
case BsonBinarySubType.UuidStandard:
jsonDotNetValue = GuidConverter.FromBytes(bsonBinaryData.Bytes, GuidRepresentation.Standard);
break;
default:
jsonDotNetValue = bsonBinaryData.Bytes;
break;
}
SetCurrentToken(Newtonsoft.Json.JsonToken.Bytes, jsonDotNetValue, bsonBinaryData);
return;
case BsonType.Boolean:
var booleanValue = _wrappedReader.ReadBoolean();
SetCurrentToken(Newtonsoft.Json.JsonToken.Boolean, booleanValue, (BsonBoolean)booleanValue);
return;
case BsonType.DateTime:
var bsonDateTime = new BsonDateTime(_wrappedReader.ReadDateTime());
if (bsonDateTime.IsValidDateTime)
{
jsonDotNetValue = bsonDateTime.ToUniversalTime();
}
else
{
jsonDotNetValue = bsonDateTime.MillisecondsSinceEpoch;
}
SetCurrentToken(Newtonsoft.Json.JsonToken.Date, jsonDotNetValue, bsonDateTime);
return;
case BsonType.Document:
_wrappedReader.ReadStartDocument();
SetCurrentToken(Newtonsoft.Json.JsonToken.StartObject);
return;
case BsonType.Double:
var bsonDouble = new BsonDouble(_wrappedReader.ReadDouble());
switch (FloatParseHandling)
{
case Newtonsoft.Json.FloatParseHandling.Decimal:
jsonDotNetValue = Convert.ToDecimal(bsonDouble);
break;
case Newtonsoft.Json.FloatParseHandling.Double:
jsonDotNetValue = bsonDouble.Value;
break;
default:
throw new NotSupportedException(string.Format("Unexpected FloatParseHandling value: {0}.", FloatParseHandling));
}
SetCurrentToken(Newtonsoft.Json.JsonToken.Float, jsonDotNetValue, bsonDouble);
return;
case BsonType.Int32:
var bsonInt32 = (BsonInt32)_wrappedReader.ReadInt32();
SetCurrentToken(Newtonsoft.Json.JsonToken.Integer, (long)bsonInt32.Value, bsonInt32);
return;
case BsonType.Int64:
var bsonInt64 = (BsonInt64)_wrappedReader.ReadInt64();
SetCurrentToken(Newtonsoft.Json.JsonToken.Integer, bsonInt64.Value, bsonInt64);
return;
case BsonType.JavaScript:
{
var code = _wrappedReader.ReadJavaScript();
var bsonJavaScript = new BsonJavaScript(code);
SetCurrentToken(Newtonsoft.Json.JsonToken.String, code, bsonJavaScript);
}
return;
case BsonType.JavaScriptWithScope:
{
var code = _wrappedReader.ReadJavaScriptWithScope();
var context = BsonDeserializationContext.CreateRoot(_wrappedReader);
var scope = BsonDocumentSerializer.Instance.Deserialize <BsonDocument>(context);
var bsonJavaScriptWithScope = new BsonJavaScriptWithScope(code, scope);
SetCurrentToken(Newtonsoft.Json.JsonToken.String, code, bsonJavaScriptWithScope);
}
return;
case BsonType.MaxKey:
_wrappedReader.ReadMaxKey();
SetCurrentToken(Newtonsoft.Json.JsonToken.Undefined, null, BsonMaxKey.Value);
return;
case BsonType.MinKey:
_wrappedReader.ReadMinKey();
SetCurrentToken(Newtonsoft.Json.JsonToken.Undefined, null, BsonMinKey.Value);
return;
case BsonType.Null:
_wrappedReader.ReadNull();
SetCurrentToken(Newtonsoft.Json.JsonToken.Null, null, BsonNull.Value);
return;
case BsonType.ObjectId:
var bsonObjectId = new BsonObjectId(_wrappedReader.ReadObjectId());
SetCurrentToken(Newtonsoft.Json.JsonToken.Bytes, bsonObjectId.Value.ToByteArray(), bsonObjectId);
return;
case BsonType.RegularExpression:
var bsonRegularExpression = _wrappedReader.ReadRegularExpression();
var pattern = bsonRegularExpression.Pattern;
var options = bsonRegularExpression.Options;
jsonDotNetValue = "/" + pattern.Replace("/", "\\/") + "/" + options;
SetCurrentToken(Newtonsoft.Json.JsonToken.String, jsonDotNetValue, bsonRegularExpression);
return;
case BsonType.String:
var stringValue = _wrappedReader.ReadString();
SetCurrentToken(Newtonsoft.Json.JsonToken.String, stringValue, (BsonString)stringValue);
return;
case BsonType.Symbol:
var bsonSymbol = BsonSymbolTable.Lookup(_wrappedReader.ReadSymbol());
SetCurrentToken(Newtonsoft.Json.JsonToken.String, bsonSymbol.Name, bsonSymbol);
return;
case BsonType.Timestamp:
var bsonTimestamp = new BsonTimestamp(_wrappedReader.ReadTimestamp());
SetCurrentToken(Newtonsoft.Json.JsonToken.Integer, bsonTimestamp.Value, bsonTimestamp);
return;
case BsonType.Undefined:
_wrappedReader.ReadUndefined();
SetCurrentToken(Newtonsoft.Json.JsonToken.Undefined, null, BsonUndefined.Value);
return;
default:
var message = string.Format("Unexpected BsonType: {0}.", _wrappedReader.GetCurrentBsonType());
throw new Newtonsoft.Json.JsonReaderException(message);
}
}
public void TestUndefinedKeyword()
{
var json = "undefined";
using (_bsonReader = new JsonReader(json))
{
Assert.Equal(BsonType.Undefined, _bsonReader.ReadBsonType());
_bsonReader.ReadUndefined();
Assert.Equal(BsonReaderState.Initial, _bsonReader.State);
}
Assert.Equal(json, BsonSerializer.Deserialize<BsonUndefined>(json).ToJson());
}
public void TestUndefinedExtendedJson()
{
var json = "{ \"$undefined\" : true }";
using (_bsonReader = new JsonReader(json))
{
Assert.Equal(BsonType.Undefined, _bsonReader.ReadBsonType());
_bsonReader.ReadUndefined();
Assert.Equal(BsonReaderState.Initial, _bsonReader.State);
}
var canonicalJson = "undefined";
Assert.Equal(canonicalJson, BsonSerializer.Deserialize<BsonUndefined>(new StringReader(json)).ToJson());
}
public override bool Read()
{
if (bsonReader.State == BsonReaderState.Initial ||
bsonReader.State == BsonReaderState.ScopeDocument ||
bsonReader.State == BsonReaderState.Type)
{
bsonReader.ReadBsonType();
}
if (bsonReader.State == BsonReaderState.Name)
{
SetToken(NewtonsoftJsonToken.PropertyName, bsonReader.ReadName().UnescapeBson());
}
else if (bsonReader.State == BsonReaderState.Value)
{
switch (bsonReader.CurrentBsonType)
{
case BsonType.Document:
SetToken(NewtonsoftJsonToken.StartObject);
bsonReader.ReadStartDocument();
break;
case BsonType.Array:
SetToken(NewtonsoftJsonToken.StartArray);
bsonReader.ReadStartArray();
break;
case BsonType.Undefined:
SetToken(NewtonsoftJsonToken.Undefined);
bsonReader.ReadUndefined();
break;
case BsonType.Null:
SetToken(NewtonsoftJsonToken.Null);
bsonReader.ReadNull();
break;
case BsonType.String:
SetToken(NewtonsoftJsonToken.String, bsonReader.ReadString());
break;
case BsonType.Binary:
SetToken(NewtonsoftJsonToken.Bytes, bsonReader.ReadBinaryData().Bytes);
break;
case BsonType.Boolean:
SetToken(NewtonsoftJsonToken.Boolean, bsonReader.ReadBoolean());
break;
case BsonType.DateTime:
SetToken(NewtonsoftJsonToken.Date, bsonReader.ReadDateTime());
break;
case BsonType.Int32:
SetToken(NewtonsoftJsonToken.Integer, bsonReader.ReadInt32());
break;
case BsonType.Int64:
SetToken(NewtonsoftJsonToken.Integer, bsonReader.ReadInt64());
break;
case BsonType.Double:
SetToken(NewtonsoftJsonToken.Float, bsonReader.ReadDouble());
break;
case BsonType.Decimal128:
SetToken(NewtonsoftJsonToken.Float, Decimal128.ToDouble(bsonReader.ReadDecimal128()));
break;
default:
throw new NotSupportedException();
}
}
else if (bsonReader.State == BsonReaderState.EndOfDocument)
{
SetToken(NewtonsoftJsonToken.EndObject);
bsonReader.ReadEndDocument();
}
else if (bsonReader.State == BsonReaderState.EndOfArray)
{
SetToken(NewtonsoftJsonToken.EndArray);
bsonReader.ReadEndArray();
}
if (bsonReader.State == BsonReaderState.Initial)
{
return(true);
}
return(!bsonReader.IsAtEndOfFile());
}
