< Summary - pva.SuperV

Information
Class: pva.SuperV.Engine.JsonConverters.FieldDefinitionJsonConverter
Assembly: pva.SuperV.Engine
File(s): /home/runner/work/pva.SuperV/pva.SuperV/pva.SuperV.Engine/JsonConverters/FieldDefinitionJsonConverter.cs
Tag: dotnet-ubuntu_22190969454
Line coverage
96%
Covered lines: 60
Uncovered lines: 2
Coverable lines: 62
Total lines: 131
Line coverage: 96.7%
Branch coverage
91%
Covered branches: 22
Total branches: 24
Branch coverage: 91.6%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.cctor()100%11100%
Read(...)87.5%8892.85%
Write(...)100%1414100%
CreateInstance(...)100%11100%
GetConstructor(...)50%22100%

File(s)

/home/runner/work/pva.SuperV/pva.SuperV/pva.SuperV.Engine/JsonConverters/FieldDefinitionJsonConverter.cs

#LineLine coverage
 1using pva.SuperV.Engine.FieldFormatters;
 2using pva.SuperV.Engine.Processing;
 3using System.Reflection;
 4using System.Text.Json;
 5using System.Text.Json.Serialization;
 6
 7namespace pva.SuperV.Engine.JsonConverters
 8{
 9    /// <summary>
 10    /// Json converter for field definition
 11    /// </summary>
 12    /// <seealso cref="JsonConverter&lt;IFieldDefinition&gt;" />
 13    public class FieldDefinitionJsonConverter : JsonConverter<IFieldDefinition>
 14    {
 15        /// <summary>
 16        /// The field converters cache.
 17        /// </summary>
 218        private static readonly Dictionary<Type, dynamic> FieldConvertersCache = [];
 19
 20        /// <summary>
 21        /// Reads and converts the JSON to type.
 22        /// </summary>
 23        /// <param name="reader">The reader.</param>
 24        /// <param name="typeToConvert">The type to convert.</param>
 25        /// <param name="options">An object that specifies serialization options to use.</param>
 26        /// <returns>
 27        /// The converted value.
 28        /// </returns>
 29        /// <exception cref="JsonException"></exception>
 30        public override IFieldDefinition Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions optio
 3531        {
 3532            JsonHelpers.ReadTokenType(ref reader, JsonTokenType.StartObject, false);
 3533            string? fieldTypeString = JsonHelpers.GetStringPropertyFromUtfReader(ref reader, "Type");
 3534            Type? fieldType = Type.GetType(fieldTypeString!);
 3535            string? fieldName = JsonHelpers.GetStringPropertyFromUtfReader(ref reader, "Name");
 36
 3537            JsonHelpers.ReadTokenType(ref reader, JsonTokenType.PropertyName);
 3538            JsonHelpers.ReadPropertyName(ref reader, "DefaultValue");
 3539            dynamic? defaultValue = JsonSerializer.Deserialize(ref reader, fieldType!, options);
 40
 3541            string? topicName = JsonHelpers.GetStringPropertyFromUtfReader(ref reader, "TopicName");
 42
 3543            JsonHelpers.ReadTokenType(ref reader, JsonTokenType.PropertyName);
 3544            JsonHelpers.ReadPropertyName(ref reader, "ValuePostChangeProcessings");
 3545            List<IFieldValueProcessing>? fieldValueProcessings = JsonSerializer.Deserialize<List<IFieldValueProcessing>>
 46
 3547            FieldFormatter? fieldFormatter = null;
 3548            reader.Read();
 3549            if (reader.TokenType == JsonTokenType.PropertyName)
 250            {
 251                if (reader.GetString() != "Formatter")
 052                {
 053                    throw new JsonException();
 54                }
 255                fieldFormatter = JsonSerializer.Deserialize<FieldFormatter>(ref reader, options);
 256                reader.Read();
 257            }
 58
 3559            JsonHelpers.ReadTokenType(ref reader, JsonTokenType.EndObject, false);
 60
 3561            IFieldDefinition fieldDefinition = CreateInstance(fieldType!, fieldName, defaultValue, topicName);
 3562            fieldDefinition.ValuePostChangeProcessings = fieldValueProcessings!;
 3563            fieldDefinition.Formatter = fieldFormatter;
 3564            return fieldDefinition;
 3565        }
 66
 67        /// <summary>
 68        /// Writes the specified writer.
 69        /// </summary>
 70        /// <param name="writer">The writer.</param>
 71        /// <param name="value">The field definition.</param>
 72        /// <param name="options">The options.</param>
 73        public override void Write(Utf8JsonWriter writer, IFieldDefinition value, JsonSerializerOptions options)
 5674        {
 5675            writer.WriteStartObject();
 76
 5677            writer.WriteString("Type", value.Type.ToString());
 5678            writer.WriteString("Name", value.Name);
 5679            dynamic actualFieldDefinition = value;
 5680            Type fieldType = actualFieldDefinition.Type;
 5681            if (!FieldConvertersCache.TryGetValue(fieldType, out dynamic? fieldConverter))
 2482            {
 2483                fieldConverter = JsonSerializerOptions.Default.GetConverter(fieldType);
 2484                FieldConvertersCache.Add(fieldType, fieldConverter);
 2485            }
 5686            writer.WritePropertyName("DefaultValue");
 5687            fieldConverter.Write(writer, actualFieldDefinition.DefaultValue, options);
 88
 5689            writer.WriteString("TopicName", value.TopicName);
 90
 5691            writer.WritePropertyName("ValuePostChangeProcessings");
 5692            JsonSerializer.Serialize(writer, value.ValuePostChangeProcessings, options);
 93
 5694            if (value!.Formatter is not null)
 495            {
 496                writer.WritePropertyName("Formatter");
 497                JsonSerializer.Serialize(writer, value.Formatter, options);
 498            }
 5699            writer.WriteEndObject();
 56100        }
 101
 102        /// <summary>
 103        /// Creates an instance for targetType's <see cref="FieldDefinition{T}"/>.
 104        /// </summary>
 105        /// <param name="targetType">Type of the target.</param>
 106        /// <param name="fieldName">Name of the field.</param>
 107        /// <param name="value">The value.</param>
 108        /// <param name="topicName">Name of the topic.</param>
 109        /// <returns><see cref="IFieldDefinition"/> created instance.</returns>
 110        private static IFieldDefinition CreateInstance(Type targetType, string fieldName, object value, string? topicNam
 35111        {
 35112            var ctor = GetConstructor(targetType, targetType);
 35113            return (IFieldDefinition)ctor.Invoke([fieldName, value, topicName]);
 35114        }
 115
 116        /// <summary>
 117        /// Gets the constructor for targetType's <see cref="FieldDefinition{T}"/>.
 118        /// </summary>
 119        /// <param name="targetType">Type of the target.</param>
 120        /// <param name="argumentType">Type of the argument.</param>
 121        /// <returns>Constructor info</returns>
 122        /// <exception cref="InvalidOperationException">No constructor found for FieldDefinition{targetType.Name}.</exce
 123        private static ConstructorInfo GetConstructor(Type targetType, Type argumentType)
 35124        {
 35125            return typeof(FieldDefinition<>)
 35126                .MakeGenericType(targetType)
 35127                .GetConstructor([typeof(string), argumentType, typeof(string)])
 35128                ?? throw new InvalidOperationException($"No constructor found for FieldDefinition<{targetType.Name}>.");
 35129        }
 130    }
 131}
Generated by: ReportGenerator 5.4.4.0
02/19/2026 - 16:45:37
GitHub | reportgenerator.io

Methods/Properties

.cctor()
Read(System.Text.Json.Utf8JsonReader&,System.Type,System.Text.Json.JsonSerializerOptions)
Write(System.Text.Json.Utf8JsonWriter,pva.SuperV.Engine.IFieldDefinition,System.Text.Json.JsonSerializerOptions)
CreateInstance(System.Type,System.String,System.Object,System.String)
GetConstructor(System.Type,System.Type)