< Summary - Syki

Information
Class: Syki.Back.Converters.SykiStringEnumConverter
Assembly: Back
File(s): /home/runner/work/syki/syki/Back/Converters/SykiStringEnumConverter.cs
Tag: 56_26538939494
Line coverage
39%
Covered lines: 19
Uncovered lines: 29
Coverable lines: 48
Total lines: 106
Line coverage: 39.5%
Branch coverage
33%
Covered branches: 16
Total branches: 48
Branch coverage: 33.3%
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(...)0%342180%
Write(...)100%11100%
.ctor()100%11100%
Read(...)40%1012041.17%
Write(...)0%620%

File(s)

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

#LineLine coverage
 1using System.Text.Json;
 2using System.Text.Json.Serialization;
 3
 4namespace Syki.Back.Converters;
 5
 6public sealed class SykiStringEnumConverter : JsonConverterFactory
 7{
 128    public SykiStringEnumConverter() { }
 9
 10    public override bool CanConvert(Type typeToConvert)
 11    {
 23012        var underlying = Nullable.GetUnderlyingType(typeToConvert);
 23013        return (underlying is not null && underlying.IsEnum) || typeToConvert.IsEnum;
 14    }
 15
 16    public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)
 17    {
 1418        var underlying = Nullable.GetUnderlyingType(typeToConvert);
 1419        var enumType = underlying ?? typeToConvert;
 20
 1421        var convType = underlying == null
 1422            ? typeof(EnumConverter<>).MakeGenericType(enumType)
 1423            : typeof(NullableEnumConverter<>).MakeGenericType(enumType);
 24
 1425        return (JsonConverter)Activator.CreateInstance(convType)!;
 26    }
 27
 28    private sealed class EnumConverter<TEnum> : JsonConverter<TEnum> where TEnum : struct, Enum
 29    {
 1630        public EnumConverter() { }
 31
 32        public override TEnum Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
 33        {
 034            if (reader.TokenType == JsonTokenType.String)
 35            {
 036                var s = reader.GetString();
 037                if (!string.IsNullOrWhiteSpace(s) &&
 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            }
 046            else if (reader.TokenType == JsonTokenType.Number &&
 047                    reader.TryGetInt32(out var value) &&
 048                    Enum.IsDefined(typeof(TEnum), value))
 49            {
 050                return (TEnum)Enum.ToObject(typeof(TEnum), value);
 51            }
 52
 053            return (TEnum)Enum.ToObject(typeof(TEnum), int.MaxValue);
 54        }
 55
 56        public override void Write(Utf8JsonWriter writer, TEnum value, JsonSerializerOptions options)
 1857            => writer.WriteStringValue(value.ToString());
 58    }
 59
 60    private sealed class NullableEnumConverter<TEnum> : JsonConverter<TEnum?> where TEnum : struct, Enum
 61    {
 1262        public NullableEnumConverter() { }
 63
 64        public override TEnum? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
 65        {
 9666            if (reader.TokenType == JsonTokenType.Null)
 067                return null;
 68
 9669            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
 9685            if (reader.TokenType == JsonTokenType.Number &&
 9686                reader.TryGetInt32(out var value) &&
 9687                Enum.IsDefined(typeof(TEnum), value))
 88            {
 8889                return (TEnum)Enum.ToObject(typeof(TEnum), value);
 90            }
 91
 892            return null;
 93        }
 94
 95        public override void Write(Utf8JsonWriter writer, TEnum? value, JsonSerializerOptions options)
 96        {
 097            if (value == null)
 98            {
 099                writer.WriteNullValue();
 0100                return;
 101            }
 102
 0103            writer.WriteStringValue(value.Value.ToString());
 0104        }
 105    }
 106}