public void CheckJsonProperty(JsonProperty prop, JsonDataType? expectedType = null, string odataTypeName = null, bool? isArray = null, bool? customMembersIsNull = null)
{
if (expectedType != null)
Assert.AreEqual(expectedType.Value, prop.Type);
if (odataTypeName != null)
Assert.AreEqual(odataTypeName, prop.ODataTypeName);
if (isArray != null)
Assert.AreEqual(isArray.Value, prop.IsArray);
if (customMembersIsNull != null && customMembersIsNull.Value)
Assert.IsNull(prop.CustomMembers);
else if (customMembersIsNull != null && !customMembersIsNull.Value)
Assert.IsNotNull(prop.CustomMembers);
}
/// <nodoc /> EitherTag IEither.OnDeserializing(JsonDataType jsonType) => this.OnDeserializing(jsonType);
private void WriteValue(Array array)
{
// This method is called only if WriteValue(object) is called with an array
// The contract for XmlWriter.WriteValue(object) requires that this object array be written out as a string.
// E.g. WriteValue(new int[] { 1, 2, 3}) should be equivalent to WriteString("1 2 3").
JsonDataType oldDataType = _dataType;
// Set attribute mode to String because WritePrimitiveValue might write numerical text.
// Calls to methods that write numbers can't be mixed with calls that write quoted text unless the attribute mode is explictly string.
_dataType = JsonDataType.String;
StartText();
for (int i = 0; i < array.Length; i++)
{
if (i != 0)
{
_nodeWriter.WriteText(JsonGlobals.WhitespaceChar);
}
WritePrimitiveValue(array.GetValue(i));
}
_dataType = oldDataType;
}
void InitializeWriter()
{
nodeType = JsonNodeType.None;
dataType = JsonDataType.None;
isWritingDataTypeAttribute = false;
wroteServerTypeAttribute = false;
isWritingServerTypeAttribute = false;
serverTypeValue = null;
attributeText = null;
if (depth != 0)
{
depth = 0;
}
if ((scopes != null) && (scopes.Length > JsonGlobals.maxScopeSize))
{
scopes = null;
}
// Can't let writeState be at Closed if reinitializing.
writeState = WriteState.Start;
endElementBuffer = false;
indentLevel = 0;
}
public JsonData(object obj)
{
if (obj is Boolean) {
type = JsonDataType.Boolean;
inst_boolean = (bool) obj;
return;
}
if (obj is Double) {
type = JsonDataType.Double;
inst_double = (double) obj;
return;
}
if (obj is Int32) {
type = JsonDataType.Int;
inst_int = (int) obj;
return;
}
if (obj is Int64) {
type = JsonDataType.Long;
inst_long = (long) obj;
return;
}
if (obj is String) {
type = JsonDataType.String;
inst_string = (string) obj;
return;
}
throw new ArgumentException (
"Unable to wrap the given object with JsonData");
}
public JsonData(int number)
{
type = JsonDataType.Int;
inst_int = number;
}
void IJsonWrapper.SetLong(long val)
{
type = JsonDataType.Long;
inst_long = val;
json = null;
}
public JsonData(string str)
{
type = JsonDataType.String;
inst_string = str;
}
public JsonValue(string value, JsonDataType type) : base(type)
{
Value = value;
}
protected JsonItem(JsonDataType dataType)
{
DataType = dataType;
}
public JsonValue(StringMatchData matchData, JsonDataType dataType) : base(dataType)
{
_matchData = matchData;
}
public static bool Compare(string value1, string value2, JsonDataType targetType, BooleanComparisonType comparisonType)
{
switch (targetType)
{
case JsonDataType.Boolean:
bool bool_value1, bool_value2;
if (bool.TryParse(value1, out bool_value1) && bool.TryParse(value2, out bool_value2))
{
switch (comparisonType)
{
case BooleanComparisonType.Equals:
return(bool_value1 == bool_value2);
case BooleanComparisonType.NotEqualToBrackets:
case BooleanComparisonType.NotEqualToExclamation:
return(bool_value1 != bool_value2);
default:
throw new QueryCompilationException("Operator " + comparisonType.ToString() + " cannot be applied to operands of type \"boolean\".");
}
}
else
{
return(false);
}
case JsonDataType.Bytes:
switch (comparisonType)
{
case BooleanComparisonType.Equals:
return(value1 == value2);
case BooleanComparisonType.NotEqualToBrackets:
case BooleanComparisonType.NotEqualToExclamation:
return(value1 != value2);
default:
return(false);
}
case JsonDataType.Int:
int int_value1, int_value2;
if (int.TryParse(value1, out int_value1) && int.TryParse(value2, out int_value2))
{
switch (comparisonType)
{
case BooleanComparisonType.Equals:
return(int_value1 == int_value2);
case BooleanComparisonType.GreaterThan:
return(int_value1 > int_value2);
case BooleanComparisonType.GreaterThanOrEqualTo:
return(int_value1 >= int_value2);
case BooleanComparisonType.LessThan:
return(int_value1 < int_value2);
case BooleanComparisonType.LessThanOrEqualTo:
return(int_value1 <= int_value2);
case BooleanComparisonType.NotEqualToBrackets:
case BooleanComparisonType.NotEqualToExclamation:
return(int_value1 != int_value2);
case BooleanComparisonType.NotGreaterThan:
return(!(int_value1 > int_value2));
case BooleanComparisonType.NotLessThan:
return(!(int_value1 < int_value2));
default:
throw new QueryCompilationException("Operator " + comparisonType.ToString() + " cannot be applied to operands of type \"int\".");
}
}
else
{
return(false);
}
case JsonDataType.Long:
long long_value1, long_value2;
if (long.TryParse(value1, out long_value1) && long.TryParse(value2, out long_value2))
{
switch (comparisonType)
{
case BooleanComparisonType.Equals:
return(long_value1 == long_value2);
case BooleanComparisonType.GreaterThan:
return(long_value1 > long_value2);
case BooleanComparisonType.GreaterThanOrEqualTo:
return(long_value1 >= long_value2);
case BooleanComparisonType.LessThan:
return(long_value1 < long_value2);
case BooleanComparisonType.LessThanOrEqualTo:
return(long_value1 <= long_value2);
case BooleanComparisonType.NotEqualToBrackets:
case BooleanComparisonType.NotEqualToExclamation:
return(long_value1 != long_value2);
case BooleanComparisonType.NotGreaterThan:
return(!(long_value1 > long_value2));
case BooleanComparisonType.NotLessThan:
return(!(long_value1 < long_value2));
default:
throw new QueryCompilationException("Operator " + comparisonType.ToString() + " cannot be applied to operands of type \"long\".");
}
}
else
{
return(false);
}
case JsonDataType.Double:
double double_value1, double_value2;
if (double.TryParse(value1, out double_value1) && double.TryParse(value2, out double_value2))
{
switch (comparisonType)
{
case BooleanComparisonType.Equals:
return(double_value1 == double_value2);
case BooleanComparisonType.GreaterThan:
return(double_value1 > double_value2);
case BooleanComparisonType.GreaterThanOrEqualTo:
return(double_value1 >= double_value2);
case BooleanComparisonType.LessThan:
return(double_value1 < double_value2);
case BooleanComparisonType.LessThanOrEqualTo:
return(double_value1 <= double_value2);
case BooleanComparisonType.NotEqualToBrackets:
case BooleanComparisonType.NotEqualToExclamation:
return(double_value1 != double_value2);
case BooleanComparisonType.NotGreaterThan:
return(!(double_value1 > double_value2));
case BooleanComparisonType.NotLessThan:
return(!(double_value1 < double_value2));
default:
throw new QueryCompilationException("Operator " + comparisonType.ToString() + " cannot be applied to operands of type \"double\".");
}
}
else
{
return(false);
}
case JsonDataType.Float:
float float_value1, float_value2;
if (float.TryParse(value1, out float_value1) && float.TryParse(value2, out float_value2))
{
switch (comparisonType)
{
case BooleanComparisonType.Equals:
return(float_value1 == float_value2);
case BooleanComparisonType.GreaterThan:
return(float_value1 > float_value2);
case BooleanComparisonType.GreaterThanOrEqualTo:
return(float_value1 >= float_value2);
case BooleanComparisonType.LessThan:
return(float_value1 < float_value2);
case BooleanComparisonType.LessThanOrEqualTo:
return(float_value1 <= float_value2);
case BooleanComparisonType.NotEqualToBrackets:
case BooleanComparisonType.NotEqualToExclamation:
return(float_value1 != float_value2);
case BooleanComparisonType.NotGreaterThan:
return(!(float_value1 > float_value2));
case BooleanComparisonType.NotLessThan:
return(!(float_value1 < float_value2));
default:
throw new QueryCompilationException("Operator " + comparisonType.ToString() + " cannot be applied to operands of type \"float\".");
}
}
else
{
return(false);
}
case JsonDataType.String:
switch (comparisonType)
{
case BooleanComparisonType.Equals:
return(value1 == value2);
case BooleanComparisonType.GreaterThan:
case BooleanComparisonType.GreaterThanOrEqualTo:
return(value1.CompareTo(value2) > 0);
case BooleanComparisonType.LessThan:
case BooleanComparisonType.LessThanOrEqualTo:
return(value1.CompareTo(value2) > 0);
case BooleanComparisonType.NotEqualToBrackets:
case BooleanComparisonType.NotEqualToExclamation:
return(value1 != value2);
case BooleanComparisonType.NotGreaterThan:
return(value1.CompareTo(value2) <= 0);
case BooleanComparisonType.NotLessThan:
return(value1.CompareTo(value2) >= 0);
default:
throw new QueryCompilationException("Operator " + comparisonType.ToString() + " cannot be applied to operands of type \"string\".");
}
case JsonDataType.Date:
throw new NotImplementedException();
case JsonDataType.Null:
return(false);
default:
throw new QueryCompilationException("Unsupported data type.");
}
}
internal ReflectionCache(Type type)
{
Type = type;
TypeName = type.FullName;
AssemblyName = type.AssemblyQualifiedName;
CircularReferencable = type.IsValueType == false || type != typeof(string);
IsAbstract = type.IsUndetermined();
IsAnonymous = type.IsAnonymous();
JsonDataType = Reflection.GetJsonDataType(type);
SerializeMethod = JsonSerializer.GetWriteJsonMethod(type);
DeserializeMethod = JsonDeserializer.GetReadJsonMethod(type);
if (JsonDataType == JsonDataType.Enum)
{
IsFlaggedEnum = AttributeHelper.HasAttribute <FlagsAttribute> (type, false);
return;
}
if (type.IsPointer)
{
throw new JsonSerializationException("Can not serialize pointer type: " + type.AssemblyQualifiedName);
}
if (type.IsArray)
{
ArgumentTypes = new Type[] { type.GetElementType() };
CommonType = type.GetArrayRank() == 1 ? ComplexType.Array : ComplexType.MultiDimensionalArray;
}
else
{
var t = type;
if (t.IsGenericType == false)
{
while ((t = t.BaseType) != null)
{
if (t.IsGenericType)
{
break;
}
}
}
if (t != null)
{
ArgumentTypes = t.GetGenericArguments();
var gt = t.GetGenericTypeDefinition();
if (gt.Equals(typeof(Dictionary <,>)))
{
CommonType = ComplexType.Dictionary;
}
else if (gt.Equals(typeof(List <>)))
{
CommonType = ComplexType.List;
}
else if (gt.Equals(typeof(Nullable <>)))
{
CommonType = ComplexType.Nullable;
SerializeMethod = JsonSerializer.GetWriteJsonMethod(ArgumentTypes[0]);
}
}
}
if (typeof(IEnumerable).IsAssignableFrom(type))
{
if (typeof(Array).IsAssignableFrom(type) == false)
{
AppendItem = Reflection.CreateWrapperMethod <AddCollectionItem> (Reflection.FindMethod(type, "Add", new Type[] { null }));
}
if (ArgumentTypes != null && ArgumentTypes.Length == 1)
{
ItemSerializer = JsonSerializer.GetWriteJsonMethod(ArgumentTypes[0]);
ItemDeserializer = JsonDeserializer.GetReadJsonMethod(ArgumentTypes[0]);
}
}
if (ArgumentTypes != null)
{
ArgumentReflections = new ReflectionCache[ArgumentTypes.Length];
}
if (CommonType != ComplexType.Array &&
CommonType != ComplexType.MultiDimensionalArray &&
CommonType != ComplexType.Nullable)
{
if (type.IsPubliclyAccessible() == false)
{
ConstructorInfo |= ConstructorTypes.NonPublic;
}
if (type.IsClass || type.IsValueType)
{
try {
Constructor = Reflection.CreateConstructorMethod(type, type.IsVisible == false || typeof(DatasetSchema).Equals(type));
}
catch (Exception ex) {
throw new JsonSerializationException("Error occurred when creating constructor method for type " + type.AssemblyQualifiedName, ex);
}
if (Constructor != null && Constructor.Method.IsPublic == false)
{
ConstructorInfo |= ConstructorTypes.NonPublic;
}
if (Constructor == null)
{
var c = type.GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
if (c != null && c.Length > 0)
{
ConstructorInfo |= ConstructorTypes.Parametric;
}
}
Members = Reflection.GetMembers(type);
}
}
//if (typeof (IEnumerable).IsAssignableFrom (type)) {
// return;
//}
//if (JsonDataType != JsonDataType.Undefined) {
// return;
//}
}
/// <nodoc /> protected abstract EitherTag OnDeserializing(JsonDataType jsonType);
private void WriteServerTypeAttribute()
{
string str = serverTypeValue;
JsonDataType jsonDataType = dataType;
NameState _nameState = this.nameState;
(this).WriteStartElement("__type");
(this).WriteValue(str);
WriteEndElement();
dataType = jsonDataType;
this.nameState = _nameState;
wroteServerTypeAttribute = true;
}
private static JsonProperty ParseProperty(string name, JToken value, JsonSchema containerSchema)
{
switch (value.Type)
{
case JTokenType.Boolean:
return(new JsonProperty {
Name = name, Type = JsonDataType.Boolean, OriginalValue = value.ToString()
});
case JTokenType.Float:
case JTokenType.Integer:
return(new JsonProperty {
Name = name, Type = JsonDataType.Number, OriginalValue = value.ToString()
});
case JTokenType.String:
return(new JsonProperty {
Name = name, Type = JsonDataType.String, OriginalValue = value.ToString()
});
case JTokenType.Date:
return(new JsonProperty {
Name = name, Type = JsonDataType.String, OriginalValue = value.ToString()
});
case JTokenType.Object:
{
var objectSchema = ObjectToSchema((JObject)value);
if (objectSchema.ContainsKey("@odata.type"))
{
return(new JsonProperty {
Name = name, Type = JsonDataType.ODataType, ODataTypeName = objectSchema["@odata.type"].OriginalValue
});
}
else
{
// See if we can infer type from the parent scehma
JsonProperty schemaProperty;
JsonDataType propertyType = JsonDataType.Object;
string odataTypeName = null;
if (null != containerSchema && containerSchema.ExpectedProperties.TryGetValue(name, out schemaProperty))
{
odataTypeName = schemaProperty.ODataTypeName;
propertyType = schemaProperty.Type;
}
return(new JsonProperty {
Name = name, Type = propertyType, ODataTypeName = odataTypeName, CustomMembers = ObjectToSchema((JObject)value)
});
}
}
case JTokenType.Array:
{
// Array
JsonDataType propertyType = JsonDataType.Array;
string odataTypeName = null;
// Infer type from the items in the array
var firstChild = value.First;
if (null != firstChild)
{
var objectType = ParseProperty("array[0]", firstChild, null);
if (null != objectType)
{
odataTypeName = objectType.ODataTypeName;
propertyType = objectType.Type;
}
}
else
{
propertyType = JsonDataType.Array;
}
// See if we can do better than just Custom
if (propertyType == JsonDataType.Object)
{
JsonProperty schemaProperty;
if (null != containerSchema && containerSchema.ExpectedProperties.TryGetValue(name, out schemaProperty))
{
// Use the parent schema's type indication
odataTypeName = schemaProperty.ODataTypeName;
propertyType = schemaProperty.Type;
}
}
Dictionary <string, JsonProperty> members = null;
if (propertyType == JsonDataType.Object || propertyType == JsonDataType.Array)
{
var firstValue = (JObject)value.First;
members = firstValue != null?ObjectToSchema(firstValue) : new Dictionary <string, JsonProperty>();
}
return(new JsonProperty {
Name = name, Type = propertyType, ODataTypeName = odataTypeName, IsArray = true,
OriginalValue = value.ToString(), CustomMembers = members
});
}
case JTokenType.Null:
return(new JsonProperty {
Name = name, Type = JsonDataType.Object, IsArray = false, OriginalValue = null
});
default:
Console.WriteLine("Unsupported: Property {0} is of type {1} which is not currently supported.", name, value.Type);
throw new NotSupportedException(string.Format("Unsupported: Property {0} is of type {1} which is not currently supported.", name, value.Type));
}
}
MemberCache(MemberInfo memberInfo, Type memberType, string name)
{
MemberName = name;
MemberType = memberType;
MemberInfo = memberInfo;
JsonDataType dt = Reflection.GetJsonDataType (memberType);
DeserializeMethod = JsonDeserializer.GetReadJsonMethod (memberType);
SerializeMethod = JsonSerializer.GetWriteJsonMethod (memberType);
if (dt == JsonDataType.Array || dt == JsonDataType.MultiDimensionalArray) {
ElementType = memberType.GetElementType ();
}
IsValueType = memberType.IsValueType;
IsStruct = (IsValueType && !memberType.IsPrimitive && !memberType.IsEnum && typeof (decimal).Equals (memberType) == false);
IsClass = memberType.IsClass;
IsCollection = typeof (ICollection).IsAssignableFrom (memberType) && typeof (byte[]).Equals (memberType) == false;
if (memberType.IsGenericType) {
ElementType = memberType.GetGenericArguments ()[0];
IsNullable = memberType.GetGenericTypeDefinition ().Equals (typeof (Nullable<>));
}
if (IsValueType) {
ChangeType = IsNullable ? ElementType : memberType;
}
JsonDataType = dt;
}
internal static RevertJsonValue GetRevertMethod(JsonDataType type)
{
return(_revertMethods[(int)type]);
}
void IJsonWrapper.SetDouble(double val)
{
type = JsonDataType.Double;
inst_double = val;
json = null;
}
public JsonData(bool boolean)
{
type = JsonDataType.Boolean;
inst_boolean = boolean;
}
public JsonData(bool boolean)
{
type = JsonDataType.Boolean;
inst_boolean = boolean;
}
public JsonData(double number)
{
type = JsonDataType.Double;
inst_double = number;
}
private IDictionary EnsureDictionary()
{
if (type == JsonDataType.Object)
return (IDictionary) inst_object;
if (type != JsonDataType.None)
throw new InvalidOperationException (
"Instance of JsonData is not a dictionary");
type = JsonDataType.Object;
inst_object = new Dictionary<string, JsonData> ();
object_list = new List<KeyValuePair<string, JsonData>> ();
return (IDictionary) inst_object;
}
public JsonData(int number)
{
type = JsonDataType.Int;
inst_int = number;
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonDataAttribute"/> class.
/// </summary>
/// <param name="dataType">Type of the data.</param>
/// <param name="encode">if set to <c>true</c> [encode].</param>
public JsonDataAttribute(JsonDataType dataType, bool encode)
{
this.DataType = dataType;
this.Encode = encode;
}
public JsonData(long number)
{
type = JsonDataType.Long;
inst_long = number;
}
private void InitializeWriter()
{
_nodeType = JsonNodeType.None;
_dataType = JsonDataType.None;
_isWritingDataTypeAttribute = false;
_wroteServerTypeAttribute = false;
_isWritingServerTypeAttribute = false;
_serverTypeValue = null;
_attributeText = null;
if (_depth != 0)
{
_depth = 0;
}
if ((_scopes != null) && (_scopes.Length > JsonGlobals.maxScopeSize))
{
_scopes = null;
}
// Can't let writeState be at Closed if reinitializing.
_writeState = WriteState.Start;
_endElementBuffer = false;
_indentLevel = 0;
}
public JsonData(string str)
{
type = JsonDataType.String;
inst_string = str;
}
public override void WriteEndElement()
{
if (IsClosed)
{
ThrowClosed();
}
if (_depth == 0)
{
throw new XmlException(SR.JsonEndElementNoOpenNodes);
}
if (HasOpenAttribute)
{
throw new XmlException(SR.Format(SR.JsonOpenAttributeMustBeClosedFirst, "WriteEndElement"));
}
_endElementBuffer = false;
JsonNodeType token = ExitScope();
if (token == JsonNodeType.Collection)
{
_indentLevel--;
if (_indent)
{
if (_nodeType == JsonNodeType.Element)
{
_nodeWriter.WriteText(WHITESPACE);
}
else
{
WriteNewLine();
WriteIndent();
}
}
_nodeWriter.WriteText(JsonGlobals.EndCollectionChar);
token = ExitScope();
}
else if (_nodeType == JsonNodeType.QuotedText)
{
// For writing "
WriteJsonQuote();
}
else if (_nodeType == JsonNodeType.Element)
{
if ((_dataType == JsonDataType.None) && (_serverTypeValue != null))
{
throw new XmlException(SR.Format(SR.JsonMustSpecifyDataType, JsonGlobals.typeString, JsonGlobals.objectString, JsonGlobals.serverTypeString));
}
if (IsWritingNameWithMapping && !WrittenNameWithMapping)
{
// Ending </item> without writing item attribute
// Not providing a better error message because localization deadline has passed.
throw new XmlException(SR.Format(SR.JsonMustSpecifyDataType, JsonGlobals.itemString, string.Empty, JsonGlobals.itemString));
}
// the element is empty, it does not have any content,
if ((_dataType == JsonDataType.None) ||
(_dataType == JsonDataType.String))
{
_nodeWriter.WriteText(JsonGlobals.QuoteChar);
_nodeWriter.WriteText(JsonGlobals.QuoteChar);
}
}
else
{
// Assert on only StandaloneText and EndElement because preceding if
// conditions take care of checking for QuotedText and Element.
Fx.Assert((_nodeType == JsonNodeType.StandaloneText) || (_nodeType == JsonNodeType.EndElement),
"nodeType has invalid value " + _nodeType + ". Expected it to be QuotedText, Element, StandaloneText, or EndElement.");
}
if (_depth != 0)
{
if (token == JsonNodeType.Element)
{
_endElementBuffer = true;
}
else if (token == JsonNodeType.Object)
{
_indentLevel--;
if (_indent)
{
if (_nodeType == JsonNodeType.Element)
{
_nodeWriter.WriteText(WHITESPACE);
}
else
{
WriteNewLine();
WriteIndent();
}
}
_nodeWriter.WriteText(JsonGlobals.EndObjectChar);
if ((_depth > 0) && _scopes[_depth] == JsonNodeType.Element)
{
ExitScope();
_endElementBuffer = true;
}
}
}
_dataType = JsonDataType.None;
_nodeType = JsonNodeType.EndElement;
_nameState = NameState.None;
_wroteServerTypeAttribute = false;
}
void IJsonWrapper.SetBoolean(bool val)
{
type = JsonDataType.Boolean;
inst_boolean = val;
json = null;
}
private void InitializeWriter()
{
nodeType = JsonNodeType.None;
dataType = JsonDataType.None;
isWritingDataTypeAttribute = false;
wroteServerTypeAttribute = false;
isWritingServerTypeAttribute = false;
serverTypeValue = null;
attributeText = null;
depth = 0;
if (scopes != null && scopes.Length > 25)
scopes = null;
writeState = WriteState.Start;
endElementBuffer = false;
}
void IJsonWrapper.SetDouble(double val)
{
type = JsonDataType.Double;
inst_double = val;
json = null;
}
private void WriteValue(Array array)
{
JsonDataType jsonDataType = dataType;
dataType = JsonDataType.String;
StartText();
for (int index = 0; index < array.Length; ++index)
{
if (index != 0)
nodeWriter.Write(" ");
WritePrimitiveValue(array.GetValue(index));
}
dataType = jsonDataType;
}
void IJsonWrapper.SetInt(int val)
{
type = JsonDataType.Int;
inst_int = val;
json = null;
}
internal ReflectionCache(Type type)
{
Type = type;
TypeName = type.FullName;
AssemblyName = type.AssemblyQualifiedName;
JsonDataType = Reflection.GetJsonDataType (type);
SerializeMethod = JsonSerializer.GetWriteJsonMethod (type);
DeserializeMethod = JsonDeserializer.GetReadJsonMethod (type);
if (JsonDataType == JsonDataType.Enum) {
IsFlaggedEnum = AttributeHelper.HasAttribute<FlagsAttribute> (type, false);
return;
}
if (type.IsArray) {
ArgumentTypes = new Type[] { type.GetElementType () };
CommonType = type.GetArrayRank () == 1 ? ComplexType.Array : ComplexType.MultiDimensionalArray;
}
else {
var t = type;
if (t.IsGenericType == false) {
while ((t = t.BaseType) != null) {
if (t.IsGenericType) {
break;
}
}
}
if (t != null) {
ArgumentTypes = t.GetGenericArguments ();
var gt = t.GetGenericTypeDefinition ();
if (gt.Equals (typeof (Dictionary<,>))) {
CommonType = ComplexType.Dictionary;
}
else if (gt.Equals (typeof (List<>))) {
CommonType = ComplexType.List;
}
else if (gt.Equals (typeof (Nullable<>))) {
CommonType = ComplexType.Nullable;
SerializeMethod = JsonSerializer.GetWriteJsonMethod (ArgumentTypes[0]);
}
}
}
if (typeof(IEnumerable).IsAssignableFrom (type)) {
if (typeof(Array).IsAssignableFrom (type) == false) {
AppendItem = Reflection.CreateWrapperMethod<AddCollectionItem> (Reflection.FindMethod (type, "Add", new Type[1] { null }));
}
if (ArgumentTypes != null && ArgumentTypes.Length == 1) {
ItemSerializer = JsonSerializer.GetWriteJsonMethod (ArgumentTypes[0]);
ItemDeserializer = JsonDeserializer.GetReadJsonMethod (ArgumentTypes[0]);
}
}
if (ArgumentTypes != null) {
ArgumentReflections = new ReflectionCache[ArgumentTypes.Length];
}
if (CommonType != ComplexType.Array
&& CommonType != ComplexType.MultiDimensionalArray
&& CommonType != ComplexType.Nullable) {
var t = type;
if (type.IsNested == false && type.IsPublic == false) {
ConstructorInfo |= ConstructorTypes.NonPublic;
}
else {
while (t != null && t.IsNested) {
if (t.IsNestedPublic == false) {
ConstructorInfo |= ConstructorTypes.NonPublic;
}
t = t.DeclaringType;
}
}
if (type.IsClass || type.IsValueType) {
Constructor = Reflection.CreateConstructorMethod (type, type.IsVisible == false || typeof (DatasetSchema).Equals (type));
if (Constructor != null && Constructor.Method.IsPublic == false) {
ConstructorInfo |= ConstructorTypes.NonPublic;
}
if (Constructor == null) {
var c = type.GetConstructors (BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
if (c != null && c.Length > 0) {
ConstructorInfo |= ConstructorTypes.Parametric;
}
}
Members = Reflection.GetMembers (type);
}
}
//if (typeof (IEnumerable).IsAssignableFrom (type)) {
// return;
//}
//if (JsonDataType != JsonDataType.Undefined) {
// return;
//}
}
void IJsonWrapper.SetLong(long val)
{
type = JsonDataType.Long;
inst_long = val;
json = null;
}
void IJsonWrapper.SetBoolean(bool val)
{
type = JsonDataType.Boolean;
inst_boolean = val;
json = null;
}
void IJsonWrapper.SetString(string val)
{
type = JsonDataType.String;
inst_string = val;
json = null;
}
void IJsonWrapper.SetInt(int val)
{
type = JsonDataType.Int;
inst_int = val;
json = null;
}
public override void SetValue(string pValue)
{
mType = JsonDataType.StringValue;
mValue = pValue;
}
void IJsonWrapper.SetString(string val)
{
type = JsonDataType.String;
inst_string = val;
json = null;
}
public override void SetValue(float pValue)
{
mType = JsonDataType.FloatValue;
mValue = pValue;
}
public JsonData(double number)
{
type = JsonDataType.Double;
inst_double = number;
}
public override void SetValue(double pValue)
{
mType = JsonDataType.DoubleValue;
mValue = pValue;
}
public JsonData(long number)
{
type = JsonDataType.Long;
inst_long = number;
}
public override void SetValue(int pValue)
{
mType = JsonDataType.IntValue;
mValue = pValue;
}
private IList EnsureList()
{
if (type == JsonDataType.Array)
return (IList) inst_array;
if (type != JsonDataType.None)
throw new InvalidOperationException (
"Instance of JsonData is not a list");
type = JsonDataType.Array;
inst_array = new List<JsonData> ();
return (IList) inst_array;
}
public override void SetValue(long pValue)
{
mType = JsonDataType.LongValue;
mValue = pValue;
}
private static object MakeSwaggerProperty(JsonDataType type, string customDataType, string description)
{
Dictionary<string, object> definition = null;
if (type == JsonDataType.ODataType)
{
definition = new Dictionary<string, object> {
{ "$ref", "#/definitions/" + customDataType.SwaggerResourceName() }
};
}
else
{
definition = new Dictionary<string, object>
{
{ "type", type.SwaggerType() }
};
}
if (!string.IsNullOrEmpty(description))
{
definition.Add("description", description);
}
return definition;
}
public override void SetValue(bool pValue)
{
mType = JsonDataType.BoolValue;
mValue = pValue;
}
/// <summary>
/// Initializes a new instance of the <see cref="JsonDataAttribute"/> class.
/// </summary>
/// <param name="dataType">Type of the data.</param>
public JsonDataAttribute(JsonDataType dataType)
: this(dataType, false)
{
}
protected JsonData(JsonDataType type)
{
Type = type;
}
public override void WriteEndAttribute()
{
if (IsClosed)
{
ThrowClosed();
}
if (!HasOpenAttribute)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new XmlException(SR.GetString(SR.JsonNoMatchingStartAttribute)));
}
Fx.Assert(!(isWritingDataTypeAttribute && isWritingServerTypeAttribute),
"Can not write type attribute and __type attribute at the same time.");
if (isWritingDataTypeAttribute)
{
switch (attributeText)
{
case JsonGlobals.numberString:
{
ThrowIfServerTypeWritten(JsonGlobals.numberString);
dataType = JsonDataType.Number;
break;
}
case JsonGlobals.stringString:
{
ThrowIfServerTypeWritten(JsonGlobals.stringString);
dataType = JsonDataType.String;
break;
}
case JsonGlobals.arrayString:
{
ThrowIfServerTypeWritten(JsonGlobals.arrayString);
dataType = JsonDataType.Array;
break;
}
case JsonGlobals.objectString:
{
dataType = JsonDataType.Object;
break;
}
case JsonGlobals.nullString:
{
ThrowIfServerTypeWritten(JsonGlobals.nullString);
dataType = JsonDataType.Null;
break;
}
case JsonGlobals.booleanString:
{
ThrowIfServerTypeWritten(JsonGlobals.booleanString);
dataType = JsonDataType.Boolean;
break;
}
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new XmlException(SR.GetString(SR.JsonUnexpectedAttributeValue, attributeText)));
}
attributeText = null;
isWritingDataTypeAttribute = false;
if (!IsWritingNameWithMapping || WrittenNameWithMapping)
{
WriteDataTypeServerType();
}
}
else if (isWritingServerTypeAttribute)
{
serverTypeValue = attributeText;
attributeText = null;
isWritingServerTypeAttribute = false;
// we are writing __type after type="object" (enforced by WSE)
if ((!IsWritingNameWithMapping || WrittenNameWithMapping) && dataType == JsonDataType.Object)
{
WriteServerTypeAttribute();
}
}
else if (IsWritingNameAttribute)
{
WriteJsonElementName(attributeText);
attributeText = null;
nameState = NameState.IsWritingNameWithMapping | NameState.WrittenNameWithMapping;
WriteDataTypeServerType();
}
else if (isWritingXmlnsAttribute)
{
if (!string.IsNullOrEmpty(attributeText) && isWritingXmlnsAttributeDefaultNs)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("ns", SR.GetString(SR.JsonNamespaceMustBeEmpty, attributeText));
}
attributeText = null;
isWritingXmlnsAttribute = false;
isWritingXmlnsAttributeDefaultNs = false;
}
}
public ScalarValue(string value, JsonDataType dataType)
{
this.value = value;
this.dataType = dataType;
}
private void WriteServerTypeAttribute()
{
string value = _serverTypeValue;
JsonDataType oldDataType = _dataType;
NameState oldNameState = _nameState;
WriteStartElement(JsonGlobals.serverTypeString);
WriteValue(value);
WriteEndElement();
_dataType = oldDataType;
_nameState = oldNameState;
_wroteServerTypeAttribute = true;
}
public FieldValue(int fieldIndex)
{
this.fieldIndex = fieldIndex;
dataType = JsonDataType.String;
}
public override void WriteEndAttribute()
{
if (IsClosed)
{
ThrowClosed();
}
if (!HasOpenAttribute)
{
throw new XmlException(SR.JsonNoMatchingStartAttribute);
}
Fx.Assert(!(_isWritingDataTypeAttribute && _isWritingServerTypeAttribute),
"Can not write type attribute and __type attribute at the same time.");
if (_isWritingDataTypeAttribute)
{
switch (_attributeText)
{
case JsonGlobals.numberString:
{
ThrowIfServerTypeWritten(JsonGlobals.numberString);
_dataType = JsonDataType.Number;
break;
}
case JsonGlobals.stringString:
{
ThrowIfServerTypeWritten(JsonGlobals.stringString);
_dataType = JsonDataType.String;
break;
}
case JsonGlobals.arrayString:
{
ThrowIfServerTypeWritten(JsonGlobals.arrayString);
_dataType = JsonDataType.Array;
break;
}
case JsonGlobals.objectString:
{
_dataType = JsonDataType.Object;
break;
}
case JsonGlobals.nullString:
{
ThrowIfServerTypeWritten(JsonGlobals.nullString);
_dataType = JsonDataType.Null;
break;
}
case JsonGlobals.booleanString:
{
ThrowIfServerTypeWritten(JsonGlobals.booleanString);
_dataType = JsonDataType.Boolean;
break;
}
default:
throw new XmlException(SR.Format(SR.JsonUnexpectedAttributeValue, _attributeText));
}
_attributeText = null;
_isWritingDataTypeAttribute = false;
if (!IsWritingNameWithMapping || WrittenNameWithMapping)
{
WriteDataTypeServerType();
}
}
else if (_isWritingServerTypeAttribute)
{
_serverTypeValue = _attributeText;
_attributeText = null;
_isWritingServerTypeAttribute = false;
// we are writing __type after type="object" (enforced by WSE)
if ((!IsWritingNameWithMapping || WrittenNameWithMapping) && _dataType == JsonDataType.Object)
{
WriteServerTypeAttribute();
}
}
else if (IsWritingNameAttribute)
{
WriteJsonElementName(_attributeText);
_attributeText = null;
_nameState = NameState.IsWritingNameWithMapping | NameState.WrittenNameWithMapping;
WriteDataTypeServerType();
}
else if (_isWritingXmlnsAttribute)
{
if (!string.IsNullOrEmpty(_attributeText) && _isWritingXmlnsAttributeDefaultNs)
{
throw new ArgumentException(SR.Format(SR.JsonNamespaceMustBeEmpty, _attributeText));
}
_attributeText = null;
_isWritingXmlnsAttribute = false;
_isWritingXmlnsAttributeDefaultNs = false;
}
}
public override FieldObject Evaluate(RawRecord record)
{
//string value1 = f1.Evaluate(record);
//string value2 = f2.Evaluate(record);
string value1 = f1.Evaluate(record)?.ToValue;
string value2 = f2.Evaluate(record)?.ToValue;
JsonDataType targetType = DataType();
switch (targetType)
{
case JsonDataType.Boolean:
bool bool_value1, bool_value2;
if (bool.TryParse(value1, out bool_value1) && bool.TryParse(value2, out bool_value2))
{
switch (binaryType)
{
case BinaryExpressionType.BitwiseAnd:
//return (bool_value1 ^ bool_value2).ToString();
return(new StringField((bool_value1 ^ bool_value2).ToString(), JsonDataType.Boolean));
case BinaryExpressionType.BitwiseOr:
//return (bool_value1 | bool_value2).ToString();
return(new StringField((bool_value1 | bool_value2).ToString(), JsonDataType.Boolean));
case BinaryExpressionType.BitwiseXor:
//return (bool_value1 ^ bool_value2).ToString();
return(new StringField((bool_value1 ^ bool_value2).ToString(), JsonDataType.Boolean));
default:
throw new QueryCompilationException("Operator " + binaryType.ToString() + " cannot be applied to operands of type \"boolean\".");
}
}
else
{
throw new QueryCompilationException(string.Format("Cannot cast \"{0}\" or \"{1}\" to values of type \"boolean\"",
value1, value2));
}
case JsonDataType.Bytes:
switch (binaryType)
{
case BinaryExpressionType.Add:
//return value1 + value2.Substring(2); // A binary string starts with 0x
return(new StringField(value1 + value2.Substring(2), JsonDataType.Bytes));
default:
throw new QueryCompilationException("Operator " + binaryType.ToString() + " cannot be applied to operands of type \"bytes\".");
}
case JsonDataType.Int:
int int_value1, int_value2;
if (int.TryParse(value1, out int_value1) && int.TryParse(value2, out int_value2))
{
switch (binaryType)
{
case BinaryExpressionType.Add:
//return (int_value1 + int_value2).ToString();
return(new StringField((int_value1 + int_value2).ToString(), JsonDataType.Int));
case BinaryExpressionType.BitwiseAnd:
//return (int_value1 & int_value2).ToString();
return(new StringField((int_value1 & int_value2).ToString(), JsonDataType.Int));
case BinaryExpressionType.BitwiseOr:
//return (int_value1 | int_value2).ToString();
return(new StringField((int_value1 | int_value2).ToString(), JsonDataType.Int));
case BinaryExpressionType.BitwiseXor:
//return (int_value1 ^ int_value2).ToString();
return(new StringField((int_value1 ^ int_value2).ToString(), JsonDataType.Int));
case BinaryExpressionType.Divide:
//return (int_value1 / int_value2).ToString();
return(new StringField((int_value1 / int_value2).ToString(), JsonDataType.Int));
case BinaryExpressionType.Modulo:
//return (int_value1 % int_value2).ToString();
return(new StringField((int_value1 % int_value2).ToString(), JsonDataType.Int));
case BinaryExpressionType.Multiply:
//return (int_value1 * int_value2).ToString();
return(new StringField((int_value1 * int_value2).ToString(), JsonDataType.Int));
case BinaryExpressionType.Subtract:
//return (int_value1 - int_value2).ToString();
return(new StringField((int_value1 - int_value2).ToString(), JsonDataType.Int));
default:
//return "";
return(new StringField(""));
}
}
else
{
throw new QueryCompilationException(string.Format("Cannot cast \"{0}\" or \"{1}\" to values of type \"int\"",
value1, value2));
}
case JsonDataType.Long:
long long_value1, long_value2;
if (long.TryParse(value1, out long_value1) && long.TryParse(value2, out long_value2))
{
switch (binaryType)
{
case BinaryExpressionType.Add:
//return (long_value1 + long_value2).ToString();
return(new StringField((long_value1 + long_value2).ToString(), JsonDataType.Long));
case BinaryExpressionType.BitwiseAnd:
//return (long_value1 & long_value2).ToString();
return(new StringField((long_value1 & long_value2).ToString(), JsonDataType.Long));
case BinaryExpressionType.BitwiseOr:
//return (long_value1 | long_value2).ToString();
return(new StringField((long_value1 | long_value2).ToString(), JsonDataType.Long));
case BinaryExpressionType.BitwiseXor:
//return (long_value1 ^ long_value2).ToString();
return(new StringField((long_value1 ^ long_value2).ToString(), JsonDataType.Long));
case BinaryExpressionType.Divide:
//return (long_value1 / long_value2).ToString();
return(new StringField((long_value1 / long_value2).ToString(), JsonDataType.Long));
case BinaryExpressionType.Modulo:
//return (long_value1 % long_value2).ToString();
return(new StringField((long_value1 % long_value2).ToString(), JsonDataType.Long));
case BinaryExpressionType.Multiply:
//return (long_value1 * long_value2).ToString();
return(new StringField((long_value1 * long_value2).ToString(), JsonDataType.Long));
case BinaryExpressionType.Subtract:
//return (long_value1 - long_value2).ToString();
return(new StringField((long_value1 - long_value2).ToString(), JsonDataType.Long));
default:
//return "";
return(new StringField(""));
}
}
else
{
throw new QueryCompilationException(string.Format("Cannot cast \"{0}\" or \"{1}\" to values of type \"long\"",
value1, value2));
}
case JsonDataType.Double:
double double_value1, double_value2;
if (double.TryParse(value1, out double_value1) && double.TryParse(value2, out double_value2))
{
switch (binaryType)
{
case BinaryExpressionType.Add:
//return (double_value1 + double_value2).ToString();
return(new StringField((double_value1 + double_value2).ToString(), JsonDataType.Double));
case BinaryExpressionType.Divide:
//return (double_value1 / double_value2).ToString();
return(new StringField((double_value1 / double_value2).ToString(), JsonDataType.Double));
case BinaryExpressionType.Modulo:
//return (double_value1 % double_value2).ToString();
return(new StringField((double_value1 % double_value2).ToString(), JsonDataType.Double));
case BinaryExpressionType.Multiply:
//return (double_value1 * double_value2).ToString();
return(new StringField((double_value1 * double_value2).ToString(), JsonDataType.Double));
case BinaryExpressionType.Subtract:
//return (double_value1 - double_value2).ToString();
return(new StringField((double_value1 - double_value2).ToString(), JsonDataType.Double));
default:
throw new QueryCompilationException("Operator " + binaryType.ToString() + " cannot be applied to operands of type 'double'.");
}
}
else
{
throw new QueryCompilationException(string.Format("Cannot cast \"{0}\" or \"{1}\" to values of type \"double\"",
value1, value2));
}
case JsonDataType.Float:
float float_value1, float_value2;
if (float.TryParse(value1, out float_value1) && float.TryParse(value2, out float_value2))
{
switch (binaryType)
{
case BinaryExpressionType.Add:
//return (float_value1 + float_value2).ToString();
return(new StringField((float_value1 + float_value2).ToString(), JsonDataType.Float));
case BinaryExpressionType.Divide:
//return (float_value1 / float_value2).ToString();
return(new StringField((float_value1 / float_value2).ToString(), JsonDataType.Float));
case BinaryExpressionType.Modulo:
//return (float_value1 % float_value2).ToString();
return(new StringField((float_value1 % float_value2).ToString(), JsonDataType.Float));
case BinaryExpressionType.Multiply:
//return (float_value1 * float_value2).ToString();
return(new StringField((float_value1 * float_value2).ToString(), JsonDataType.Float));
case BinaryExpressionType.Subtract:
//return (float_value1 - float_value2).ToString();
return(new StringField((float_value1 - float_value2).ToString(), JsonDataType.Float));
default:
throw new QueryCompilationException("Operator " + binaryType.ToString() + " cannot be applied to operands of type 'float'.");
}
}
else
{
throw new QueryCompilationException(string.Format("Cannot cast \"{0}\" or \"{1}\" to values of type \"float\"",
value1, value2));
}
case JsonDataType.String:
switch (binaryType)
{
case BinaryExpressionType.Add:
//return value1 + value2;
return(new StringField(value1 + value2));
default:
throw new QueryCompilationException("Operator " + binaryType.ToString() + " cannot be applied to operands of type \"string\".");
}
case JsonDataType.Date:
throw new NotImplementedException();
case JsonDataType.Null:
return(null);
default:
throw new QueryCompilationException("Unsupported data type.");
}
}
public override void WriteStartElement(string prefix, string localName, string ns)
{
if (localName == null)
{
throw new ArgumentNullException(nameof(localName));
}
if (localName.Length == 0)
{
throw new ArgumentException(SR.JsonInvalidLocalNameEmpty, nameof(localName));
}
if (!string.IsNullOrEmpty(prefix))
{
if (string.IsNullOrEmpty(ns) || !TrySetWritingNameWithMapping(localName, ns))
{
throw new ArgumentException(SR.Format(SR.JsonPrefixMustBeNullOrEmpty, prefix), nameof(prefix));
}
}
if (!string.IsNullOrEmpty(ns))
{
if (!TrySetWritingNameWithMapping(localName, ns))
{
throw new ArgumentException(SR.Format(SR.JsonNamespaceMustBeEmpty, ns), nameof(ns));
}
}
if (IsClosed)
{
ThrowClosed();
}
if (HasOpenAttribute)
{
throw new XmlException(SR.Format(SR.JsonOpenAttributeMustBeClosedFirst, "WriteStartElement"));
}
if ((_nodeType != JsonNodeType.None) && _depth == 0)
{
throw new XmlException(SR.JsonMultipleRootElementsNotAllowedOnWriter);
}
switch (_nodeType)
{
case JsonNodeType.None:
{
if (!localName.Equals(JsonGlobals.rootString))
{
throw new XmlException(SR.Format(SR.JsonInvalidRootElementName, localName, JsonGlobals.rootString));
}
EnterScope(JsonNodeType.Element);
break;
}
case JsonNodeType.Element:
{
if ((_dataType != JsonDataType.Array) && (_dataType != JsonDataType.Object))
{
throw new XmlException(SR.JsonNodeTypeArrayOrObjectNotSpecified);
}
if (_indent)
{
WriteNewLine();
WriteIndent();
}
if (!IsWritingCollection)
{
if (_nameState != NameState.IsWritingNameWithMapping)
{
WriteJsonElementName(localName);
}
}
else if (!localName.Equals(JsonGlobals.itemString))
{
throw new XmlException(SR.Format(SR.JsonInvalidItemNameForArrayElement, localName, JsonGlobals.itemString));
}
EnterScope(JsonNodeType.Element);
break;
}
case JsonNodeType.EndElement:
{
if (_endElementBuffer)
{
_nodeWriter.WriteText(JsonGlobals.MemberSeparatorChar);
}
if (_indent)
{
WriteNewLine();
WriteIndent();
}
if (!IsWritingCollection)
{
if (_nameState != NameState.IsWritingNameWithMapping)
{
WriteJsonElementName(localName);
}
}
else if (!localName.Equals(JsonGlobals.itemString))
{
throw new XmlException(SR.Format(SR.JsonInvalidItemNameForArrayElement, localName, JsonGlobals.itemString));
}
EnterScope(JsonNodeType.Element);
break;
}
default:
throw new XmlException(SR.JsonInvalidStartElementCall);
}
_isWritingDataTypeAttribute = false;
_isWritingServerTypeAttribute = false;
_isWritingXmlnsAttribute = false;
_wroteServerTypeAttribute = false;
_serverTypeValue = null;
_dataType = JsonDataType.None;
_nodeType = JsonNodeType.Element;
}
public override bool Evaluate(RawRecord record)
{
//string value1 = firstScalarFunction.Evaluate(record);
//string value2 = secondScalarFunction.Evaluate(record);
string value1 = firstScalarFunction.Evaluate(record)?.ToValue;
string value2 = secondScalarFunction.Evaluate(record)?.ToValue;
JsonDataType type1 = firstScalarFunction.DataType();
JsonDataType type2 = secondScalarFunction.DataType();
JsonDataType targetType = type1 > type2 ? type1 : type2;
if (value1 == null || value2 == null)
{
return(false);
}
switch (targetType)
{
case JsonDataType.Boolean:
bool bool_value1, bool_value2;
if (bool.TryParse(value1, out bool_value1) && bool.TryParse(value2, out bool_value2))
{
switch (comparisonType)
{
case BooleanComparisonType.Equals:
return(bool_value1 == bool_value2);
case BooleanComparisonType.NotEqualToBrackets:
case BooleanComparisonType.NotEqualToExclamation:
return(bool_value1 != bool_value2);
default:
throw new QueryCompilationException("Operator " + comparisonType.ToString() + " cannot be applied to operands of type \"boolean\".");
}
}
else
{
throw new QueryCompilationException(string.Format("Cannot cast \"{0}\" or \"{1}\" to values of type \"boolean\"",
value1, value2));
}
case JsonDataType.Bytes:
switch (comparisonType)
{
case BooleanComparisonType.Equals:
return(value1 == value2);
case BooleanComparisonType.NotEqualToBrackets:
case BooleanComparisonType.NotEqualToExclamation:
return(value1 != value2);
default:
throw new NotImplementedException();
}
case JsonDataType.Int:
int int_value1, int_value2;
if (int.TryParse(value1, out int_value1) && int.TryParse(value2, out int_value2))
{
switch (comparisonType)
{
case BooleanComparisonType.Equals:
return(int_value1 == int_value2);
case BooleanComparisonType.GreaterThan:
return(int_value1 > int_value2);
case BooleanComparisonType.GreaterThanOrEqualTo:
return(int_value1 >= int_value2);
case BooleanComparisonType.LessThan:
return(int_value1 < int_value2);
case BooleanComparisonType.LessThanOrEqualTo:
return(int_value1 <= int_value2);
case BooleanComparisonType.NotEqualToBrackets:
case BooleanComparisonType.NotEqualToExclamation:
return(int_value1 != int_value2);
case BooleanComparisonType.NotGreaterThan:
return(!(int_value1 > int_value2));
case BooleanComparisonType.NotLessThan:
return(!(int_value1 < int_value2));
default:
throw new QueryCompilationException("Operator " + comparisonType.ToString() + " cannot be applied to operands of type \"int\".");
}
}
else
{
throw new QueryCompilationException(string.Format("Cannot cast \"{0}\" or \"{1}\" to values of type \"int\"",
value1, value2));
}
case JsonDataType.Long:
long long_value1, long_value2;
if (long.TryParse(value1, out long_value1) && long.TryParse(value2, out long_value2))
{
switch (comparisonType)
{
case BooleanComparisonType.Equals:
return(long_value1 == long_value2);
case BooleanComparisonType.GreaterThan:
return(long_value1 > long_value2);
case BooleanComparisonType.GreaterThanOrEqualTo:
return(long_value1 >= long_value2);
case BooleanComparisonType.LessThan:
return(long_value1 < long_value2);
case BooleanComparisonType.LessThanOrEqualTo:
return(long_value1 <= long_value2);
case BooleanComparisonType.NotEqualToBrackets:
case BooleanComparisonType.NotEqualToExclamation:
return(long_value1 != long_value2);
case BooleanComparisonType.NotGreaterThan:
return(!(long_value1 > long_value2));
case BooleanComparisonType.NotLessThan:
return(!(long_value1 < long_value2));
default:
throw new QueryCompilationException("Operator " + comparisonType.ToString() + " cannot be applied to operands of type \"long\".");
}
}
else
{
throw new QueryCompilationException(string.Format("Cannot cast \"{0}\" or \"{1}\" to values of type \"long\"",
value1, value2));
}
case JsonDataType.Double:
double double_value1, double_value2;
if (double.TryParse(value1, out double_value1) && double.TryParse(value2, out double_value2))
{
switch (comparisonType)
{
case BooleanComparisonType.Equals:
return(double_value1 == double_value2);
case BooleanComparisonType.GreaterThan:
return(double_value1 > double_value2);
case BooleanComparisonType.GreaterThanOrEqualTo:
return(double_value1 >= double_value2);
case BooleanComparisonType.LessThan:
return(double_value1 < double_value2);
case BooleanComparisonType.LessThanOrEqualTo:
return(double_value1 <= double_value2);
case BooleanComparisonType.NotEqualToBrackets:
case BooleanComparisonType.NotEqualToExclamation:
return(double_value1 != double_value2);
case BooleanComparisonType.NotGreaterThan:
return(!(double_value1 > double_value2));
case BooleanComparisonType.NotLessThan:
return(!(double_value1 < double_value2));
default:
throw new QueryCompilationException("Operator " + comparisonType.ToString() + " cannot be applied to operands of type \"double\".");
}
}
else
{
throw new QueryCompilationException(string.Format("Cannot cast \"{0}\" or \"{1}\" to values of type \"double\"",
value1, value2));
}
case JsonDataType.Float:
float float_value1, float_value2;
if (float.TryParse(value1, out float_value1) && float.TryParse(value2, out float_value2))
{
switch (comparisonType)
{
case BooleanComparisonType.Equals:
return(float_value1 == float_value2);
case BooleanComparisonType.GreaterThan:
return(float_value1 > float_value2);
case BooleanComparisonType.GreaterThanOrEqualTo:
return(float_value1 >= float_value2);
case BooleanComparisonType.LessThan:
return(float_value1 < float_value2);
case BooleanComparisonType.LessThanOrEqualTo:
return(float_value1 <= float_value2);
case BooleanComparisonType.NotEqualToBrackets:
case BooleanComparisonType.NotEqualToExclamation:
return(float_value1 != float_value2);
case BooleanComparisonType.NotGreaterThan:
return(!(float_value1 > float_value2));
case BooleanComparisonType.NotLessThan:
return(!(float_value1 < float_value2));
default:
throw new QueryCompilationException("Operator " + comparisonType.ToString() + " cannot be applied to operands of type \"float\".");
}
}
else
{
throw new QueryCompilationException(string.Format("Cannot cast \"{0}\" or \"{1}\" to values of type \"float\"",
value1, value2));
}
case JsonDataType.String:
switch (comparisonType)
{
case BooleanComparisonType.Equals:
return(value1 == value2);
case BooleanComparisonType.GreaterThan:
case BooleanComparisonType.GreaterThanOrEqualTo:
return(value1.CompareTo(value2) > 0);
case BooleanComparisonType.LessThan:
case BooleanComparisonType.LessThanOrEqualTo:
return(value1.CompareTo(value2) > 0);
case BooleanComparisonType.NotEqualToBrackets:
case BooleanComparisonType.NotEqualToExclamation:
return(value1 != value2);
case BooleanComparisonType.NotGreaterThan:
return(value1.CompareTo(value2) <= 0);
case BooleanComparisonType.NotLessThan:
return(value1.CompareTo(value2) >= 0);
default:
throw new QueryCompilationException("Operator " + comparisonType.ToString() + " cannot be applied to operands of type \"string\".");
}
case JsonDataType.Date:
throw new NotImplementedException();
case JsonDataType.Null:
return(false);
default:
throw new QueryCompilationException("Unsupported data type.");
}
}
