private static int Compare(JsonValueKind valueType, JsonElement objA, JsonElement objB)
{
/*Same types*/
if (objA.ValueKind == JsonValueKind.Null && objB.ValueKind == JsonValueKind.Null)
{
return(0);
}
if (objA.ValueKind == JsonValueKind.Undefined && objB.ValueKind == JsonValueKind.Undefined)
{
return(0);
}
if (objA.ValueKind == JsonValueKind.True && objB.ValueKind == JsonValueKind.True)
{
return(0);
}
if (objA.ValueKind == JsonValueKind.False && objB.ValueKind == JsonValueKind.False)
{
return(0);
}
if (objA.ValueKind == JsonValueKind.Number && objB.ValueKind == JsonValueKind.Number)
{
return(objA.GetDouble().CompareTo(objB.GetDouble()));
}
if (objA.ValueKind == JsonValueKind.String && objB.ValueKind == JsonValueKind.String)
{
return(objA.GetString().CompareTo(objB.GetString()));
}
//When objA is a number and objB is not.
if (objA.ValueKind == JsonValueKind.Number)
{
var valueObjA = objA.GetDouble();
if (objB.ValueKind == JsonValueKind.String)
{
if (double.TryParse(objB.GetRawText().AsSpan().TrimStart('"').TrimEnd('"'), out double queryValueTyped))
{
return(valueObjA.CompareTo(queryValueTyped));
}
}
}
//When objA is a string and objB is not.
if (objA.ValueKind == JsonValueKind.String)
{
if (objB.ValueKind == JsonValueKind.Number)
{
if (double.TryParse(objA.GetRawText().AsSpan().TrimStart('"').TrimEnd('"'), out double valueTyped))
{
return(valueTyped.CompareTo(objB.GetDouble()));
}
}
}
return(-1);
}
public static Object Deserialize(JSONELEMENT element)
{
if (element.ValueKind == JsonValueKind.Null)
{
return(null);
}
if (element.ValueKind == JsonValueKind.False)
{
return(false);
}
if (element.ValueKind == JsonValueKind.True)
{
return(true);
}
if (element.ValueKind == JsonValueKind.String)
{
return(element.GetString());
}
if (element.ValueKind == JsonValueKind.Number)
{
return(element.GetDouble());
}
if (element.ValueKind == JsonValueKind.Array)
{
return(_JsonArray.CreateFrom(element));
}
if (element.ValueKind == JsonValueKind.Object)
{
return(_JsonObject.CreateFrom(element));
}
throw new NotImplementedException();
}
/// <summary>
/// Gets the value of the element as a System.Object.
/// </summary>
public static object GetObjectValue(this JsonElement src)
{
if (src.ValueKind == JsonValueKind.Null)
{
return(null);
}
if (src.ValueKind == JsonValueKind.String)
{
return(src.GetString());
}
if (src.ValueKind == JsonValueKind.False || src.ValueKind == JsonValueKind.True)
{
return(src.GetBoolean());
}
if (src.ValueKind == JsonValueKind.Number)
{
return(src.GetDouble());
}
return(src.GetRawText());
}
internal static bool EqualsWithStringCoercion(JsonElement value, JsonElement queryValue)
{
if (value.Equals(queryValue))
{
return(true);
}
// Handle comparing an integer with a float
// e.g. Comparing 1 and 1.0
if (value.ValueKind == JsonValueKind.Number && queryValue.ValueKind == JsonValueKind.Number)
{
return(value.GetDouble() == queryValue.GetDouble());
}
if (queryValue.ValueKind != JsonValueKind.String)
{
return(false);
}
return(string.Equals(value.ToString(), queryValue.GetString(), StringComparison.Ordinal));
}
internal static bool EqualsWithStrictMatch(JsonElement value, JsonElement queryValue)
{
// we handle floats and integers the exact same way, so they are pseudo equivalent
if (value.ValueKind != queryValue.ValueKind)
{
return(false);
}
// Handle comparing an integer with a float
// e.g. Comparing 1 and 1.0
if (value.ValueKind == JsonValueKind.Number && queryValue.ValueKind == JsonValueKind.Number)
{
return(value.GetDouble() == queryValue.GetDouble());
}
if (value.ValueKind == JsonValueKind.String && queryValue.ValueKind == JsonValueKind.String)
{
return(value.GetString() == queryValue.GetString());
}
if (value.ValueKind == JsonValueKind.Null && queryValue.ValueKind == JsonValueKind.Null)
{
return(true);
}
if (value.ValueKind == JsonValueKind.Undefined && queryValue.ValueKind == JsonValueKind.Undefined)
{
return(true);
}
if ((value.ValueKind == JsonValueKind.False || value.ValueKind == JsonValueKind.True) &&
(queryValue.ValueKind == JsonValueKind.False || queryValue.ValueKind == JsonValueKind.True))
{
return(value.GetBoolean() == queryValue.GetBoolean());
}
return(value.Equals(queryValue));
}
public bool TryGet <T>(string key, out T value)
{
if (storage.TryGetValue(key, out object target))
{
if (target == null)
{
value = default(T);
return(true);
}
log.Debug($"Get: Key: '{key}', RequiredType: '{typeof(T).FullName}', ActualType: '{target.GetType().FullName}'.");
if (target is T targetValue)
{
value = targetValue;
return(true);
}
JsonElement element = (JsonElement)target;
if (typeof(T) == typeof(string))
{
value = (T)(object)element.GetString();
return(true);
}
if (typeof(T) == typeof(int))
{
value = (T)(object)element.GetInt32();
return(true);
}
if (typeof(T) == typeof(long))
{
value = (T)(object)element.GetInt64();
return(true);
}
if (typeof(T) == typeof(decimal))
{
value = (T)(object)element.GetDecimal();
return(true);
}
if (typeof(T) == typeof(double))
{
value = (T)(object)element.GetDouble();
return(true);
}
if (typeof(T) == typeof(bool))
{
value = (T)(object)element.GetBoolean();
return(true);
}
if (typeof(T) == typeof(IKey))
{
if (element.ValueKind == JsonValueKind.Null)
{
value = default(T);
return(true);
}
string type = element.GetProperty("Type").GetString();
if (element.TryGetProperty("Guid", out JsonElement rawGuid))
{
string rawGuidValue = rawGuid.GetString();
if (rawGuidValue == null)
{
value = (T)(object)GuidKey.Empty(type);
}
else
{
value = (T)(object)GuidKey.Create(Guid.Parse(rawGuidValue), type);
}
return(true);
}
else if (element.TryGetProperty("Identifier", out JsonElement rawIdentifier))
{
string rawIdentifierValue = rawIdentifier.GetString();
if (rawIdentifierValue == null)
{
value = (T)(object)StringKey.Empty(type);
}
else
{
value = (T)(object)StringKey.Create(rawIdentifierValue, type);
}
return(true);
}
}
if (typeof(T) == typeof(Color))
{
byte[] parts = element.GetString().Split(new char[] { ';' }).Select(p => Byte.Parse(p)).ToArray();
value = (T)(object)Color.FromArgb(parts[0], parts[1], parts[2], parts[3]);
log.Debug($"Get: Color: '{value}'.");
return(true);
}
if (typeof(T) == typeof(Price))
{
log.Debug($"Get: Price value type: '{element.GetProperty("Value").GetType().FullName}'.");
decimal priceValue = element.GetProperty("Value").GetDecimal();
string priceCurrency = element.GetProperty("Currency").GetString();
value = (T)(object)new Price(priceValue, priceCurrency);
return(true);
}
if (typeof(T) == typeof(DateTime))
{
string rawDateTime = element.GetString();
if (DateTime.TryParse(rawDateTime, out DateTime dateTime))
{
value = (T)(object)dateTime;
return(true);
}
else
{
log.Warning($"Get: Key: '{key}' not parseable to datetime from value '{rawDateTime}'.");
value = default(T);
return(false);
}
}
}
log.Debug($"Get: Key: '{key}' NOT FOUND. Storage: '{JsonSerializer.Serialize(storage)}'.");
value = default(T);
return(false);
}
