/// <summary>
/// Reads a typed array.
/// </summary>
/// <param name="T">Element type.</param>
/// <param name="Provider">Database provider object.</param>
/// <param name="Reader">Binary reader.</param>
/// <param name="FieldDataType">Field data type.</param>
/// <returns>String value.</returns>
/// <exception cref="ArgumentException">If the <paramref name="FieldDataType"/> was invalid.</exception>
public static Array ReadArray(Type T, MongoDBProvider Provider, IBsonReader Reader, BsonType FieldDataType)
{
switch (FieldDataType)
{
case BsonType.Array:
List <object> Elements = new List <object>();
IObjectSerializer S = Provider.GetObjectSerializer(T ?? typeof(GenericObject));
Reader.ReadStartArray();
while (Reader.State != BsonReaderState.EndOfArray)
{
BsonType?ElementType = null;
if (Reader.State == BsonReaderState.Type)
{
ElementType = Reader.ReadBsonType();
if (ElementType == BsonType.EndOfDocument)
{
break;
}
}
Elements.Add(S.Deserialize(Reader, ElementType, true));
}
Reader.ReadEndArray();
if (T is null)
{
return(Elements.ToArray());
}
int c = Elements.Count;
Array Result = Array.CreateInstance(T, c);
Array.Copy(Elements.ToArray(), 0, Result, 0, c);
return(Result);
case BsonType.Binary:
byte[] Bin = Reader.ReadBytes();
if (T is null || T == typeof(byte))
{
return(Bin);
}
c = Bin.Length;
Result = Array.CreateInstance(T, c);
Array.Copy(Bin, 0, Result, 0, c);
return(Result);
case BsonType.Null:
Reader.ReadNull();
return(null);
default:
throw new Exception("Array expected.");
}
}
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 TestHexData()
{
var expectedBytes = new byte[] { 0x01, 0x23 };
var json = "HexData(0, \"123\")";
using (_bsonReader = new JsonReader(json))
{
Assert.Equal(BsonType.Binary, _bsonReader.ReadBsonType());
var bytes = _bsonReader.ReadBytes();
Assert.True(expectedBytes.SequenceEqual(bytes));
Assert.Equal(BsonReaderState.Initial, _bsonReader.State);
}
var expectedJson = "new BinData(0, \"ASM=\")";
Assert.Equal(expectedJson, BsonSerializer.Deserialize <byte[]>(json).ToJson());
}
/// <summary>
/// Reads a typed array.
/// </summary>
/// <typeparam name="T">Element type.</typeparam>
/// <param name="Provider">Database provider object.</param>
/// <param name="Reader">Binary reader.</param>
/// <param name="FieldDataType">Field data type.</param>
/// <returns>String value.</returns>
/// <exception cref="ArgumentException">If the <paramref name="FieldDataType"/> was invalid.</exception>
public static T[] ReadArray <T>(MongoDBProvider Provider, IBsonReader Reader, BsonType FieldDataType)
{
switch (FieldDataType)
{
case BsonType.Array:
List <T> Elements = new List <T>();
IObjectSerializer S = Provider.GetObjectSerializer(typeof(T));
Reader.ReadStartArray();
while (Reader.State != BsonReaderState.EndOfArray)
{
BsonType?ElementType = null;
if (Reader.State == BsonReaderState.Type)
{
ElementType = Reader.ReadBsonType();
if (ElementType == BsonType.EndOfDocument)
{
break;
}
}
Elements.Add((T)S.Deserialize(Reader, ElementType, true));
}
Reader.ReadEndArray();
return(Elements.ToArray());
case BsonType.Binary:
object Temp = Reader.ReadBytes();
return((T[])Temp);
case BsonType.Null:
Reader.ReadNull();
return(null);
default:
throw new Exception("Array expected.");
}
}
internal static object Deserialize(IBsonReader reader)
{
switch (reader.GetCurrentBsonType())
{
case BsonType.ObjectId:
return(reader.ReadObjectId());
case BsonType.Boolean:
return(reader.ReadBoolean());
case BsonType.DateTime:
return(UnixTime.ToDateTime(reader.ReadDateTime()));
case BsonType.Int32:
return(reader.ReadInt32());
case BsonType.Binary:
return(reader.ReadBytes());
case BsonType.Int64:
return(reader.ReadInt64());
case BsonType.Double:
return(reader.ReadDouble());
case BsonType.Null:
reader.ReadNull();
return(null);
case BsonType.String:
return(reader.ReadString());
default:
throw new InvalidOperationException(
$"Cannot deserialize {reader.GetCurrentBsonType()} to native value.");
}
}
/// <summary>
/// Deserializes an object from a binary source.
/// </summary>
/// <param name="Reader">Binary deserializer.</param>
/// <param name="DataType">Optional datatype. If not provided, will be read from the binary source.</param>
/// <param name="Embedded">If the object is embedded into another.</param>
/// <returns>Deserialized object.</returns>
public override object Deserialize(IBsonReader Reader, BsonType?DataType, bool Embedded)
{
BsonReaderBookmark Bookmark = Reader.GetBookmark();
BsonType? DataTypeBak = DataType;
if (!DataType.HasValue)
{
DataType = Reader.ReadBsonType();
}
switch (DataType.Value)
{
case BsonType.Document:
break;
case BsonType.Boolean:
return(Reader.ReadBoolean());
case BsonType.Int32:
return(Reader.ReadInt32());
case BsonType.Int64:
return(Reader.ReadInt64());
case BsonType.Decimal128:
return((decimal)Reader.ReadDecimal128());
case BsonType.Double:
return(Reader.ReadDouble());
case BsonType.DateTime:
return(ObjectSerializer.UnixEpoch.AddMilliseconds(Reader.ReadDateTime()));
case BsonType.String:
case BsonType.Symbol:
case BsonType.JavaScript:
case BsonType.JavaScriptWithScope:
return(Reader.ReadString());
case BsonType.Binary:
return(Reader.ReadBytes());
case BsonType.Null:
Reader.ReadNull();
return(null);
default:
throw new Exception("Object or value expected.");
}
LinkedList <KeyValuePair <string, object> > Properties = new LinkedList <KeyValuePair <string, object> >();
LinkedList <KeyValuePair <string, object> > LowerCase = null;
string TypeName = string.Empty;
Guid ObjectId = Guid.Empty;
string CollectionName = string.Empty;
string FieldName;
BsonType ValueType;
object Value;
Reader.ReadStartDocument();
while (Reader.State == BsonReaderState.Type)
{
ValueType = Reader.ReadBsonType();
if (ValueType == BsonType.EndOfDocument)
{
break;
}
FieldName = Reader.ReadName();
switch (ValueType)
{
case BsonType.Array:
Value = GeneratedObjectSerializerBase.ReadArray(null, this.Provider, Reader, ValueType);
break;
case BsonType.Binary:
Value = Reader.ReadBytes();
break;
case BsonType.Boolean:
Value = Reader.ReadBoolean();
break;
case BsonType.DateTime:
Value = ObjectSerializer.UnixEpoch.AddMilliseconds(Reader.ReadDateTime());
break;
case BsonType.Decimal128:
Value = (decimal)Reader.ReadDecimal128();
break;
case BsonType.Document:
Value = this.Deserialize(Reader, ValueType, true);
break;
case BsonType.Double:
Value = Reader.ReadDouble();
break;
case BsonType.Int32:
Value = Reader.ReadInt32();
break;
case BsonType.Int64:
Value = Reader.ReadInt64();
break;
case BsonType.JavaScript:
Value = Reader.ReadJavaScript();
break;
case BsonType.JavaScriptWithScope:
Value = Reader.ReadJavaScriptWithScope();
break;
case BsonType.Null:
Value = null;
Reader.ReadNull();
break;
case BsonType.ObjectId:
Value = Reader.ReadObjectId();
break;
case BsonType.String:
Value = Reader.ReadString();
break;
case BsonType.Symbol:
Value = Reader.ReadSymbol();
break;
default:
throw new Exception("Unrecognized data type: " + ValueType.ToString());
}
switch (FieldName)
{
case "_id":
if (Value is Guid Guid)
{
ObjectId = Guid;
}
else if (Value is string s)
{
ObjectId = new Guid(s);
}
else if (Value is byte[] A)
{
ObjectId = new Guid(A);
}
else if (Value is ObjectId ObjId)
{
ObjectId = GeneratedObjectSerializerBase.ObjectIdToGuid(ObjId);
}
else
{
throw new Exception("Unrecognized Object ID type: " + Value.GetType().FullName);
}
break;
case "_type":
TypeName = Value?.ToString();
if (this.returnTypedObjects && !string.IsNullOrEmpty(TypeName))
{
Type DesiredType = Types.GetType(TypeName);
if (DesiredType is null)
{
DesiredType = typeof(GenericObject);
}
if (DesiredType != typeof(GenericObject))
{
IObjectSerializer Serializer2 = this.provider.GetObjectSerializer(DesiredType);
Reader.ReturnToBookmark(Bookmark);
return(Serializer2.Deserialize(Reader, DataTypeBak, Embedded));
}
}
break;
case "_collection":
CollectionName = Value?.ToString();
break;
default:
if (FieldName.EndsWith("_L"))
{
string s = FieldName.Substring(0, FieldName.Length - 2);
bool Ignore = false;
foreach (KeyValuePair <string, object> P in Properties)
{
if (P.Key == s)
{
Ignore = true;
break;
}
}
if (!Ignore)
{
if (LowerCase is null)
{
LowerCase = new LinkedList <KeyValuePair <string, object> >();
}
LowerCase.AddLast(new KeyValuePair <string, object>(s, Value));
}
}
else
{
Properties.AddLast(new KeyValuePair <string, object>(FieldName, Value));
}
break;
}
}
if (!(LowerCase is null))
{
foreach (KeyValuePair <string, object> P in LowerCase)
{
bool Ignore = false;
foreach (KeyValuePair <string, object> P2 in Properties)
{
if (P2.Key == P.Key)
{
Ignore = true;
break;
}
}
if (!Ignore)
{
Properties.AddLast(new KeyValuePair <string, object>(P.Key + "_L", P.Value));
}
}
}
Reader.ReadEndDocument();
return(new GenericObject(CollectionName, TypeName, ObjectId, Properties));
}
/// <summary>
/// Reads a BSON binary data element from the reader.
/// </summary>
/// <param name="reader">The reader.</param>
/// <param name="name">The name of the element.</param>
/// <returns>A byte array.</returns>
public static byte[] ReadBytes(this IBsonReader reader, string name)
{
VerifyName(reader, name);
return(reader.ReadBytes());
}
public void TestHexData()
{
var expectedBytes = new byte[] { 0x01, 0x23 };
var json = "HexData(0, \"123\")";
using (_bsonReader = new JsonReader(json))
{
Assert.Equal(BsonType.Binary, _bsonReader.ReadBsonType());
var bytes = _bsonReader.ReadBytes();
Assert.True(expectedBytes.SequenceEqual(bytes));
Assert.Equal(BsonReaderState.Initial, _bsonReader.State);
}
var expectedJson = "new BinData(0, \"ASM=\")";
Assert.Equal(expectedJson, BsonSerializer.Deserialize<byte[]>(json).ToJson());
}
