< Summary - Estud

Information
Class: Estud.Back.Converters.EstudStringEnumConverter
Assembly: Back
File(s): /home/runner/work/syki/syki/Back/Converters/EstudStringEnumConverter.cs
Tag: 114_29044117136
Line coverage
58%
Covered lines: 28
Uncovered lines: 20
Coverable lines: 48
Total lines: 106
Line coverage: 58.3%
Branch coverage
54%
Covered branches: 26
Total branches: 48
Branch coverage: 54.1%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor()100%11100%
CanConvert(...)100%44100%
CreateConverter(...)100%44100%
.ctor()100%11100%
Read(...)50%781842.85%
Write(...)100%11100%
.ctor()100%11100%
Read(...)40%1012041.17%
Write(...)50%2260%

File(s)

/home/runner/work/syki/syki/Back/Converters/EstudStringEnumConverter.cs

#LineLine coverage
 1using System.Text.Json;
 2using System.Text.Json.Serialization;
 3
 4namespace Estud.Back.Converters;
 5
 6public sealed class EstudStringEnumConverter : JsonConverterFactory
 7{
 168    public EstudStringEnumConverter() { }
 9
 10    public override bool CanConvert(Type typeToConvert)
 11    {
 56212        var underlying = Nullable.GetUnderlyingType(typeToConvert);
 56213        return (underlying is not null && underlying.IsEnum) || typeToConvert.IsEnum;
 14    }
 15
 16    public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)
 17    {
 4418        var underlying = Nullable.GetUnderlyingType(typeToConvert);
 4419        var enumType = underlying ?? typeToConvert;
 20
 4421        var convType = underlying == null
 4422            ? typeof(EnumConverter<>).MakeGenericType(enumType)
 4423            : typeof(NullableEnumConverter<>).MakeGenericType(enumType);
 24
 4425        return (JsonConverter)Activator.CreateInstance(convType)!;
 26    }
 27
 28    private sealed class EnumConverter<TEnum> : JsonConverter<TEnum> where TEnum : struct, Enum
 29    {
 7230        public EnumConverter() { }
 31
 32        public override TEnum Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
 33        {
 23834            if (reader.TokenType == JsonTokenType.String)
 35            {
 036                var s = reader.GetString();
 037                if (s.HasValue() &&
 038                    Enum.TryParse<TEnum>(s, ignoreCase: true, out var parsed) &&
 039                    Enum.IsDefined(parsed))
 040                    return parsed;
 41
 042                if (int.TryParse(s, out var n) &&
 043                    Enum.IsDefined(typeof(TEnum), n))
 044                    return (TEnum)Enum.ToObject(typeof(TEnum), n);
 45            }
 23846            else if (reader.TokenType == JsonTokenType.Number &&
 23847                    reader.TryGetInt32(out var value) &&
 23848                    Enum.IsDefined(typeof(TEnum), value))
 49            {
 23050                return (TEnum)Enum.ToObject(typeof(TEnum), value);
 51            }
 52
 853            return (TEnum)Enum.ToObject(typeof(TEnum), int.MaxValue);
 54        }
 55
 56        public override void Write(Utf8JsonWriter writer, TEnum value, JsonSerializerOptions options)
 11457            => writer.WriteStringValue(value.ToString());
 58    }
 59
 60    private sealed class NullableEnumConverter<TEnum> : JsonConverter<TEnum?> where TEnum : struct, Enum
 61    {
 1662        public NullableEnumConverter() { }
 63
 64        public override TEnum? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
 65        {
 24866            if (reader.TokenType == JsonTokenType.Null)
 067                return null;
 68
 24869            if (reader.TokenType == JsonTokenType.String)
 70            {
 071                var str = reader.GetString();
 072                if (str.IsEmpty()) return null;
 73
 074                if (Enum.TryParse<TEnum>(str, ignoreCase: true, out var parsed) &&
 075                    Enum.IsDefined(parsed))
 076                    return parsed;
 77
 078                if (int.TryParse(str, out var n) &&
 079                    Enum.IsDefined(typeof(TEnum), n))
 080                    return (TEnum)Enum.ToObject(typeof(TEnum), n);
 81
 082                return null;
 83            }
 84
 24885            if (reader.TokenType == JsonTokenType.Number &&
 24886                reader.TryGetInt32(out var value) &&
 24887                Enum.IsDefined(typeof(TEnum), value))
 88            {
 23889                return (TEnum)Enum.ToObject(typeof(TEnum), value);
 90            }
 91
 1092            return null;
 93        }
 94
 95        public override void Write(Utf8JsonWriter writer, TEnum? value, JsonSerializerOptions options)
 96        {
 297            if (value == null)
 98            {
 099                writer.WriteNullValue();
 0100                return;
 101            }
 102
 2103            writer.WriteStringValue(value.Value.ToString());
 2104        }
 105    }
 106}