How to use CreateConverter method of Microsoft.Playwright.Transport.Converters.JsonStringEnumMemberConverter class

1/*
2 * MIT License
3 *
4 * Copyright (c) Microsoft Corporation.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in all
14 * copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 */
24
25using System;
26using System.Text.Json;
27using System.Text.Json.Serialization;
28using Microsoft.Playwright.Helpers;
29
30namespace Microsoft.Playwright.Transport.Converters
31{
32    internal class JsonStringEnumMemberConverter : JsonConverterFactory
33    {
34        public override bool CanConvert(Type typeToConvert)
35            => typeToConvert.IsEnum || Nullable.GetUnderlyingType(typeToConvert)?.IsEnum == true;
36
37        public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)
38        {
39            var nullableType = Nullable.GetUnderlyingType(typeToConvert);
40
41            return (JsonConverter)Activator.CreateInstance(
42                nullableType == null ?
43                    typeof(EnumMemberConverter<>).MakeGenericType(typeToConvert) :
44                    typeof(NullableEnumMemberConverter<>).MakeGenericType(nullableType));
45        }
46
47        private static TEnum? Read<TEnum>(ref Utf8JsonReader reader)
48            where TEnum : struct, Enum
49        {
50            if (reader.TokenType == JsonTokenType.Null)
51            {
52                return null;
53            }
54            else if (reader.TokenType == JsonTokenType.String)
55            {
56                return EnumHelper.FromValueString<TEnum>(reader.GetString());
57            }
58            else if (reader.TokenType == JsonTokenType.Number)
59            {
60                var enumTypeCode = Type.GetTypeCode(typeof(TEnum));
61                return enumTypeCode switch
62                {
63                    TypeCode.Int32 => (TEnum)(object)reader.GetInt32(),
64                    TypeCode.Int64 => (TEnum)(object)reader.GetInt64(),
65                    TypeCode.Int16 => (TEnum)(object)reader.GetInt16(),
66                    TypeCode.Byte => (TEnum)(object)reader.GetByte(),
67                    TypeCode.UInt32 => (TEnum)(object)reader.GetUInt32(),
68                    TypeCode.UInt64 => (TEnum)(object)reader.GetUInt64(),
69                    TypeCode.UInt16 => (TEnum)(object)reader.GetUInt16(),
70                    TypeCode.SByte => (TEnum)(object)reader.GetSByte(),
71                    _ => throw new JsonException($"Enum '{typeof(TEnum).Name}' of {enumTypeCode} type is not supported."),
72                };
73            }
74            throw new JsonException();
75        }
76
77        private static void Write<TEnum>(Utf8JsonWriter writer, TEnum? value)
78            where TEnum : struct, Enum
79        {
80            if (value.HasValue)
81            {
82                writer.WriteStringValue(EnumHelper.ToValueString(value.Value));
83            }
84            else
85            {
86                writer.WriteNullValue();
87            }
88        }
89
90        private class EnumMemberConverter<TEnum> : JsonConverter<TEnum>
91            where TEnum : struct, Enum
92        {
93            public override TEnum Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
94                => Read<TEnum>(ref reader) ?? default;
95
96            public override void Write(Utf8JsonWriter writer, TEnum value, JsonSerializerOptions options)
97                => Write<TEnum>(writer, value);
98        }
99
100        private class NullableEnumMemberConverter<TEnum> : JsonConverter<TEnum?>
101            where TEnum : struct, Enum
102        {
103            public override TEnum? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
104                => Read<TEnum>(ref reader);
105
106            public override void Write(Utf8JsonWriter writer, TEnum? value, JsonSerializerOptions options)
107                => Write<TEnum>(writer, value);
108        }
109    }
110}
111

Source: JsonStringEnumMemberConverter.cs

/*
 * MIT License
 *
 * Copyright (c) Microsoft Corporation.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

using System;
using System.Text.Json;
using System.Text.Json.Serialization;
using Microsoft.Playwright.Helpers;

namespace Microsoft.Playwright.Transport.Converters
{
    internal class JsonStringEnumMemberConverter : JsonConverterFactory
    {
        public override bool CanConvert(Type typeToConvert)
            => typeToConvert.IsEnum || Nullable.GetUnderlyingType(typeToConvert)?.IsEnum == true;

        public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)
        {
            var nullableType = Nullable.GetUnderlyingType(typeToConvert);

            return (JsonConverter)Activator.CreateInstance(
                nullableType == null ?
                    typeof(EnumMemberConverter<>).MakeGenericType(typeToConvert) :
                    typeof(NullableEnumMemberConverter<>).MakeGenericType(nullableType));
        }

        private static TEnum? Read<TEnum>(ref Utf8JsonReader reader)
            where TEnum : struct, Enum
        {
            if (reader.TokenType == JsonTokenType.Null)
            {
                return null;
            }
            else if (reader.TokenType == JsonTokenType.String)
            {
                return EnumHelper.FromValueString<TEnum>(reader.GetString());
            }
            else if (reader.TokenType == JsonTokenType.Number)
            {
                var enumTypeCode = Type.GetTypeCode(typeof(TEnum));
                return enumTypeCode switch
                {
                    TypeCode.Int32 => (TEnum)(object)reader.GetInt32(),
                    TypeCode.Int64 => (TEnum)(object)reader.GetInt64(),
                    TypeCode.Int16 => (TEnum)(object)reader.GetInt16(),
                    TypeCode.Byte => (TEnum)(object)reader.GetByte(),
                    TypeCode.UInt32 => (TEnum)(object)reader.GetUInt32(),
                    TypeCode.UInt64 => (TEnum)(object)reader.GetUInt64(),
                    TypeCode.UInt16 => (TEnum)(object)reader.GetUInt16(),
                    TypeCode.SByte => (TEnum)(object)reader.GetSByte(),
                    _ => throw new JsonException($"Enum '{typeof(TEnum).Name}' of {enumTypeCode} type is not supported."),
                };
            }
            throw new JsonException();
        }

        private static void Write<TEnum>(Utf8JsonWriter writer, TEnum? value)
            where TEnum : struct, Enum
        {
            if (value.HasValue)
            {
                writer.WriteStringValue(EnumHelper.ToValueString(value.Value));
            }
            else
            {
                writer.WriteNullValue();
            }
        }

        private class EnumMemberConverter<TEnum> : JsonConverter<TEnum>
            where TEnum : struct, Enum
        {
            public override TEnum Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
                => Read<TEnum>(ref reader) ?? default;

            public override void Write(Utf8JsonWriter writer, TEnum value, JsonSerializerOptions options)
                => Write<TEnum>(writer, value);
        }

        private class NullableEnumMemberConverter<TEnum> : JsonConverter<TEnum?>
            where TEnum : struct, Enum
        {
            public override TEnum? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
                => Read<TEnum>(ref reader);

            public override void Write(Utf8JsonWriter writer, TEnum? value, JsonSerializerOptions options)
                => Write<TEnum>(writer, value);
        }
    }
}