-
Notifications
You must be signed in to change notification settings - Fork 44
/
EnumIntKeyDictionaryConverterFactory.cs
126 lines (108 loc) · 4.53 KB
/
EnumIntKeyDictionaryConverterFactory.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
//
// EnumIntKeyDictionaryConverterFactory.cs
//
// Author:
// Jarl Gullberg <jarl.gullberg@gmail.com>
//
// Copyright (c) Jarl Gullberg
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
using System;
using System.Collections.Generic;
using System.Text.Json;
using System.Text.Json.Serialization;
using Remora.Rest.Json;
namespace Remora.Discord.API.Json;
/// <summary>
/// Creates a JSON converter for dictionaries with enum keys.
/// </summary>
internal class EnumIntKeyDictionaryConverterFactory : JsonConverterFactory
{
/// <inheritdoc />
public override bool CanConvert(Type typeToConvert)
=> typeToConvert.IsGenericType && typeof(IReadOnlyDictionary<,>).IsAssignableFrom(typeToConvert.GetGenericTypeDefinition())
&& typeToConvert.GetGenericArguments()[0].IsEnum;
/// <inheritdoc />
public override JsonConverter? CreateConverter(Type typeToConvert, JsonSerializerOptions options)
=> (JsonConverter?)Activator.CreateInstance
(
typeof(EnumKeyDictionaryConverterInner<,>).MakeGenericType
(
typeToConvert.GetGenericArguments()[0],
typeToConvert.GetGenericArguments()[1]
),
options
);
/// <inheritdoc />
internal class EnumKeyDictionaryConverterInner<TEnumKey, TValue> : JsonConverter<IReadOnlyDictionary<TEnumKey, TValue>>
where TEnumKey : struct, Enum
{
private readonly JsonConverter<TValue> _valueConverter;
private readonly JsonConverter<TEnumKey> _keyConverter;
/// <summary>
/// Initializes a new instance of the <see cref="EnumKeyDictionaryConverterInner{TEnumKey, TValue}"/> class.
/// </summary>
/// <param name="options">The serializer options.</param>
public EnumKeyDictionaryConverterInner(JsonSerializerOptions options)
{
_valueConverter = (JsonConverter<TValue>)options.GetConverter(typeof(TValue));
_keyConverter = new StringEnumConverter<TEnumKey>(asInteger: true);
}
/// <inheritdoc />
public override IReadOnlyDictionary<TEnumKey, TValue> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
if (reader.TokenType != JsonTokenType.StartObject)
{
throw new JsonException();
}
var result = new Dictionary<TEnumKey, TValue>();
while (reader.Read())
{
if (reader.TokenType == JsonTokenType.EndObject)
{
return result;
}
if (reader.TokenType != JsonTokenType.PropertyName)
{
throw new JsonException();
}
var keyString = reader.GetString() ?? throw new JsonException("Dictionaries cannot contain null keys.");
var parsedKey = Enum.TryParse<TEnumKey>(keyString, out var keyValue);
if (!parsedKey)
{
throw new JsonException($"Could not parse key '{keyString}' as enum of type {typeof(TEnumKey).Name}.");
}
if (!reader.Read())
{
throw new JsonException();
}
var value = _valueConverter.Read(ref reader, typeof(TValue), options);
result.Add(keyValue, value!);
}
return result;
}
/// <inheritdoc />
public override void Write(Utf8JsonWriter writer, IReadOnlyDictionary<TEnumKey, TValue> value, JsonSerializerOptions options)
{
writer.WriteStartObject();
foreach (var (key, val) in value)
{
_keyConverter.WriteAsPropertyName(writer, key, options);
_valueConverter.Write(writer, val, options);
}
writer.WriteEndObject();
}
}
}