/// <summary>
/// Reads a single value.
/// </summary>
/// <param name="Reader">Binary reader.</param>
/// <param name="FieldDataType">Field data type.</param>
/// <returns>Single value.</returns>
/// <exception cref="ArgumentException">If the <paramref name="FieldDataType"/> was invalid.</exception>
public static float ReadSingle(IBsonReader Reader, BsonType FieldDataType)
{
switch (FieldDataType)
{
case BsonType.Boolean: return(Reader.ReadBoolean() ? (float)1 : (float)0);
case BsonType.Decimal128: return((float)Reader.ReadDecimal128());
case BsonType.Double: return((float)Reader.ReadDouble());
case BsonType.Int32: return((float)Reader.ReadInt32());
case BsonType.Int64: return((float)Reader.ReadInt64());
case BsonType.String: return(float.Parse(Reader.ReadString()));
case BsonType.MinKey: Reader.ReadMinKey(); return(float.MinValue);
case BsonType.MaxKey: Reader.ReadMaxKey(); return(float.MaxValue);
default:
throw new ArgumentException("Expected a single value, but was a " +
FieldDataType.ToString() + ".", nameof(FieldDataType));
}
}
/// <summary>
/// Reads a string value.
/// </summary>
/// <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 string ReadString(IBsonReader Reader, BsonType FieldDataType)
{
switch (FieldDataType)
{
case BsonType.Boolean: return(Reader.ReadBoolean().ToString());
case BsonType.DateTime: return(ObjectSerializer.UnixEpoch.AddMilliseconds(Reader.ReadDateTime()).ToString());
case BsonType.Decimal128: return(Reader.ReadDecimal128().ToString());
case BsonType.Double: return(Reader.ReadDouble().ToString());
case BsonType.Int32: return(Reader.ReadInt32().ToString());
case BsonType.Int64: return(Reader.ReadInt64().ToString());
case BsonType.JavaScript: return(Reader.ReadJavaScript());
case BsonType.JavaScriptWithScope: return(Reader.ReadJavaScriptWithScope());
case BsonType.Null: Reader.ReadNull(); return(null);
case BsonType.ObjectId: return(Reader.ReadObjectId().ToString());
case BsonType.String: return(Reader.ReadString());
case BsonType.Symbol: return(Reader.ReadSymbol());
default:
throw new ArgumentException("Expected a char value, but was a " +
FieldDataType.ToString() + ".", nameof(FieldDataType));
}
}
/// <summary>
/// Reads a char value.
/// </summary>
/// <param name="Reader">Binary reader.</param>
/// <param name="FieldDataType">Field data type.</param>
/// <returns>Char value.</returns>
/// <exception cref="ArgumentException">If the <paramref name="FieldDataType"/> was invalid.</exception>
public static char ReadChar(IBsonReader Reader, BsonType FieldDataType)
{
switch (FieldDataType)
{
case BsonType.Decimal128: return((char)Reader.ReadDecimal128());
case BsonType.Double: return((char)Reader.ReadDouble());
case BsonType.Int32: return((char)Reader.ReadInt32());
case BsonType.Int64: return((char)Reader.ReadInt64());
case BsonType.MinKey: Reader.ReadMinKey(); return(char.MinValue);
case BsonType.MaxKey: Reader.ReadMaxKey(); return(char.MaxValue);
case BsonType.String:
string s = Reader.ReadString();
return(string.IsNullOrEmpty(s) ? (char)0 : s[0]);
default:
throw new ArgumentException("Expected a char value, but was a " +
FieldDataType.ToString() + ".", nameof(FieldDataType));
}
}
/// <summary>
/// Reads a 64-bit unsigned integer value.
/// </summary>
/// <param name="Reader">Binary reader.</param>
/// <param name="FieldDataType">Field data type.</param>
/// <returns>64-bit unsigned integer value.</returns>
/// <exception cref="ArgumentException">If the <paramref name="FieldDataType"/> was invalid.</exception>
public static ulong ReadUInt64(IBsonReader Reader, BsonType FieldDataType)
{
switch (FieldDataType)
{
case BsonType.Boolean: return(Reader.ReadBoolean() ? (ulong)1 : (ulong)0);
case BsonType.Decimal128: return((ulong)Reader.ReadDecimal128());
case BsonType.Double: return((ulong)Reader.ReadDouble());
case BsonType.Int32: return((ulong)Reader.ReadInt32());
case BsonType.Int64: return((ulong)Reader.ReadInt64());
case BsonType.String: return(ulong.Parse(Reader.ReadString()));
case BsonType.MinKey: Reader.ReadMinKey(); return(ulong.MinValue);
case BsonType.MaxKey: Reader.ReadMaxKey(); return(ulong.MaxValue);
default:
throw new ArgumentException("Expected a 64-bit unsigned integer value, but was a " +
FieldDataType.ToString() + ".", nameof(FieldDataType));
}
}
/// <summary>
/// Reads a GUID value.
/// </summary>
/// <param name="Reader">Binary reader.</param>
/// <param name="FieldDataType">Field data type.</param>
/// <returns>Guid value.</returns>
/// <exception cref="ArgumentException">If the <paramref name="FieldDataType"/> was invalid.</exception>
public static Guid ReadGuid(IBsonReader Reader, BsonType FieldDataType)
{
switch (FieldDataType)
{
case BsonType.String: return(Guid.Parse(Reader.ReadString()));
default:
throw new ArgumentException("Expected a GUID value, but was a " +
FieldDataType.ToString() + ".", nameof(FieldDataType));
}
}
/// <summary>
/// TypeOf ($type)
/// </summary>
/// <param name="type">Bson Type</param>
public static IQuery TypeOf(BsonType type)
{
var bsonTypeName = type.ToString();
bsonTypeName = char.ToLower(bsonTypeName[0]) + bsonTypeName.Substring(1);
return(new Query
{
Operator = MongoOperator.TypeOf,
Value = new QueryValue <string>(bsonTypeName)
});
}
/// <summary>
/// Reads a string value.
/// </summary>
/// <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 byte[] ReadByteArray(IBsonReader Reader, BsonType FieldDataType)
{
switch (FieldDataType)
{
case BsonType.Binary: return(Reader.ReadBinaryData().Bytes);
case BsonType.Null: Reader.ReadNull(); return(null);
default:
throw new ArgumentException("Expected a byte array value, but was a " +
FieldDataType.ToString() + ".", nameof(FieldDataType));
}
}
/// <summary>
/// Reads a time span value.
/// </summary>
/// <param name="Reader">Binary reader.</param>
/// <param name="FieldDataType">Field data type.</param>
/// <returns>TimeSpan value.</returns>
/// <exception cref="ArgumentException">If the <paramref name="FieldDataType"/> was invalid.</exception>
public static TimeSpan ReadTimeSpan(IBsonReader Reader, BsonType FieldDataType)
{
switch (FieldDataType)
{
case BsonType.String: return(TimeSpan.Parse(Reader.ReadString()));
case BsonType.MinKey: Reader.ReadMinKey(); return(TimeSpan.MinValue);
case BsonType.MaxKey: Reader.ReadMaxKey(); return(TimeSpan.MaxValue);
default:
throw new ArgumentException("Expected a time span value, but was a " +
FieldDataType.ToString() + ".", nameof(FieldDataType));
}
}
/// <summary>
/// Reads a date & time value with offset.
/// </summary>
/// <param name="Reader">Binary reader.</param>
/// <param name="FieldDataType">Field data type.</param>
/// <returns>DateTimeOffset value.</returns>
/// <exception cref="ArgumentException">If the <paramref name="FieldDataType"/> was invalid.</exception>
public static DateTimeOffset ReadDateTimeOffset(IBsonReader Reader, BsonType FieldDataType)
{
switch (FieldDataType)
{
case BsonType.DateTime: return((DateTimeOffset)ObjectSerializer.UnixEpoch.AddMilliseconds(Reader.ReadDateTime()));
case BsonType.String: return(DateTimeOffset.Parse(Reader.ReadString()));
case BsonType.Document:
DateTime TP = DateTime.MinValue;
TimeSpan TZ = TimeSpan.Zero;
Reader.ReadStartDocument();
while (Reader.State == BsonReaderState.Type)
{
BsonType BsonType = Reader.ReadBsonType();
if (BsonType == BsonType.EndOfDocument)
{
break;
}
string FieldName = Reader.ReadName();
switch (FieldName)
{
case "tp":
TP = ObjectSerializer.UnixEpoch.AddMilliseconds(Reader.ReadDateTime());
break;
case "tz":
TZ = TimeSpan.Parse(Reader.ReadString());
break;
}
}
Reader.ReadEndDocument();
return(new DateTimeOffset(TP, TZ));
case BsonType.MinKey: Reader.ReadMinKey(); return(DateTimeOffset.MinValue);
case BsonType.MaxKey: Reader.ReadMaxKey(); return(DateTimeOffset.MaxValue);
default:
throw new ArgumentException("Expected a date & time value with offset, but was a " +
FieldDataType.ToString() + ".", nameof(FieldDataType));
}
}
private static BsonValue CastTo(BsonType bsonType, int value)
{
switch (bsonType)
{
case BsonType.Int32: return((int)0);
case BsonType.Int64: return((long)0);
case BsonType.Double: return((double)0);
case BsonType.Decimal128: return((decimal)0);
default:
throw new InMemoryDatabaseException($"Unable to cast {bsonType.ToString()} to a number");
}
}
/// <summary>
/// Reads a date & time value.
/// </summary>
/// <param name="Reader">Binary reader.</param>
/// <param name="FieldDataType">Field data type.</param>
/// <returns>DateTime value.</returns>
/// <exception cref="ArgumentException">If the <paramref name="FieldDataType"/> was invalid.</exception>
public static DateTime ReadDateTime(IBsonReader Reader, BsonType FieldDataType)
{
switch (FieldDataType)
{
case BsonType.DateTime: return(ObjectSerializer.UnixEpoch.AddMilliseconds(Reader.ReadDateTime()));
case BsonType.String: return(DateTime.Parse(Reader.ReadString()));
case BsonType.MinKey: Reader.ReadMinKey(); return(DateTime.MinValue);
case BsonType.MaxKey: Reader.ReadMaxKey(); return(DateTime.MaxValue);
default:
throw new ArgumentException("Expected a date & time value, but was a " +
FieldDataType.ToString() + ".", nameof(FieldDataType));
}
}
/// <summary>
/// Reads a boolean value.
/// </summary>
/// <param name="Reader">Binary reader.</param>
/// <param name="FieldDataType">Field data type.</param>
/// <returns>Boolean value.</returns>
/// <exception cref="ArgumentException">If the <paramref name="FieldDataType"/> was invalid.</exception>
public static bool ReadBoolean(IBsonReader Reader, BsonType FieldDataType)
{
switch (FieldDataType)
{
case BsonType.Boolean: return(Reader.ReadBoolean());
case BsonType.Decimal128: return(Reader.ReadDecimal128() != 0);
case BsonType.Double: return(Reader.ReadDouble() != 0);
case BsonType.Int32: return(Reader.ReadInt32() != 0);
case BsonType.Int64: return(Reader.ReadInt64() != 0);
case BsonType.MinKey: Reader.ReadMinKey(); return(false);
case BsonType.MaxKey: Reader.ReadMaxKey(); return(true);
default:
throw new ArgumentException("Expected a boolean value, but was a " + FieldDataType.ToString() + ".", nameof(FieldDataType));
}
}
public static bool TryConvertStringToBsonType(BsonType type, string value, out BsonValue bsonValue)
{
switch (type)
{
case BsonType.Binary:
try
{
bsonValue = BsonBinaryData.Create(Convert.FromBase64String(value));
return true;
}
catch
{
bsonValue = null;
return false;
}
case BsonType.Boolean:
{
bool parsed;
if (bool.TryParse(value, out parsed))
{
bsonValue = BsonBoolean.Create(parsed);
return true;
}
bsonValue = null;
return false;
}
case BsonType.DateTime:
{
DateTime parsed;
if (DateTime.TryParse(value, out parsed))
{
bsonValue = BsonDateTime.Create(parsed);
return true;
}
bsonValue = null;
return false;
}
case BsonType.Double:
{
double parsed;
if (double.TryParse(value, out parsed))
{
bsonValue = BsonDouble.Create(parsed);
return true;
}
bsonValue = null;
return false;
}
case BsonType.Int32:
{
Int32 parsed;
if (Int32.TryParse(value, out parsed))
{
bsonValue = BsonInt32.Create(parsed);
return true;
}
bsonValue = null;
return false;
}
case BsonType.Int64:
{
Int64 parsed;
if (Int64.TryParse(value, out parsed))
{
bsonValue = BsonInt64.Create(parsed);
return true;
}
bsonValue = null;
return false;
}
case BsonType.Null:
{
bsonValue = BsonNull.Value;
return true;
}
case BsonType.ObjectId:
try
{
bsonValue = BsonObjectId.Create(value);
return true;
}
catch
{
bsonValue = null;
return false;
}
case BsonType.String:
bsonValue = BsonString.Create(value);
return true;
// TimeStamp?
}
throw new ArgumentOutOfRangeException(string.Format("Conversion to BsonType.{0} not supported", type.ToString()), "type");
}
/// <summary>
/// Reads a nullable enum stored as a nullable 32-bit integer value.
/// </summary>
/// <param name="Reader">Binary reader.</param>
/// <param name="FieldDataType">Field data type.</param>
/// <param name="EnumType">Enumeration type.</param>
/// <returns>Nullable enumeration value.</returns>
/// <exception cref="ArgumentException">If the <paramref name="FieldDataType"/> was invalid.</exception>
public static object ReadNullableEnum(IBsonReader Reader, BsonType FieldDataType, Type EnumType)
{
switch (FieldDataType)
{
case BsonType.Int32: return(Enum.ToObject(EnumType, ReadInt32(Reader, FieldDataType)));
case BsonType.Int64: return(Enum.ToObject(EnumType, ReadInt64(Reader, FieldDataType)));
case BsonType.String: return(Enum.Parse(EnumType, Reader.ReadString()));
case BsonType.Null: Reader.ReadNull(); return(null);
default:
throw new ArgumentException("Expected an enumerated value, but was a " + FieldDataType.ToString() + ".", nameof(FieldDataType));
}
}
// Token: 0x060015D3 RID: 5587 RVA: 0x00072C00 File Offset: 0x00070E00
private void ReadType(BsonType type)
{
switch (type)
{
case BsonType.Number:
{
double num = this.ReadDouble();
if (this._floatParseHandling == FloatParseHandling.Decimal)
{
base.SetToken(JsonToken.Float, Convert.ToDecimal(num, CultureInfo.InvariantCulture));
return;
}
base.SetToken(JsonToken.Float, num);
return;
}
case BsonType.String:
case BsonType.Symbol:
base.SetToken(JsonToken.String, this.ReadLengthString());
return;
case BsonType.Object:
{
base.SetToken(JsonToken.StartObject);
BsonReader.ContainerContext containerContext = new BsonReader.ContainerContext(BsonType.Object);
this.PushContext(containerContext);
containerContext.Length = this.ReadInt32();
return;
}
case BsonType.Array:
{
base.SetToken(JsonToken.StartArray);
BsonReader.ContainerContext containerContext2 = new BsonReader.ContainerContext(BsonType.Array);
this.PushContext(containerContext2);
containerContext2.Length = this.ReadInt32();
return;
}
case BsonType.Binary:
{
BsonBinaryType bsonBinaryType;
byte[] array = this.ReadBinary(out bsonBinaryType);
object value = (bsonBinaryType != BsonBinaryType.Uuid) ? array : new Guid(array);
base.SetToken(JsonToken.Bytes, value);
return;
}
case BsonType.Undefined:
base.SetToken(JsonToken.Undefined);
return;
case BsonType.Oid:
{
byte[] value2 = this.ReadBytes(12);
base.SetToken(JsonToken.Bytes, value2);
return;
}
case BsonType.Boolean:
{
bool flag = Convert.ToBoolean(this.ReadByte());
base.SetToken(JsonToken.Boolean, flag);
return;
}
case BsonType.Date:
{
DateTime dateTime = DateTimeUtils.ConvertJavaScriptTicksToDateTime(this.ReadInt64());
DateTimeKind dateTimeKindHandling = this.DateTimeKindHandling;
DateTime dateTime2;
if (dateTimeKindHandling != DateTimeKind.Unspecified)
{
if (dateTimeKindHandling != DateTimeKind.Local)
{
dateTime2 = dateTime;
}
else
{
dateTime2 = dateTime.ToLocalTime();
}
}
else
{
dateTime2 = DateTime.SpecifyKind(dateTime, DateTimeKind.Unspecified);
}
base.SetToken(JsonToken.Date, dateTime2);
return;
}
case BsonType.Null:
base.SetToken(JsonToken.Null);
return;
case BsonType.Regex:
{
string str = this.ReadString();
string str2 = this.ReadString();
string value3 = "/" + str + "/" + str2;
base.SetToken(JsonToken.String, value3);
return;
}
case BsonType.Reference:
base.SetToken(JsonToken.StartObject);
this._bsonReaderState = BsonReader.BsonReaderState.ReferenceStart;
return;
case BsonType.Code:
base.SetToken(JsonToken.String, this.ReadLengthString());
return;
case BsonType.CodeWScope:
base.SetToken(JsonToken.StartObject);
this._bsonReaderState = BsonReader.BsonReaderState.CodeWScopeStart;
return;
case BsonType.Integer:
base.SetToken(JsonToken.Integer, (long)this.ReadInt32());
return;
case BsonType.TimeStamp:
case BsonType.Long:
base.SetToken(JsonToken.Integer, this.ReadInt64());
return;
default:
throw new ArgumentOutOfRangeException("type", "Unexpected BsonType value: " + type.ToString());
}
}
