E1.37-5 JSON Metadata Defines / Schema for Manufacturer PIDs

RDMSharp/Metadata/DataTree.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace RDMSharp.Metadata
+{
+    public readonly struct DataTree : IEquatable<DataTree>
+    {
+        public readonly string Name;
+        public readonly uint Index;
+        public readonly object? Value;
+        public readonly string? Unit;
+        public readonly DataTreeValueLabel[]? Labels;
+        public readonly DataTree[]? Children;
+        public readonly DataTreeIssue[]? Issues;
+
+        private DataTree(string name, uint index, DataTreeIssue[]? issues = null)
+        {
+            Name = name;
+            Index = index;
+            Issues = issues;
+        }
+        public DataTree(DataTree dataTree, uint index) : this(dataTree.Name, index, dataTree.Issues)
+        {
+            Value = dataTree.Value;
+            Unit = dataTree.Unit;
+            Labels = dataTree.Labels;
+            Children = dataTree.Children;
+        }
+        public DataTree(string name, uint index, object value, DataTreeIssue[]? issues = null, string unit = null, DataTreeValueLabel[] labels = null) : this(name, index, issues)
+        {
+            if (value is IEnumerable<DataTree> || value is DataTree[] children)
+                throw new ArgumentException($"Use other Constructor if you use {nameof(Children)}");
+
+            Value = value;
+            Unit = unit;
+            Labels = labels;
+        }
+
+        public DataTree(string name, uint index, DataTree[] children, DataTreeIssue[]? issues = null) : this(name, index, issues)
+        {
+            Children = children;
+        }
+
+        public override string ToString()
+        {
+            return $"[{Index}] {Name}: {Value}";
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is DataTree tree && Equals(tree);
+        }
+
+        public bool Equals(DataTree other)
+        {
+            return Name == other.Name &&
+                   Index == other.Index &&
+                   EqualityComparer<object>.Default.Equals(Value, other.Value) &&
+                   compairArrays(this, other);
+
+            bool compairArrays(DataTree _this, DataTree other)
+            {
+                if (_this.Children != null)
+                {
+                    if (!_this.Children.SequenceEqual(other.Children))
+                        return false;
+                }
+                else if (other.Children != null)
+                    return false;
+                if (_this.Issues != null)
+                {
+                    if (!_this.Issues.SequenceEqual(other.Issues))
+                        return false;
+                }
+                else if (other.Issues != null)
+                    return false;
+
+                return true;
+            }
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(Name, Index, Value, Children, Issues);
+        }
+
+        public static bool operator ==(DataTree left, DataTree right)
+        {
+            return left.Equals(right);
+        }
+
+        public static bool operator !=(DataTree left, DataTree right)
+        {
+            return !(left == right);
+        }
+    }
+}

RDMSharp/Metadata/DataTreeIssue.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace RDMSharp.Metadata
+{
+    public readonly struct DataTreeIssue
+    {
+        public readonly string Description;
+
+        public DataTreeIssue(string description)
+        {
+            if (string.IsNullOrWhiteSpace(description))
+                throw new ArgumentNullException($"{nameof(description)} has to be a vaild String");
+            Description = description;
+        }
+        public override string ToString()
+        {
+            return Description;
+        }
+    }
+}

RDMSharp/Metadata/DataTreeValueLabel.cs

@@ -0,0 +1,14 @@
+namespace RDMSharp.Metadata
+{
+    public readonly struct DataTreeValueLabel
+    {
+        public readonly object Value;
+        public readonly string Label;
+
+        public DataTreeValueLabel(object value, string label)
+        {
+            Value = value;
+            Label = label;
+        }
+    }
+}

RDMSharp/Metadata/DefineNotFoundException.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace RDMSharp.Metadata
+{
+    public class DefineNotFoundException : Exception
+    {
+        public DefineNotFoundException()
+        {
+        }
+
+        public DefineNotFoundException(string message) : base(message)
+        {
+        }
+    }
+}

RDMSharp/Metadata/JSON/Command.cs

