public void Create_Setting()
{
bool valueChangedFired = false;
var setting = new Setting <int>(1);
setting.ValueChanged += (s, e) => valueChangedFired = true;
setting.Value.ShouldBeEquivalentTo(1);
setting.IsValueSet.ShouldBeEquivalentTo(false);
IJsonValue jsonValue = setting.ExportToJsonObject();
jsonValue.ValueType.ShouldBeEquivalentTo(JsonValueType.Number);
jsonValue.GetNumber().ShouldBeEquivalentTo(1.0M);
setting.Value = 2;
setting.Value.ShouldBeEquivalentTo(2);
setting.IsValueSet.ShouldBeEquivalentTo(true);
valueChangedFired.ShouldBeEquivalentTo(true);
setting.DefaultValue.ShouldBeEquivalentTo(1);
jsonValue = setting.ExportToJsonObject();
jsonValue.ValueType.ShouldBeEquivalentTo(JsonValueType.Number);
jsonValue.GetNumber().ShouldBeEquivalentTo(2.0M);
jsonValue = JsonValue.CreateNumberValue(3);
setting.ImportFromJsonValue(jsonValue);
setting.Value.ShouldBeEquivalentTo(3);
}
private static string formatVinnere(IJsonValue x)
{
if (x.GetNumber() == 0d)
{
return(Utils.isEnglish() ? "no winners" : "ingen vinnere");
}
else if (x.GetNumber() == 1d)
{
return(Utils.isEnglish() ? "1 winner" : "1 vinner");
}
else
{
return(String.Format("{0} {1}", x.GetNumber().ToString("### ###"), Utils.isEnglish() ? "winners" : "vinnere"));
}
}
internal void SetValue(object item, IJsonValue value)
{
// clunky and basic primitive conversion...
object toSet = null;
if (value.ValueType == JsonValueType.String)
{
toSet = value.GetString();
}
else if (value.ValueType == JsonValueType.Number)
{
toSet = value.GetNumber();
}
else if (value.ValueType == JsonValueType.Boolean)
{
toSet = value.GetBoolean();
}
else
{
throw new NotSupportedException(string.Format("Cannot handle '{0}'.", value.ValueType));
}
// convert to the target type and set...
toSet = Convert.ChangeType(toSet, this.Property.PropertyType);
this.Property.SetValue(item, toSet);
}
internal static object ValueToObject(IJsonValue value)
{
switch (value.ValueType)
{
case JsonValueType.Null:
return(null);
case JsonValueType.Boolean:
return(value.GetBoolean());
case JsonValueType.Number:
return(value.GetNumber());
case JsonValueType.String:
return(value.GetString());
case JsonValueType.Object:
return(new JsonPropertyProvider(value.GetObject()));
case JsonValueType.Array:
return(new JsonVectorView(value.GetArray()));
default:
throw new ArgumentException();
}
}
public static bool TryGetFloat(this IJsonValue data, out float retVal)
{
if (data == null)
{
retVal = default(float);
return(false);
}
if (data.ValueType == JsonValueType.String)
{
if (!float.TryParse(data.GetString(), out retVal))
{
retVal = default(float);
return(false);
}
return(true);
}
else if (data.ValueType == JsonValueType.Number)
{
retVal = (float)data.GetNumber();
return(true);
}
else
{
retVal = default(float);
return(false);
}
}
public static bool TryGetDouble(this IJsonValue data, out double retVal)
{
if (data == null)
{
retVal = default(double);
return(false);
}
if (data.ValueType == JsonValueType.String)
{
if (!double.TryParse(data.GetString(), out retVal))
{
retVal = default(double);
return(false);
}
return(true);
}
else if (data.ValueType == JsonValueType.Number)
{
retVal = data.GetNumber();
return(true);
}
else
{
retVal = default(double);
return(false);
}
}
public static bool TryGetInt(this IJsonValue data, out int retVal)
{
if (data == null)
{
retVal = default(int);
return(false);
}
if (data.ValueType == JsonValueType.String)
{
if (!int.TryParse(data.GetString(), out retVal))
{
retVal = default(int);
return(false);
}
return(true);
}
else if (data.ValueType == JsonValueType.Number)
{
retVal = (int)Math.Round(data.GetNumber());
return(true);
}
else
{
retVal = default(int);
return(false);
}
}
private void Process(out JsonObject jsonObj, IJsonValue jsonData)
{
switch (jsonData.ValueType)
{
case JsonValueType.Null:
jsonObj = new JsonObject();
break;
case JsonValueType.Boolean:
jsonObj = new JsonObject(jsonData.GetBoolean());
break;
case JsonValueType.Number:
jsonObj = new JsonObject(jsonData.GetNumber());
break;
case JsonValueType.String:
jsonObj = new JsonObject(jsonData.GetString());
break;
case JsonValueType.Array:
jsonObj = new JsonObject(JsonObjectType.Array);
ProcessArray(jsonObj, jsonData.GetArray());
break;
case JsonValueType.Object:
jsonObj = new JsonObject(JsonObjectType.Object);
ProcessObject(jsonObj, jsonData.GetObject());
break;
default:
throw new Exception("意外情况");
}
}
public static object[] ToObjectArray(this IJsonValue v)
{
List <object> result = new List <object>();
switch (v.ValueType)
{
case JsonValueType.Boolean:
result.Add(v.GetBoolean());
break;
case JsonValueType.Null:
result.Add(null);
break;
case JsonValueType.Number:
result.Add(v.GetNumber());
break;
case JsonValueType.String:
result.Add(v.GetString());
break;
case JsonValueType.Array:
result.Add(v.GetArray().ToObjectArray());
break;
}
return(result.ToArray());
}
public void NumericValue_Serialize()
{
IComponentState state = new NumericSensorValue(5);
IJsonValue jsonValue = state.ToJsonValue();
jsonValue.ValueType.ShouldBeEquivalentTo(JsonValueType.Number);
jsonValue.GetNumber().ShouldBeEquivalentTo(5);
}
public void Number_ToJsonValue()
{
IJsonValue jsonValue = 1.6D.ToJsonValue();
(jsonValue == null).ShouldBeEquivalentTo(false);
jsonValue.ValueType.ShouldBeEquivalentTo(JsonValueType.Number);
jsonValue.GetNumber().ShouldBeEquivalentTo(1.6D);
}
private void WriteJsonValue(JsonWriter writer, IJsonValue value)
{
switch (value.ValueType)
{
case JsonValueType.Array:
{
JsonArray a = value.GetArray();
writer.WriteStartArray();
for (int i = 0; i < a.Count; i++)
{
WriteJsonValue(writer, a[i]);
}
writer.WriteEndArray();
}
break;
case JsonValueType.Boolean:
{
writer.WriteValue(value.GetBoolean());
}
break;
case JsonValueType.Null:
{
writer.WriteNull();
}
break;
case JsonValueType.Number:
{
// JsonValue doesn't support integers
// serialize whole numbers without a decimal point
double d = value.GetNumber();
bool isInteger = (d % 1 == 0);
if (isInteger && d <= long.MaxValue && d >= long.MinValue)
writer.WriteValue(Convert.ToInt64(d));
else
writer.WriteValue(d);
}
break;
case JsonValueType.Object:
{
JsonObject o = value.GetObject();
writer.WriteStartObject();
foreach (KeyValuePair<string, IJsonValue> v in o)
{
writer.WritePropertyName(v.Key);
WriteJsonValue(writer, v.Value);
}
writer.WriteEndObject();
}
break;
case JsonValueType.String:
{
writer.WriteValue(value.GetString());
}
break;
default:
throw new ArgumentOutOfRangeException("ValueType");
}
}
private void WriteJsonValue(JsonWriter writer, IJsonValue value)
{
switch (value.ValueType)
{
case JsonValueType.Array:
{
JsonArray a = value.GetArray();
writer.WriteStartArray();
for (int i = 0; i < a.Count; i++)
{
WriteJsonValue(writer, a[i]);
}
writer.WriteEndArray();
}
break;
case JsonValueType.Boolean:
{
writer.WriteValue(value.GetBoolean());
}
break;
case JsonValueType.Null:
{
writer.WriteNull();
}
break;
case JsonValueType.Number:
{
writer.WriteValue(value.GetNumber());
}
break;
case JsonValueType.Object:
{
JsonObject o = value.GetObject();
writer.WriteStartObject();
foreach (KeyValuePair <string, IJsonValue> v in o)
{
writer.WritePropertyName(v.Key);
WriteJsonValue(writer, v.Value);
}
writer.WriteEndObject();
}
break;
case JsonValueType.String:
{
writer.WriteValue(value.GetString());
}
break;
default:
throw new ArgumentOutOfRangeException("ValueType");
}
}
private static object _jsonDeserialize_convert(IJsonValue json)
{
object obj = null;
switch (json.ValueType)
{
case JsonValueType.Array:
JsonArray jsonArray = json.GetArray();
object[] objArray = new object[jsonArray.Count];
for (int i1 = 0; i1 < jsonArray.Count; i1++)
{
objArray[i1] = _jsonDeserialize_convert(jsonArray[i1]);
}
obj = objArray;
break;
case JsonValueType.Boolean:
obj = json.GetBoolean();
break;
case JsonValueType.Null:
obj = null;
break;
case JsonValueType.Number:
obj = json.GetNumber();
break;
case JsonValueType.Object:
JsonObject jsonObject = json.GetObject();
Dictionary <string, object> d = new Dictionary <string, object>();
List <string> keys = new List <string>();
foreach (var key in jsonObject.Keys)
{
keys.Add(key);
}
int i2 = 0;
foreach (var item in jsonObject.Values)
{
d.Add(keys[i2], _jsonDeserialize_convert(item));
i2++;
}
obj = d;
break;
case JsonValueType.String:
obj = json.GetString();
break;
}
return(obj);
}
public int Compare(JsonObject x, JsonObject y)
{
int result = -1;
IJsonValue xValue = null;
IJsonValue yValue = null;
x.TryGetValue(key, out xValue);
y.TryGetValue(key, out yValue);
if (xValue != null && yValue != null)
{
// If they are both number do a compare.
if (xValue.ValueType == JsonValueType.Number && yValue.ValueType == JsonValueType.Number)
{
result = xValue.GetNumber().CompareTo(yValue.GetNumber());
}
else
{
// If x is a number, it is less they y.
if (xValue.ValueType == JsonValueType.Number)
{
result = -1;
}
// If y is a number, x is greater then y
else if (y.ValueType == JsonValueType.Number)
{
result = 1;
}
// If neither are a number they are equal
else
{
result = 0;
}
}
}
else
{
if (xValue == null)
{
// x is less then y.
result = -1;
}
else if (yValue == null)
{
// x is greater then y.
result = 1;
}
else
{
// x and y are equal
result = 0;
}
}
return(result);
}
internal static float ValueFromObject(IJsonValue @object)
{
if (@object.ValueType == JsonValueType.Number)
{
return((float)@object.GetNumber());
}
if (@object.ValueType == JsonValueType.Array)
{
return((float)@object.GetArray()[0].GetNumber());
}
return(0);
}
private static void PrettyPrintValue(StringBuilder builder, IJsonValue jsonValue, int indent)
{
switch (jsonValue.ValueType)
{
case JsonValueType.String:
builder.Append($"\"{jsonValue.GetString()}\"");
break;
case JsonValueType.Boolean:
builder.Append($"{jsonValue.GetBoolean()}");
break;
case JsonValueType.Number:
builder.Append($"{jsonValue.GetNumber()}");
break;
case JsonValueType.Null:
builder.Append($"null");
break;
case JsonValueType.Object:
builder.Append("{\r\n");
indent++;
foreach (var item in jsonValue.GetObject()) //doesn't preserve order
{
Tabs(builder, indent);
builder.Append($"\"{item.Key}\": ");
PrettyPrintValue(builder, (item.Value), indent);
}
RemoveLastComma(builder);
indent--;
Tabs(builder, indent);
builder.Append("}");
break;
case JsonValueType.Array:
builder.Append("[\r\n");
indent++;
foreach (IJsonValue value in jsonValue.GetArray())
{
Tabs(builder, indent);
PrettyPrintValue(builder, value, indent);
}
RemoveLastComma(builder);
indent--;
Tabs(builder, indent);
builder.Append("]");
break;
}
builder.Append(",\r\n");
}
private void WriteJsonValue(JsonWriter writer, IJsonValue value)
{
switch (value.ValueType)
{
case JsonValueType.Array:
{
JsonArray a = value.GetArray();
writer.WriteStartArray();
for (int i = 0; i < a.Count; i++)
{
WriteJsonValue(writer, a[i]);
}
writer.WriteEndArray();
}
break;
case JsonValueType.Boolean:
{
writer.WriteValue(value.GetBoolean());
}
break;
case JsonValueType.Null:
{
writer.WriteNull();
}
break;
case JsonValueType.Number:
{
writer.WriteValue(value.GetNumber());
}
break;
case JsonValueType.Object:
{
JsonObject o = value.GetObject();
writer.WriteStartObject();
foreach (KeyValuePair<string, IJsonValue> v in o)
{
writer.WritePropertyName(v.Key);
WriteJsonValue(writer, v.Value);
}
writer.WriteEndObject();
}
break;
case JsonValueType.String:
{
writer.WriteValue(value.GetString());
}
break;
default:
throw new ArgumentOutOfRangeException("ValueType");
}
}
private static object _jsonDeserialize_convert(IJsonValue json)
{
object obj = null;
switch (json.ValueType)
{
case JsonValueType.Array:
JsonArray jsonArray = json.GetArray();
object[] objArray = new object[jsonArray.Count];
for (int i1 = 0; i1 < jsonArray.Count; i1++)
{
objArray[i1] = _jsonDeserialize_convert(jsonArray[i1]);
}
obj = objArray;
break;
case JsonValueType.Boolean:
obj = json.GetBoolean();
break;
case JsonValueType.Null:
obj = null;
break;
case JsonValueType.Number:
obj = json.GetNumber();
break;
case JsonValueType.Object:
JsonObject jsonObject = json.GetObject();
Dictionary<string, object> d = new Dictionary<string, object>();
List<string> keys = new List<string>();
foreach (var key in jsonObject.Keys)
{
keys.Add(key);
}
int i2 = 0;
foreach (var item in jsonObject.Values)
{
d.Add(keys[i2], _jsonDeserialize_convert(item));
i2++;
}
obj = d;
break;
case JsonValueType.String:
obj = json.GetString();
break;
}
return obj;
}
private static int ParseAsInt(IJsonValue jsonValue, int defaultValue = -1)
{
if (jsonValue.ValueType == JsonValueType.Number)
{
return((int)jsonValue.GetNumber());
}
else if (jsonValue.ValueType == JsonValueType.String)
{
int rv;
if (!int.TryParse(jsonValue.GetString(), out rv))
{
return(defaultValue);
}
return(rv);
}
else
{
return(defaultValue);
}
}
private void RenderValue(IJsonValue json, double indent)
{
switch (json.ValueType)
{
case JsonValueType.Array:
RenderArray(json.GetArray(), indent);
break;
case JsonValueType.Object:
RenderObject(json.GetObject(), indent);
break;
case JsonValueType.Null:
AddInlines(new Run()
{
Text = "null", FontStyle = Windows.UI.Text.FontStyle.Italic, Foreground = BooleanBrush
});
break;
case JsonValueType.Number:
AddInlines(new Run()
{
Text = json.GetNumber().ToString(), Foreground = NumberBrush
});
break;
case JsonValueType.String:
AddInlines(new Run()
{
Text = "\"" + json.GetString() + "\"", Foreground = StringBrush
});
break;
case JsonValueType.Boolean:
AddInlines(new Run()
{
Text = json.GetBoolean().ToString(), Foreground = BooleanBrush
});
break;
}
}
public static string GetValueString(this IJsonValue value)
{
StringBuilder builder;
switch (value.ValueType)
{
case JsonValueType.String:
return(value.GetString());
case JsonValueType.Boolean:
return(value.GetBoolean().ToString());
case JsonValueType.Number:
return(value.GetNumber().ToString());
case JsonValueType.Array:
builder = new StringBuilder();
foreach (IJsonValue item in value.GetArray())
{
builder.AppendLine(GetValueString(item));
}
return(builder.ToString());
case JsonValueType.Object:
builder = new StringBuilder();
foreach (IJsonValue item in value.GetObject().Values)
{
builder.AppendLine(GetValueString(item));
}
return(builder.ToString());
case JsonValueType.Null:
default:
return(null);
}
}
public static float GetFloat(this IJsonValue data)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
if (data.ValueType == JsonValueType.String)
{
float retVal;
if (!float.TryParse(data.GetString(), out retVal))
{
throw new Exception("JsonObject is type string but cannot be parsed to float");
}
return(retVal);
}
else if (data.ValueType == JsonValueType.Number)
{
return((float)data.GetNumber());
}
else
{
throw new Exception(string.Format("JsonObject is type {0}", data.ValueType.ToString()));
}
}
private static bool JsonComparesEqual(IJsonValue expected, IJsonValue actual, string keyName)
{
const string Anything = "<ANYTHING>";
if (expected.ValueType == JsonValueType.String && Regex.Replace(expected.GetString(), @"\p{C}", "") == Anything)
{
Debug.WriteLine($"Skipping ignored value: {actual.ValueType} {actual}");
return(true);
}
//Debug.WriteLine($"keyname: {keyName} {expected.ValueType} {actual.ValueType}");
if (expected.ValueType != actual.ValueType)
{
Debug.WriteLine($"Expected {expected} got {actual}");
return(false);
}
switch (expected.ValueType)
{
case JsonValueType.String:
if (expected.GetString() != actual.GetString())
{
Debug.WriteLine($"string:Expected {expected.GetString()} got {actual.GetString()}");
return(false);
}
return(true);
case JsonValueType.Number:
if (Math.Abs(expected.GetNumber() - actual.GetNumber()) > epsilon)
{
Debug.WriteLine($"number: {keyName} {expected.GetNumber()} {actual.GetNumber()}");
return(false);
}
return(true);
case JsonValueType.Boolean:
return(expected.GetBoolean() == actual.GetBoolean());
case JsonValueType.Null:
return(true);
case JsonValueType.Array:
{
var ea = expected.GetArray();
var aa = actual.GetArray();
if (!JsonCompareArray(ea, aa))
{
Debug.WriteLine("in key " + keyName);
return(false);
}
return(true);
}
case JsonValueType.Object:
{
if (!JsonCompareObject(expected.GetObject(), actual.GetObject()))
{
Debug.WriteLine("in key " + keyName);
return(false);
}
return(true);
}
default:
throw new ArgumentException();
}
}
public static object ToObject(this IJsonValue value, Type targetType)
{
if (value.GetType() == targetType)
{
return(value);
}
if (value.ValueType == JsonValueType.Null)
{
return(null);
}
if (targetType == typeof(JsonObject))
{
return(JsonObject.Parse(value.Stringify()));
}
if (typeof(IJsonValue).IsAssignableFrom(targetType))
{
return(value);
}
if (targetType == typeof(string))
{
return(value.GetString());
}
if (targetType == typeof(int) || targetType == typeof(int?))
{
return((int)value.GetNumber());
}
if (targetType == typeof(long) || targetType == typeof(long?))
{
return((long)value.GetNumber());
}
if (targetType == typeof(bool) || targetType == typeof(bool?))
{
return(value.GetBoolean());
}
if (targetType == typeof(float) || targetType == typeof(float?))
{
return((float)value.GetNumber());
}
if (targetType == typeof(double) || targetType == typeof(double?))
{
return(value.GetNumber());
}
if (targetType == typeof(decimal) || targetType == typeof(decimal?))
{
return((decimal)value.GetNumber());
}
if (targetType == typeof(DateTime) || targetType == typeof(DateTime?))
{
return(DateTime.Parse(value.GetString()));
}
if (targetType == typeof(TimeSpan) || targetType == typeof(TimeSpan?))
{
return(TimeSpan.Parse(value.GetString()));
}
throw new NotSupportedException($"Type {targetType} is not supported.");
}
private void RenderValue(IJsonValue json, double indent)
{
switch (json.ValueType)
{
case JsonValueType.Array:
RenderArray(json.GetArray(), indent);
break;
case JsonValueType.Object:
RenderObject(json.GetObject(), indent);
break;
case JsonValueType.Null:
AddInlines(new Run() { Text = "null", FontStyle = Windows.UI.Text.FontStyle.Italic, Foreground = BooleanBrush });
break;
case JsonValueType.Number:
AddInlines(new Run() { Text = json.GetNumber().ToString(), Foreground = NumberBrush });
break;
case JsonValueType.String:
AddInlines(new Run() { Text = "\"" + json.GetString() + "\"", Foreground = StringBrush });
break;
case JsonValueType.Boolean:
AddInlines(new Run() { Text = json.GetBoolean().ToString(), Foreground = BooleanBrush });
break;
}
}
public override BasicRoute ParseResult(string response)
{
// Parse the Result (it is JSON)
JsonObject jsonObject = JsonObject.Parse(response);
// Create a new Route
BasicRoute Route = new BasicRoute();
IJsonValue nameJsonValue = jsonObject.GetNamedValue(nameKey);
if (nameJsonValue.ValueType == JsonValueType.Null)
{
Route.Name = "New Route"; // TODO: Give it a name!
}
else
{
Route.Name = nameJsonValue.GetString();
}
IJsonValue distanceJsonValue = jsonObject.GetNamedValue(distanceKey);
if (distanceJsonValue.ValueType == JsonValueType.Null)
{
Route.Distance = null; // TODO: If there is no distance, calculate it ourselves!
}
else
{
Route.Distance = distanceJsonValue.GetNumber();
}
IJsonValue upHillJsonValue = jsonObject.GetNamedValue(uphillKey);
if (upHillJsonValue.ValueType == JsonValueType.Null)
{
Route.Uphill = null; // Null means no info in this case
}
else
{
Route.Uphill = upHillJsonValue.GetNumber();
}
IJsonValue downHillJsonValue = jsonObject.GetNamedValue(downhillKey);
if (downHillJsonValue.ValueType == JsonValueType.Null)
{
Route.Downhill = null; // Null means no info in this case
}
else
{
Route.Downhill = downHillJsonValue.GetNumber();
}
JsonObject startPointJsonObject = jsonObject.GetNamedObject(startPointKey);
Route.StartPoint = new BasicLocation()
{
Location = new Geopoint(new BasicGeoposition()
{
Latitude = startPointJsonObject.GetNamedNumber("lat", Waypoints.ElementAt(0).Location.Position.Latitude), // Just use the info we already have if there is none
Longitude = startPointJsonObject.GetNamedNumber("lng", Waypoints.ElementAt(0).Location.Position.Longitude),
Altitude = startPointJsonObject.GetNamedNumber("alt", Waypoints.ElementAt(0).Location.Position.Altitude)
})
};
List <BasicGeoposition> Track = new List <BasicGeoposition>();
foreach (IJsonValue jsonValue in jsonObject.GetNamedArray(trackKey, new JsonArray()))
{
if (jsonValue.ValueType == JsonValueType.Object)
{
JsonObject jsonValueAsObject = jsonValue.GetObject();
Track.Add(new BasicGeoposition()
{
Latitude = jsonValueAsObject.GetNamedNumber("lat"),
Longitude = jsonValueAsObject.GetNamedNumber("lng"),
Altitude = jsonValueAsObject.GetNamedNumber("alt")
});
}
}
Route.Track = Track;
return(Route);
}
public static double?AsNumber(this IJsonValue value)
{
return((value != null && value.ValueType == JsonValueType.Number) ?
(double?)value.GetNumber() :
null);
}
private void WriteJsonValue(JsonWriter writer, IJsonValue value)
{
switch (value.ValueType)
{
case JsonValueType.Array:
{
JsonArray a = value.GetArray();
writer.WriteStartArray();
for (int i = 0; i < a.Count; i++)
{
WriteJsonValue(writer, a[i]);
}
writer.WriteEndArray();
}
break;
case JsonValueType.Boolean:
{
writer.WriteValue(value.GetBoolean());
}
break;
case JsonValueType.Null:
{
writer.WriteNull();
}
break;
case JsonValueType.Number:
{
// JsonValue doesn't support integers
// serialize whole numbers without a decimal point
double d = value.GetNumber();
bool isInteger = (d % 1 == 0);
if (isInteger && d <= long.MaxValue && d >= long.MinValue)
{
writer.WriteValue(Convert.ToInt64(d));
}
else
{
writer.WriteValue(d);
}
}
break;
case JsonValueType.Object:
{
JsonObject o = value.GetObject();
writer.WriteStartObject();
foreach (KeyValuePair <string, IJsonValue> v in o)
{
writer.WritePropertyName(v.Key);
WriteJsonValue(writer, v.Value);
}
writer.WriteEndObject();
}
break;
case JsonValueType.String:
{
writer.WriteValue(value.GetString());
}
break;
default:
throw new ArgumentOutOfRangeException("ValueType");
}
}
dynamic Convert(IJsonValue json)
{
dynamic obj = null;
switch (json.ValueType)
{
case JsonValueType.Array:
obj = ConvertArray(json.GetArray());
break;
case JsonValueType.Boolean:
obj = json.GetBoolean();
break;
case JsonValueType.Null:
obj = null;
break;
case JsonValueType.Number:
obj = json.GetNumber();
break;
case JsonValueType.Object:
obj = new JsonToDynamic(json.GetObject());
break;
case JsonValueType.String:
obj = json.GetString();
break;
}
return obj;
}
private bool JsonComparesEqual(IJsonValue expected, IJsonValue actual)
{
if (expected.ValueType != actual.ValueType)
{
return(false);
}
switch (expected.ValueType)
{
case JsonValueType.String:
if (expected.GetString() == actual.GetString())
{
return(true);
}
else
{
Debug.WriteLine($"Expected {expected.GetString()} got {actual.GetString()}"); return(false);
}
case JsonValueType.Number:
return(expected.GetNumber() == actual.GetNumber());
case JsonValueType.Boolean:
return(expected.GetBoolean() == actual.GetBoolean());
case JsonValueType.Null:
return(true);
case JsonValueType.Array:
{
var ea = expected.GetArray();
var aa = actual.GetArray();
if (ea.Count != aa.Count)
{
return(false);
}
for (uint i = 0; i < ea.Count; i++)
{
if (!JsonComparesEqual(ea[(int)i], aa[(int)i]))
{
return(false);
}
}
return(true);
}
case JsonValueType.Object:
{
var eo = expected.GetObject();
var ao = actual.GetObject();
if (eo.Keys.Count != ao.Keys.Count)
{
return(false);
}
foreach (var key in eo.Keys)
{
if (!JsonComparesEqual(eo.GetNamedValue(key), ao.GetNamedValue(key)))
{
return(false);
}
}
return(true);
}
default:
throw new ArgumentException();
}
}
private Score getScoreFromJson(string jsonString)
{
JsonObject jsonObject = new JsonObject();
Score score = new Score();
if (JsonObject.TryParse(jsonString, out jsonObject))
{
var by = jsonObject.GetNamedObject("by");
IJsonValue value = null;
try
{
score.Id = (jsonObject.TryGetValue("id", out value)) ? (int.Parse(value.GetNumber().ToString())) : (0);
score.Title = (jsonObject.TryGetValue("title", out value)) ? (value.GetString()) : ("");
score.LocationProject = (jsonObject.TryGetValue("location_project", out value)) ? ((value.ValueType != JsonValueType.Null) ? (value.GetString()) : ("")) : ("");
score.LocationPreview = (jsonObject.TryGetValue("location_preview", out value)) ? ((value.ValueType != JsonValueType.Null) ? (value.GetString()) : ("")) : ("");
score.Is_Favourite = (jsonObject.TryGetValue("is_favourite", out value)) ? (value.GetBoolean()) : (false);
score.Compositor.PersonalData.Id = (by.TryGetValue("id", out value)) ? (int.Parse(value.GetString())) : (0);
score.Compositor.PersonalData.Username = (by.TryGetValue("username", out value)) ? (value.GetString()) : ("");
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e.Message);
throw;
}
}
return(score);
}
private static int ParseAsInt(IJsonValue jsonValue, int defaultValue = -1)
{
if (jsonValue.ValueType == JsonValueType.Number)
{
return (int)jsonValue.GetNumber();
}
else if (jsonValue.ValueType == JsonValueType.String)
{
int rv;
if (!int.TryParse(jsonValue.GetString(), out rv))
return defaultValue;
return rv;
}
else
{
return defaultValue;
}
}
static public object Convert(ITypeDefinition type, IJsonValue val)
{
try
{
switch (type.Type)
{
case TypeId.Boolean:
return(val.GetBoolean());
case TypeId.Double:
return(val.GetNumber());
case TypeId.Dictionary:
return(val.GetArray()
.ToList()
.Select(x =>
new KeyValuePair <object, object>(
Convert(type.KeyType, x.GetArray()[0]),
Convert(type.ValueType, x.GetArray()[1])
)
));
case TypeId.Signature:
return(val.GetString());
case TypeId.Int32:
return((Int32)val.GetNumber());
case TypeId.Int16:
return((Int16)val.GetNumber());
case TypeId.ObjectPath:
return(val.GetString());
case TypeId.Uint16:
return((UInt16)val.GetNumber());
case TypeId.Struct:
return(ConvertStruct(type, val));
case TypeId.String:
return(val.GetString());
case TypeId.Uint64:
return((UInt64)val.GetNumber());
case TypeId.Uint32:
return((UInt32)val.GetNumber());
case TypeId.Variant:
return(ConvertVariant(val));
case TypeId.Int64:
return((Int64)val.GetNumber());
case TypeId.Uint8:
return((byte)val.GetNumber());
case TypeId.BooleanArray:
return(val.GetArray().Select(x => x.GetBoolean()).Cast <object>().ToList());
case TypeId.DoubleArray:
return(val.GetArray().Select(x => x.GetNumber()).Cast <object>().ToList());
case TypeId.Int32Array:
return(val.GetArray().Select(x => (Int32)x.GetNumber()).Cast <object>().ToList());
case TypeId.Int16Array:
return(val.GetArray().Select(x => (Int16)x.GetNumber()).Cast <object>().ToList());
case TypeId.Uint16Array:
return(val.GetArray().Select(x => (UInt16)x.GetNumber()).Cast <object>().ToList());
case TypeId.Uint64Array:
return(val.GetArray().Select(x => (UInt64)x.GetNumber()).Cast <object>().ToList());
case TypeId.Uint32Array:
return(val.GetArray().Select(x => (UInt32)x.GetNumber()).Cast <object>().ToList());
case TypeId.VariantArray:
return(val.GetArray().Select(ConvertVariant).Cast <object>().ToList());
case TypeId.Int64Array:
return(val.GetArray().Select(x => (Int64)x.GetNumber()).Cast <object>().ToList());
case TypeId.Uint8Array:
return(val.GetArray().Select(x => (byte)x.GetNumber()).Cast <object>().ToList());
case TypeId.SignatureArray:
return(val.GetArray().Select(x => x.GetString()).Cast <object>().ToList());
case TypeId.ObjectPathArray:
return(val.GetArray().Select(x => x.GetString()).Cast <object>().ToList());
case TypeId.StringArray:
return(val.GetArray().Select(x => x.GetString()).Cast <object>().ToList());
case TypeId.StructArray:
return(val.GetArray().Select(x => ConvertStruct(type, x)).Cast <object>().ToList());
}
}
catch (Exception) { };
throw Logger.LogException("AllJoyn cast", new InvalidCastException());
}
public static object ConvertObject(Type type, string data)
{
if (string.IsNullOrEmpty(data) ||
(!data.StartsWith("{") && !data.EndsWith("}")) ||
data.ToLower().Equals("null") ||
data.ToLower().Equals("[]") ||
data.ToLower().Equals("{}"))
{
return(null);
}
JsonObject jsonObject = JsonObject.Parse(data);
//if(!JsonObject.TryParse(data, out jsonObject))
//{
// return null;
//}
var result = Activator.CreateInstance(type);
var properties = type.GetProperties();
Dictionary <int, bool> checkedIndexs = new Dictionary <int, bool>();
int count = properties.Length;
foreach (var json in jsonObject)
{
// Debug.WriteLine($"{json.Key} : {json.Value.ToString()}");
if (count == 0)
{
break;
}
for (int i = 0; i < count; i++)
{
// Check Impelement checked
bool isChecked = false;
if (checkedIndexs.ContainsKey(i))
{
isChecked = checkedIndexs[i];
}
if (isChecked)
{
continue;
}
// Check Property Sign
var property = properties.GetValue(i) as PropertyInfo;
var sign = property.GetCustomAttribute <SignAttribute>();
if (sign == null)
{
continue;
}
if (json.Key.Equals(sign.Name))
{
if (property != null)
{
var propertyType = property.PropertyType;
var typeInfo = propertyType.GetTypeInfo();
IJsonValue jsonValue = json.Value;
//Debug.Write(jsonValue.ValueType);
if (typeInfo.IsValueType)
{
if (propertyType.IsTypeOf <int>())
{
if (jsonValue.ValueType == JsonValueType.Null)
{
property.SetValue(result,
Convert.ChangeType(0, propertyType));
}
else if (jsonValue.ValueType == JsonValueType.Number)
{
property.SetValue(result,
Convert.ChangeType(jsonValue.GetNumber(), propertyType));
}
else
{
int number;
property.SetValue(result,
int.TryParse(jsonValue.GetString(), out number)
? Convert.ChangeType(number, propertyType)
: Convert.ChangeType(0, propertyType));
}
}
else if (propertyType.IsTypeOf <bool>())
{
if (jsonValue.ValueType == JsonValueType.Null)
{
property.SetValue(result,
Convert.ChangeType(false, propertyType));
}
else if (jsonValue.ValueType == JsonValueType.Boolean)
{
property.SetValue(result, Convert.ChangeType(jsonValue.GetBoolean(), propertyType));
}
else
{
bool boolean;
property.SetValue(result,
bool.TryParse(jsonValue.GetString(), out boolean)
? Convert.ChangeType(boolean, propertyType)
: Convert.ChangeType(0, propertyType));
}
}
else if (propertyType.IsTypeOf <long>())
{
if (jsonValue.ValueType == JsonValueType.Null)
{
property.SetValue(result,
Convert.ChangeType(0, propertyType));
}
else if (jsonValue.ValueType == JsonValueType.String || jsonValue.ValueType == JsonValueType.Object)
{
long number;
property.SetValue(result,
long.TryParse(jsonValue.GetString(), out number)
? Convert.ChangeType(number, propertyType)
: Convert.ChangeType(0, propertyType));
}
else
{
property.SetValue(result, Convert.ChangeType(jsonValue.GetNumber(), propertyType));
}
}
else if (propertyType.IsTypeOf <double>())
{
if (jsonValue.ValueType == JsonValueType.Null)
{
property.SetValue(result,
Convert.ChangeType(0, propertyType));
}
else if (jsonValue.ValueType == JsonValueType.String || jsonValue.ValueType == JsonValueType.Object)
{
double number;
property.SetValue(result,
double.TryParse(jsonValue.GetString(), out number)
? Convert.ChangeType(number, propertyType)
: Convert.ChangeType(0, propertyType));
}
else
{
property.SetValue(result, Convert.ChangeType(jsonValue.GetNumber(), propertyType));
}
}
else if (propertyType.IsTypeOf <byte>())
{
if (jsonValue.ValueType == JsonValueType.Null)
{
property.SetValue(result,
Convert.ChangeType(0, propertyType));
}
else if (jsonValue.ValueType == JsonValueType.String || jsonValue.ValueType == JsonValueType.Object)
{
byte number;
property.SetValue(result,
byte.TryParse(jsonValue.GetString(), out number)
? Convert.ChangeType(number, propertyType)
: Convert.ChangeType(0, propertyType));
}
}
}
else if (propertyType.IsTypeOf <string>() && jsonValue.ValueType == JsonValueType.String)
{
if (jsonValue.ValueType == JsonValueType.Null)
{
property.SetValue(result,
Convert.ChangeType(String.Empty, propertyType));
}
else if (jsonValue.ValueType == JsonValueType.String)
{
property.SetValue(result, Convert.ChangeType(jsonValue.GetString(), propertyType));
}
else if (jsonValue.ValueType == JsonValueType.Number)
{
property.SetValue(result, Convert.ChangeType(jsonValue.GetNumber().ToString(), propertyType));
}
else if (jsonValue.ValueType == JsonValueType.Boolean)
{
property.SetValue(result, Convert.ChangeType(jsonValue.GetBoolean().ToString(), propertyType));
}
else if (jsonValue.ValueType == JsonValueType.Object)
{
property.SetValue(result, Convert.ChangeType(jsonValue.GetObject().ToString(), propertyType));
}
}
else if (typeInfo.IsClass)
{
// generic
if (typeInfo.IsGenericType)
{
var types = typeInfo.ImplementedInterfaces;
var collection = types.FirstOrDefault(p => p.FullName.Contains("Generic") || p.FullName.Contains("IList") || p.FullName.Contains("Collection") || p.FullName.Contains("IEnumerable"));
if (collection != null) // Generic Collection
{
var itemType = propertyType.GetGenericArguments().FirstOrDefault();
string arrayData = json.Value != null?json.Value.ToString() : string.Empty;
if (!string.IsNullOrEmpty(arrayData))
{
var items = (IList)Activator.CreateInstance(propertyType);
var jsonArray = JsonArray.Parse(arrayData);
// List<object> data = new List<Object>();
foreach (var _jsonValue in jsonArray)
{
var item = ConvertObject(itemType, _jsonValue.ToString());
items.Add(item);
// data.Add(item);
}
property.SetValue(result, Convert.ChangeType(items, propertyType));
}
}
else // Generic class
{
property.SetValue(result, Convert.ChangeType(ConvertObject(propertyType, json.Value.ToString()), propertyType));
}
}
else // reference class
{
//property.SetValue(result, Convert.ChangeType(jsonValue.GetString(), propertyType));
property.SetValue(result, Convert.ChangeType(ConvertObject(propertyType, json.Value.ToString()), propertyType));
}
}
}
checkedIndexs[i] = true;
break;
}
}
}
return(result);
}
/// <summary>
/// Convert a JSON value into an int, returning null if it's unable.
/// </summary>
/// <param name="value">The value to convert.</param>
/// <returns>An int or null.</returns>
public static int?AsInteger(this IJsonValue value)
{
return((value != null && value.ValueType == JsonValueType.Number) ?
(int?)value.GetNumber() :
null);
}
