< Summary - pva.SuperV

Information
Class: pva.SuperV.Engine.JsonConverters.FieldValueProcessingJsonConverter
Assembly: pva.SuperV.Engine
File(s): /home/runner/work/pva.SuperV/pva.SuperV/pva.SuperV.Engine/JsonConverters/FieldValueProcessingJsonConverter.cs
Tag: dotnet-ubuntu_22190969454
Line coverage
98%
Covered lines: 68
Uncovered lines: 1
Coverable lines: 69
Total lines: 134
Line coverage: 98.5%
Branch coverage
83%
Covered branches: 10
Total branches: 12
Branch coverage: 83.3%
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(...)100%11100%
ReadParameters(...)83.33%6695.45%
Write(...)100%11100%
WriteCtorParameters(...)100%44100%
CreateInstance(...)100%11100%
GetConstructor(...)50%22100%

File(s)

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

#LineLine coverage
 1using pva.SuperV.Engine.Processing;
 2using System.Reflection;
 3using System.Text.Json;
 4using System.Text.Json.Serialization;
 5
 6namespace pva.SuperV.Engine.JsonConverters
 7{
 8    /// <summary>
 9    /// Json converter for field value processing
 10    /// </summary>
 11    /// <seealso cref="JsonConverter{IFieldValueProcessing}" />
 12    public class FieldValueProcessingJsonConverter : JsonConverter<IFieldValueProcessing>
 13    {
 14        /// <summary>
 15        /// The field converters cache.
 16        /// </summary>
 217        private static readonly Dictionary<Type, dynamic> ArgConvertersCache = [];
 18
 19        /// <summary>
 20        /// Reads and converts the JSON to type.
 21        /// </summary>
 22        /// <param name="reader">The reader.</param>
 23        /// <param name="typeToConvert">The type to convert.</param>
 24        /// <param name="options">An object that specifies serialization options to use.</param>
 25        /// <returns>
 26        /// The converted value.
 27        /// </returns>
 28        /// <exception cref="JsonException"></exception>
 29        public override IFieldValueProcessing Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions 
 1530        {
 1531            JsonHelpers.ReadTokenType(ref reader, JsonTokenType.StartObject, false);
 32
 1533            string? fieldValueProcessingTypeString = JsonHelpers.GetStringPropertyFromUtfReader(ref reader, "Type");
 1534            string? fieldValueProcessingName = JsonHelpers.GetStringPropertyFromUtfReader(ref reader, "Name");
 35
 1536            List<object> ctorArguments = ReadParameters(ref reader, options);
 1537            Type? fieldType = Type.GetType(fieldValueProcessingTypeString!);
 38
 1539            JsonHelpers.ReadTokenType(ref reader, JsonTokenType.EndObject);
 40
 1541            IFieldValueProcessing fieldValueProcessing = CreateInstance(fieldType!);
 1542            fieldValueProcessing.Name = fieldValueProcessingName!;
 1543            fieldValueProcessing.CtorArguments = ctorArguments;
 1544            return fieldValueProcessing;
 1545        }
 46
 47        private static List<object> ReadParameters(ref Utf8JsonReader reader, JsonSerializerOptions options)
 1548        {
 1549            List<object> ctorArguments = [];
 1550            JsonHelpers.ReadTokenType(ref reader, JsonTokenType.PropertyName);
 1551            JsonHelpers.ReadPropertyName(ref reader, "Params");
 52
 1553            JsonHelpers.ReadTokenType(ref reader, JsonTokenType.StartArray);
 9354            while (reader.Read())
 9355            {
 9356                if (reader.TokenType == JsonTokenType.EndArray)
 1557                {
 1558                    return ctorArguments;
 59                }
 7860                JsonHelpers.ReadTokenType(ref reader, JsonTokenType.StartObject, false);
 7861                string? paramTypeString = JsonHelpers.GetStringPropertyFromUtfReader(ref reader, "Type");
 62
 7863                JsonHelpers.ReadTokenType(ref reader, JsonTokenType.PropertyName);
 7864                JsonHelpers.ReadPropertyName(ref reader, "Value");
 65
 7866                reader.Read();
 7867                Type? paramType = Type.GetType(paramTypeString!);
 7868                dynamic? argValue = JsonSerializer.Deserialize(ref reader, paramType!, options);
 7869                JsonHelpers.ReadTokenType(ref reader, JsonTokenType.EndObject);
 7870                ctorArguments.Add(argValue);
 7871            }
 072            return ctorArguments;
 1573        }
 74
 75        /// <summary>
 76        /// Writes the specified writer.
 77        /// </summary>
 78        /// <param name="writer">The writer.</param>
 79        /// <param name="value">The field processing.</param>
 80        /// <param name="options">The options.</param>
 81        public override void Write(Utf8JsonWriter writer, IFieldValueProcessing value, JsonSerializerOptions options)
 3082        {
 3083            writer.WriteStartObject();
 3084            writer.WriteString("Type", value.GetType().ToString());
 3085            writer.WriteString("Name", value.Name);
 3086            WriteCtorParameters(writer, value, options);
 3087            writer.WriteEndObject();
 3088        }
 89
 90        private static void WriteCtorParameters(Utf8JsonWriter writer, IFieldValueProcessing fieldValueProcessing, JsonS
 3091        {
 3092            writer.WriteStartArray("Params");
 3093            fieldValueProcessing.CtorArguments.ForEach(arg =>
 15694                {
 15695                    Type argType = arg.GetType();
 15696                    writer.WriteStartObject();
 15697                    writer.WriteString("Type", argType.ToString());
 15698                    if (!ArgConvertersCache.TryGetValue(argType, out dynamic? argConverter))
 299                    {
 2100                        argConverter = JsonSerializerOptions.Default.GetConverter(argType);
 2101                        ArgConvertersCache.Add(argType, argConverter);
 2102                    }
 156103                    writer.WritePropertyName("Value");
 156104                    JsonSerializer.Serialize(writer, arg, options);
 156105                    writer.WriteEndObject();
 186106                });
 30107            writer.WriteEndArray();
 30108        }
 109
 110        /// <summary>
 111        /// Creates an instance for targetType's <see cref="FieldValueProcessing{T}"/>.
 112        /// </summary>
 113        /// <param name="targetType">Type of the target.</param>
 114        /// <returns><see cref="IFieldValueProcessing"/> created instance.</returns>
 115        private static IFieldValueProcessing CreateInstance(Type targetType)
 15116        {
 15117            var ctor = GetConstructor(targetType);
 15118            return (IFieldValueProcessing)ctor.Invoke([]);
 15119        }
 120
 121        /// <summary>
 122        /// Gets the constructor for targetType's <see cref="FieldValueProcessing{T}"/>.
 123        /// </summary>
 124        /// <param name="fieldProcesingType">Type of the target.</param>
 125        /// <returns></returns>
 126        /// <exception cref="InvalidOperationException">No constructor found for FieldValueProcessing{targetType.Name}.<
 127        private static ConstructorInfo GetConstructor(Type fieldProcesingType)
 15128        {
 15129            return fieldProcesingType
 15130                .GetConstructor([])
 15131                ?? throw new InvalidOperationException($"No constructor found for {fieldProcesingType.Name}.");
 15132        }
 133    }
 134}
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)
ReadParameters(System.Text.Json.Utf8JsonReader&,System.Text.Json.JsonSerializerOptions)
Write(System.Text.Json.Utf8JsonWriter,pva.SuperV.Engine.Processing.IFieldValueProcessing,System.Text.Json.JsonSerializerOptions)
WriteCtorParameters(System.Text.Json.Utf8JsonWriter,pva.SuperV.Engine.Processing.IFieldValueProcessing,System.Text.Json.JsonSerializerOptions)
CreateInstance(System.Type)
GetConstructor(System.Type)