@@ -0,0 +1,78 @@
+using System.Linq;
+using System.Text.Json.Serialization;
+using RDMSharp.Metadata.JSON.Converter;
+using RDMSharp.RDM;
+using OneOf = RDMSharp.Metadata.JSON.OneOfTypes.OneOfTypes;
+
+namespace RDMSharp.Metadata.JSON
+{
+    [JsonConverter(typeof(CommandConverter))]
+    public readonly struct Command
+    {
+        [JsonConverter(typeof(CustomEnumConverter<ECommandDublicte>))]
+        public enum ECommandDublicte
+        {
+            [JsonPropertyName("get_request")]
+            GetRequest,
+            [JsonPropertyName("get_response")]
+            GetResponse,
+            [JsonPropertyName("set_request")]
+            SetRequest,
+            [JsonPropertyName("set_response")]
+            SetResponse,
+            [JsonPropertyName("different_pid")]
+            DifferentDid
+        }
+        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+        public readonly ECommandDublicte? EnumValue { get; }
+        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+        public readonly OneOf? SingleField { get; }
+        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+        public readonly OneOf[]? ListOfFields { get; }
+
+        public bool GetIsEmpty()
+        {
+            if (EnumValue != null)
+                return false;
+            if (SingleField != null)
+                return false;
+            if (ListOfFields != null)
+                return ListOfFields.Length == 0;
+
+            return true;
+        }
+        public Command(ECommandDublicte enumValue)
+        {
+            EnumValue = enumValue;
+        }
+        public Command(OneOf singleField)
+        {
+            SingleField = singleField;
+        }
+        public Command(OneOf[] listOfFields)
+        {
+            ListOfFields = listOfFields;
+        }
+        public PDL GetDataLength()
+        {
+            if(GetIsEmpty())
+                return new PDL();
+            if (SingleField.HasValue)
+                return SingleField.Value.GetDataLength();
+            if (ListOfFields != null)
+                return new PDL(ListOfFields.Select(f => f.GetDataLength()).ToArray());
+
+            throw new System.NotSupportedException();
+        }
+        public override string ToString()
+        {
+            if (EnumValue.HasValue)
+                return EnumValue.Value.ToString();
+            if (SingleField.HasValue)
+                return SingleField.Value.ToString();
+            if (ListOfFields != null)
+                return $"[ {string.Join("; ", ListOfFields.Select(f => f.ToString()))} ]";
+            return base.ToString();
+        }
+    }
+}

RDMSharp/Metadata/JSON/CommonPropertiesForNamed.cs

@@ -0,0 +1,34 @@
+using RDMSharp.RDM;
+using System.Text.Json.Serialization;
+
+namespace RDMSharp.Metadata.JSON
+{
+    public abstract class CommonPropertiesForNamed
+    {
+        [JsonPropertyName("name")]
+        [JsonIgnore(Condition = JsonIgnoreCondition.Never)]
+        public abstract string Name { get; }
+        [JsonPropertyName("displayName")]
+        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+        public abstract string DisplayName { get; }
+        [JsonPropertyName("notes")]
+        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+        public abstract string? Notes { get; }
+        [JsonPropertyName("resources")]
+        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
+        public abstract string[]? Resources { get; }
+
+        public abstract PDL GetDataLength();
+
+        public abstract byte[] ParsePayloadToData(DataTree dataTree);
+        public abstract DataTree ParseDataToPayload(ref byte[] data);
+
+        public override string ToString()
+        {
+            if(!string.IsNullOrWhiteSpace(DisplayName))
+                return DisplayName;
+
+            return Name;
+        }
+    }
+}

RDMSharp/Metadata/JSON/Converter/CommandConverter.cs

@@ -0,0 +1,45 @@
+using System.Text.Json;
+using System;
+using System.Text.Json.Serialization;
+using OneOf = RDMSharp.Metadata.JSON.OneOfTypes.OneOfTypes;
+
+namespace RDMSharp.Metadata.JSON.Converter
+{
+    public class CommandConverter : JsonConverter<Command>
+    {
+        public override Command Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            if (reader.TokenType == JsonTokenType.String)
+            {
+                var enumValue = JsonSerializer.Deserialize<Command.ECommandDublicte>(ref reader, options);
+                return new Command(enumValue);
+            }
+            else if (reader.TokenType == JsonTokenType.StartObject)
+            {
+                var singleField = JsonSerializer.Deserialize<OneOf>(ref reader, options);
+                return new Command(singleField);
+            }
+            else if (reader.TokenType == JsonTokenType.StartArray)
+            {
+                var listOfFields = JsonSerializer.Deserialize<OneOf[]>(ref reader, options);
+                if (listOfFields.Length == 0)
+                    return new Command();
+                return new Command(listOfFields);
+            }
+
+            throw new JsonException("Unexpected JSON format for FieldContainer.");
+        }
+
+        public override void Write(Utf8JsonWriter writer, Command value, JsonSerializerOptions options)
+        {
+            if (value.GetIsEmpty())
+                JsonSerializer.Serialize(writer, new object[0], options);
+            else if (value.EnumValue.HasValue)
+                JsonSerializer.Serialize(writer, value.EnumValue.Value, options);
+            else if (value.SingleField != null)
+                JsonSerializer.Serialize(writer, value.SingleField.Value, options);
+            else if (value.ListOfFields != null)
+                JsonSerializer.Serialize(writer, value.ListOfFields, options);
+        }
+    }
+}

RDMSharp/Metadata/JSON/Converter/CustomEnumConverter.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Reflection;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace RDMSharp.Metadata.JSON.Converter
+{
+    public class CustomEnumConverter<T> : JsonConverter<T> where T : struct, Enum
+    {
+        public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            string enumValue = reader.GetString();
+
+            foreach (var field in typeof(T).GetFields())
+            {
+                if (field.GetCustomAttribute<JsonPropertyNameAttribute>()?.Name == enumValue)
+                {
+                    return (T)field.GetValue(null);
+                }
+            }
+
+            throw new JsonException($"Unknown enum value: {enumValue}");
+        }
+
+        public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
+        {
+            var field = typeof(T).GetField(value.ToString());
+
+            var attribute = field.GetCustomAttribute<JsonPropertyNameAttribute>();
+            string enumString = attribute.Name;
+
+            writer.WriteStringValue(enumString);
+        }
+    }
+
+}