public void Validate(JsonElement json)
{
int i = 0;
foreach (var item in json.EnumerateArray())
{
m_context.Push(i++);
new gltf__extensions__VRM__materialProperties_ITEM__Validator(m_context).Validate(item);
m_context.Pop();
}
}
public void Validate(JsonElement json)
{
int i = 0;
foreach (var item in json.EnumerateArray())
{
m_context.Push(i++);
new gltf__extensions__EXT_lights_image_based__lights_ITEM__specularImages_ITEM__Validator(m_context).Validate(item);
m_context.Pop();
}
}
public void Validate(JsonElement json)
{
int i = 0;
foreach (var item in json.EnumerateArray())
{
m_context.Push(i++);
new gltf__extensions__VRM__blendShapeMaster__blendShapeGroups_ITEM__binds_ITEM__Validator(m_context).Validate(item);
m_context.Pop();
}
}
public void Validate(JsonElement json)
{
int i = 0;
foreach (var item in json.EnumerateArray())
{
m_context.Push(i++);
new gltf__extensions__VRM__secondaryAnimation__boneGroups_ITEM__Validator(m_context).Validate(item);
m_context.Pop();
}
}
public void Validate(JsonElement json)
{
int i = 0;
foreach (var item in json.EnumerateArray())
{
m_context.Push(i++);
new gltf__textures_ITEM__Validator(m_context).Validate(item);
m_context.Pop();
}
}
public static List <object?> ReadList(JsonElement element)
{
var list = new List <object?>();
foreach (var item in element.EnumerateArray())
{
list.Add(ReadValue(element));
}
return(list);
}
private void PreprocessJArray(JsonElement array, Utf8JsonWriter writer)
{
writer.WriteStartArray();
foreach (var item in array.EnumerateArray())
{
PreprocessJsonElement(item, writer);
}
writer.WriteEndArray();
}
private static IOpenApiAny CreateOpenApiArray(JsonElement jsonElement)
{
var openApiArray = new OpenApiArray();
foreach (var item in jsonElement.EnumerateArray())
{
openApiArray.Add(CreateFromJsonElement(item));
}
return(openApiArray);
}
public static IList <object?> ReadList(JsonElement jsonElement)
{
IList <object?> list = new List <object?>();
foreach (var item in jsonElement.EnumerateArray())
{
list.Add(ReadValue(item));
}
return(list.Count == 0 ? null : list);
}
public void Validate(JsonElement json)
{
int i = 0;
foreach (var item in json.EnumerateArray())
{
m_context.Push(i++);
m_context.Pop();
}
}
public List <object> Parse(JsonElement payload)
{
var jsonlocationlist = payload.EnumerateArray().FirstOrDefault().GetProperty("SystemInfo");
var list = JsonSerializer.Deserialize <IEnumerable <SystemInfo> >(jsonlocationlist.GetRawText()).ToList();
var sysinfo = list.First();
sysinfo.Version = JsonSerializer.Deserialize <IEnumerable <Dictionary <string, string> > >(sysinfo.SWversions.GetRawText()).SelectMany(d => d).ToList();
return(list.ToList <object>());
}
private static int SumNumbers(JsonElement element)
{
// Recursively sums numbers in a Json subtree
if (element.ValueKind == JsonValueKind.Number)
{
System.Console.WriteLine("Parse number-leaf, probably shouldn't happen");
return(element.GetInt32());
}
else if (element.ValueKind == JsonValueKind.Array)
{
int sum = 0;
foreach (JsonElement child in element.EnumerateArray())
{
if (child.ValueKind == JsonValueKind.Object || child.ValueKind == JsonValueKind.Array)
{
sum += SumNumbers(child);
}
else if (child.ValueKind == JsonValueKind.Number)
{
sum += child.GetInt32();
}
}
return(sum);
}
else if (element.ValueKind == JsonValueKind.Object)
{
int sum = 0;
foreach (JsonProperty property in element.EnumerateObject())
{
JsonElement child = property.Value;
if (child.ValueKind == JsonValueKind.String)
{
if (child.GetString() == "red")
{
return(0); // Ignore object and children
}
}
else if (child.ValueKind == JsonValueKind.Object || child.ValueKind == JsonValueKind.Array)
{
// Subtree: recurse
sum += SumNumbers(child);
}
else if (child.ValueKind == JsonValueKind.Number)
{
sum += child.GetInt32();
}
}
return(sum);
}
// No subtree or number found:
System.Console.WriteLine("Called on a non-number leaf");
return(0);
}
private string ParseJsonPropertyNames(JsonElement root)
{
var result = new StringBuilder();
var firstElement = root.EnumerateArray().First();
foreach (var property in firstElement.EnumerateObject())
{
result.Append($"{property.Name}, ");
}
return(result.ToString().TrimEnd(',', ' '));
}
public static IEnumerable <object> Intersect(this JsonElement self, JsonElement target)
{
if (self.ValueKind == JsonValueKind.Array)
{
self.EnumerateArray().Intersect(target.EnumerateArray(), new JsonElementEqualityComparer());
}
else if (self.ValueKind == JsonValueKind.Object)
{
self.EnumerateObject().Intersect(target.EnumerateObject(), new JsonPropertyEqualityComparer());
}
return(null);
}
private static JsonElement GetFirstElement(JsonElement root)
{
var firstElement = root;
if (root.ValueKind == JsonValueKind.Array && root.GetArrayLength() > 0)
{
var enumerated = root.EnumerateArray();
firstElement = enumerated.FirstOrDefault();
}
return(firstElement);
}
private static string[] ReadStringArray(JsonElement value)
{
var values = new string[value.GetArrayLength()];
var i = 0;
foreach (var item in value.EnumerateArray())
{
values[i++] = item.GetString() !;
}
return(values);
}
private static object Unwrap(JsonElement je)
{
return(je.ValueKind switch
{
JsonValueKind.String => je.ToString(),
JsonValueKind.Number => je.TryGetInt64(out var l) ? l : je.GetDouble(),
JsonValueKind.True => true,
JsonValueKind.False => false,
JsonValueKind.Array => je.EnumerateArray().Select(Unwrap).ToList(),
JsonValueKind.Object => je.EnumerateObject().ToDictionary(x => x.Name, x => Unwrap(x.Value)),
_ => null
});
private List <IPropertyStatus> ParseProperties(JsonElement parameters)
{
var list = new List <IPropertyStatus>();
foreach (var element in parameters.EnumerateArray())
{
var obj = element.EnumerateObject().First();
list.Add(new PropertyStatus(obj.Name, obj.Value.ToString()));
}
return(list);
}
private static object?ParseValue(JsonElement element)
{
switch (element.ValueKind)
{
case JsonValueKind.Object:
var dict = new Dictionary <string, object?>();
foreach (JsonProperty property in element.EnumerateObject())
{
dict[property.Name] = ParseValue(property.Value);
}
return(dict);
case JsonValueKind.Array:
var array = new object?[element.GetArrayLength()];
var i = 0;
foreach (JsonElement item in element.EnumerateArray())
{
array[i++] = ParseValue(item);
}
return(array);
case JsonValueKind.String:
return(element.GetString());
case JsonValueKind.Number:
if (element.TryGetInt32(out var intValue))
{
return(intValue);
}
if (element.TryGetDouble(out var floatValue))
{
return(floatValue);
}
return(null);
case JsonValueKind.True:
return(true);
case JsonValueKind.False:
return(false);
default:
return(null);
}
}
private static void Write(JsonElement je, Utf8JsonWriter writer)
{
switch (je.ValueKind)
{
case JsonValueKind.Object:
writer.WriteStartObject();
// !!! This is where we can order the properties.
foreach (JsonProperty x in je.EnumerateObject().OrderBy(prop => prop.Name))
{
writer.WritePropertyName(x.Name);
Write(x.Value, writer);
}
writer.WriteEndObject();
break;
// When normalizing... Original msapp arrays can be in any order...
case JsonValueKind.Array:
writer.WriteStartArray();
foreach (JsonElement x in je.EnumerateArray())
{
Write(x, writer);
}
writer.WriteEndArray();
break;
case JsonValueKind.Number:
writer.WriteNumberValue(je.GetDouble());
break;
case JsonValueKind.String:
// Escape the string
writer.WriteStringValue(je.GetString());
break;
case JsonValueKind.Null:
writer.WriteNullValue();
break;
case JsonValueKind.True:
writer.WriteBooleanValue(true);
break;
case JsonValueKind.False:
writer.WriteBooleanValue(false);
break;
default:
throw new NotImplementedException($"Kind: {je.ValueKind}");
}
}
private static INamesVariable ParseName(JsonElement json)
{
var names = new List <IName>();
foreach (var nameElement in json.EnumerateArray())
{
var hasGivenName = nameElement.TryGetProperty("given", out var givenName);
var hasFamilyName = nameElement.TryGetProperty("family", out var familyName);
if (hasGivenName || hasFamilyName)
{
var family = string.Empty;
var given = string.Empty;
string?suffix = null;
string?droppingParticles = null;
string?nonDroppingParticles = null;
if (hasFamilyName)
{
family = familyName.GetString();
}
if (hasGivenName)
{
given = givenName.GetString();
}
if (nameElement.TryGetProperty("suffix", out var suffixElement))
{
suffix = suffixElement.GetString();
}
if (nameElement.TryGetProperty("dropping-particle", out var droppingParticlesElement))
{
droppingParticles = droppingParticlesElement.GetString();
}
if (nameElement.TryGetProperty("non-dropping-particle", out var nonDropingParticlesElement))
{
nonDroppingParticles = nonDropingParticlesElement.GetString();
}
var name = new PersonalName(family, given, suffix, false, droppingParticles, nonDroppingParticles);
names.Add(name);
}
else if (nameElement.TryGetProperty("literal", out var literalName))
{
names.Add(new InstitutionalName(literalName.GetString()));
}
else
{
throw new Exception();
}
}
return(new NamesVariable(names));
}
Friendship HandleLookupResponse(string responseJson)
{
JsonElement lookupJson = JsonDocument.Parse(responseJson).RootElement;
var friendship = new Friendship
{
Relationships =
(from relationship in lookupJson.EnumerateArray()
select new Relationship(relationship))
.ToList()
};
return(friendship);
}
/// <summary>Converts a JSON array to a set.</summary>
/// <typeparam name="TValue">The type of values in the set.</typeparam>
/// <param name="json">The array element.</param>
/// <param name="resultSelector">A function that converts each item in the array to its destination type.</param>
/// <returns></returns>
internal static HashSet <TValue> GetSet <TValue>(
this JsonElement json,
Func <JsonElement, TValue> resultSelector
)
{
#if NET
var values = new HashSet <TValue>(json.GetArrayLength());
#else
var values = new HashSet <TValue>();
#endif
values.UnionWith(json.EnumerateArray().Select(resultSelector));
return(values);
}
public List <object> Parse(JsonElement payload)
{
var devicelist = new List <DevicePropertiesStatus>();
var jsondevicelist = payload.EnumerateArray().FirstOrDefault().GetProperty("Devices");
foreach (var device in jsondevicelist.EnumerateArray())
{
devicelist.Add(ParseDevice(device));
}
return(devicelist.ToList <object>());
}
public List <object> Parse(JsonElement payload)
{
var devicesid = payload.EnumerateArray().First().GetProperty("Devices").EnumerateArray();
var idlist = new List <string>();
foreach (var item in devicesid)
{
idlist.Add(item.GetProperty("Uuid").GetString());
}
return(idlist.ToList <object>());
}
public List<T> ConvertFromSPEntities<T>(object source, IEnumerable<ListItemPropertyCreationInfo> properties) where T: new()
{
var sourceJson = source as string;
JsonDocument jsonDocument = JsonDocument.Parse(sourceJson);
JsonElement jsonResults = jsonDocument.RootElement.GetProperty("d").GetProperty("results");
var jsonItems = jsonResults.EnumerateArray();
var result = jsonItems
.Select(i => CreateObject<T>(i, properties))
.ToList();
return result;
}
private void AssertArraysEqual(JsonElement result, params string[] expected)
{
Assert.Equal(JsonValueKind.Array, result.ValueKind);
string[] resultArray = result.EnumerateArray().Select(x => x.GetString()).ToArray();
Assert.Equal(expected.Length, resultArray.Length);
for (int i = 0; i < expected.Length; i++)
{
Assert.Equal(expected[i], resultArray[i]);
}
}
public static Inventory GetInventory(
this JsonElement json,
MissingMemberBehavior missingMemberBehavior
)
{
List <ItemSlot?> slots = new(json.GetArrayLength());
slots.AddRange(
json.EnumerateArray().Select(entry => entry.GetItemSlot(missingMemberBehavior))
);
return(new Inventory(slots));
}
public override void Import(JsonElement property, Action <string> logger)
{
Values.Clear();
foreach (var elem in property.EnumerateArray())
{
var item = _import(elem);
if (item.Failed)
{
continue;
}
Values.Add(item.Value);
}
}
private static TouchPoint[] ReadTouchPointArray(JsonElement jsonElement)
{
var touchPoints = new TouchPoint[jsonElement.GetArrayLength()];
var i = 0;
foreach (var item in jsonElement.EnumerateArray())
{
touchPoints[i++] = ReadTouchPoint(item);
}
return(touchPoints);
}