private static JsonConverter <T>?GetConverter <T>(JsonSerializerOptions options)
{
if (typeof(T) == typeof(object))
{
return(null);
}
return(options?.GetConverter(typeof(T)) as JsonConverter <T>);
}
/// <summary>
/// Initializes a new instance of the <see cref="ConfigurationDictionaryConverter{TElement}" /> class.
/// </summary>
/// <param name="options">
/// The options controlling the serialization/deserialization.
/// </param>
public ConfigurationDictionaryConverter(JsonSerializerOptions options)
{
// For performance, use the existing converter if available.
_valueConverter = (JsonConverter <TElement>)options
.GetConverter(typeof(TElement));
// Cache the key and value types.
_keyType = typeof(string);
_elementType = typeof(TElement);
}
public override Option <T> Read(ref Utf8JsonReader reader, System.Type typeToConvert, JsonSerializerOptions options)
{
if (reader.TokenType == JsonTokenType.Null)
{
reader.Read();
return(Option.None <T>());
}
return(Option.Some(((JsonConverter <T>)options.GetConverter(typeof(T))).Read(ref reader, typeof(T), options)));
}
public override void Write(Utf8JsonWriter writer, ResolvedEvent value, JsonSerializerOptions options)
{
var @event = value.OriginalEvent;
if (@event == null)
{
writer.WriteStartObject();
writer.WriteEndObject();
return;
}
writer.WriteStartObject();
writer.WritePropertyName("messageId");
options.GetConverter <Uuid>().Write(writer, @event.EventId, options);
writer.WriteString("createdUtc", @event.Created);
writer.WritePropertyName("position");
options.GetConverter <Position>().Write(writer, @event.Position, options);
writer.WriteString("streamId", @event.EventStreamId);
writer.WritePropertyName("streamVersion");
options.GetConverter <StreamRevision>()
.Write(writer, StreamRevision.FromStreamPosition(@event.EventNumber), options);
writer.WriteString("type", @event.EventType);
writer.WritePropertyName("payload");
if (MediaTypeHeaderValue.TryParse(@event.ContentType, out var contentType) &&
contentType.SubType.EndsWith("json", StringComparison.Ordinal))
{
var reader = new Utf8JsonReader(@event.Data.Span);
if (JsonDocument.TryParseValue(ref reader, out var payload))
{
payload.WriteTo(writer);
}
else
{
writer.WriteBase64StringValue(@event.Data.Span);
}
}
private static T GetValue <T>(ref Utf8JsonReader reader, JsonSerializerOptions options)
{
var converter = typeof(T) != typeof(object)
? options?.GetConverter(typeof(T)) as JsonConverter <T>
: null;
return(converter != null
? converter.Read(ref reader, typeof(T), options)
: JsonSerializer.Deserialize <T>(ref reader, options));
}
public DictionaryEnumConverterInner(JsonSerializerOptions options)
{
// For performance, use the existing converter if available.
_valueConverter = (JsonConverter <TValue>)options
.GetConverter(typeof(TValue));
// Cache the key and value types.
_keyType = typeof(TKey);
_valueType = typeof(TValue);
}
public StringNullableEnumConverter(JsonSerializerOptions options)
{
// for performance, use the existing converter if available
if (options != null)
{
_converter = (JsonConverter <T>)options.GetConverter(typeof(T));
}
// cache the underlying type
_underlyingType = Nullable.GetUnderlyingType(typeof(T));
}
public AbstractDictionaryConverter(JsonSerializerOptions options)
{
_keyConverter = TypeDescriptor.GetConverter(typeof(TK));
if (!(_keyConverter.CanConvertFrom(typeof(string)) && _keyConverter.CanConvertTo(typeof(string))))
{
throw new JsonException();
}
_valueConverter = (JsonConverter <TV>)options.GetConverter(typeof(TV));
}
public override void Write(Utf8JsonWriter writer, AudioAnalysis value, JsonSerializerOptions options)
{
var sectionArrayConverter = options.GetConverter <SectionArray>();
var segmentArrayConverter = options.GetConverter <SegmentArray>();
var timeIntervalArrayConverter = options.GetConverter <TimeIntervalArray>();
writer.WriteStartObject();
writer.WriteString("type", "audio_analysis");
writer.WritePropertyName("bars");
timeIntervalArrayConverter.Write(writer, value.Bars, options);
writer.WritePropertyName("beats");
timeIntervalArrayConverter.Write(writer, value.Beats, options);
writer.WritePropertyName("sections");
sectionArrayConverter.Write(writer, value.Sections, options);
writer.WritePropertyName("segments");
segmentArrayConverter.Write(writer, value.Segments, options);
writer.WritePropertyName("tatums");
timeIntervalArrayConverter.Write(writer, value.Tatums, options);
writer.WriteEndObject();
}
public ImmutablePointConverter(JsonSerializerOptions options)
{
if (options?.GetConverter(typeof(int)) is JsonConverter <int> intConverter)
{
_intConverter = intConverter;
}
else
{
throw new InvalidOperationException();
}
}
public KeyCombinationConverter(JsonSerializerOptions options)
{
if (options?.GetConverter(typeof(int)) is JsonConverter <int> intConverter)
{
this.intConverter = intConverter;
}
else
{
throw new InvalidOperationException();
}
if (options?.GetConverter(typeof(bool)) is JsonConverter <bool> boolConverter)
{
this.boolConverter = boolConverter;
}
else
{
throw new InvalidOperationException();
}
}
private static JsonConverter <List <T> > GetKeyConverter(JsonSerializerOptions options)
{
var converter = options.GetConverter(typeof(List <T>)) as JsonConverter <List <T> >;
if (converter is null)
{
throw new JsonException("...");
}
return(converter);
}
internal static JsonApiRelationshipDetailsConverter <T> GetRelationshipConverter <T>(this JsonSerializerOptions options)
{
var converter = options.GetConverter(typeof(RelationshipResource <T>));
if (converter is not JsonApiRelationshipDetailsConverter <T> jsonApiConverter)
{
throw new JsonApiException($"Converter not found for type {typeof(T)}");
}
return(jsonApiConverter);
}
public override IReadOnlyDictionary <IndexName, TValue>?Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
var converter = options.GetConverter(typeof(ReadOnlyIndexNameDictionary <>).MakeGenericType(typeof(TValue)));
if (converter is ReadOnlyIndexNameDictionaryConverter <TValue> specialisedConverter)
{
return(specialisedConverter.Read(ref reader, typeToConvert, options));
}
return(null);
}
internal static WrappedJsonConverter <T> GetWrappedConverter <T>(this JsonSerializerOptions options)
{
var converter = options.GetConverter(typeof(T));
if (converter is not WrappedJsonConverter <T> jsonApiConverter)
{
throw new JsonApiException($"Converter not found for type {typeof(T)}");
}
return(jsonApiConverter);
}
private static JsonConverter <T> GetKeyConverter(JsonSerializerOptions options)
{
var converter = options.GetConverter(typeof(T)) as JsonConverter <T>;
if (converter is null)
{
throw new JsonException($"No JSON converter for type {typeof(T).Name}");
}
return(converter);
}
public override T?Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
var converter = options.GetConverter(typeof(SourceMarker <>).MakeGenericType(typeToConvert));
if (converter is SourceConverter <T> sourceConverter)
{
var source = sourceConverter.Read(ref reader, typeToConvert, options);
return(source.Source);
}
return(default);
public int ReadProperty(ref Utf8JsonReader reader, JsonSerializerOptions options)
{
if (options?.GetConverter(typeof(int)) is JsonConverter <int> intConverter)
{
reader.Read();
return(intConverter.Read(ref reader, typeof(int), options));
}
else
{
throw new JsonException();
}
}
public override void Write(Utf8JsonWriter writer, object?value, JsonSerializerOptions options)
{
if (value == null)
{
writer.WriteNullValue();
return;
}
JsonConverter jsonConverter = options.GetConverter(value.GetType());
jsonConverter.GetType().GetMethod("Write") !.Invoke(jsonConverter, new object[] { writer, value, options });
}
public ExtensionDataMemberConverter(PropertyInfo propertyInfo, JsonSerializerOptions options)
{
if (propertyInfo.GetMethod == null || propertyInfo.SetMethod == null)
{
throw new JsonException("Invalid Serialization DataExtension Property");
}
Debug.Assert(propertyInfo.IsDefined(typeof(JsonExtensionDataAttribute)));
_memberGetter = (Func <T, Dictionary <string, TValue> >)propertyInfo.GetMethod.CreateDelegate(typeof(Func <T, Dictionary <string, TValue> >));
_memberSetter = (Action <T, Dictionary <string, TValue> >)propertyInfo.SetMethod.CreateDelegate(typeof(Action <T, Dictionary <string, TValue> >));
_jsonElementConverter = options.GetConverter <JsonElement>();
}
private static void WriteLinks(Utf8JsonWriter writer, IEnumerable <Link> links, JsonSerializerOptions options)
{
if (links == null || !links.Any())
{
return;
}
writer.WritePropertyName("_links");
var linkConverter = (LinksConverter)options.GetConverter(typeof(IEnumerable <Link>));
linkConverter.Write(writer, links, options);
}
private static TValue?ReadProperty <TValue>(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions?options)
{
// Attempt to use existing converter first before re-entering through JsonSerializer.Deserialize().
// The default converter for objects does not parse null objects as null, so it is not used here.
if (typeToConvert != typeof(object) && options?.GetConverter(typeToConvert) is JsonConverter <TValue> valueConverter)
{
reader.Read();
return(valueConverter.Read(ref reader, typeToConvert, options));
}
return(JsonSerializer.Deserialize <TValue>(ref reader, options));
}
internal override void WriteWithQuotes(Utf8JsonWriter writer, object value, JsonSerializerOptions options, ref WriteStack state)
{
Type runtimeType = value.GetType();
JsonConverter runtimeConverter = options.GetConverter(runtimeType);
if (runtimeConverter == this)
{
ThrowHelper.ThrowNotSupportedException_DictionaryKeyTypeNotSupported(runtimeType, this);
}
runtimeConverter.WriteWithQuotesAsObject(writer, value, options, ref state);
}
public override object?Read(ref Utf8JsonReader reader, Type type, JsonSerializerOptions options)
{
var converter = options.GetConverter(typeof(JsonElement)) as JsonConverter <JsonElement>;
if (converter == null)
{
throw new JsonException();
}
var jsonEl = converter.Read(ref reader, type, options);
return(deserializeValue(jsonEl, options));
}
/// <summary>
/// Gets the default <see cref="JsonSerializerOptions" /> options.
/// </summary>
/// <remarks>
/// When changing these options, update
/// Jellyfin.Server/Extensions/ApiServiceCollectionExtensions.cs
/// -> AddJellyfinApi
/// -> AddJsonOptions.
/// </remarks>
/// <returns>The default <see cref="JsonSerializerOptions" /> options.</returns>
public static JsonSerializerOptions GetOptions()
{
var options = new JsonSerializerOptions
{
ReadCommentHandling = JsonCommentHandling.Disallow,
WriteIndented = false,
DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
NumberHandling = JsonNumberHandling.AllowReadingFromString
};
// Get built-in converters for fallback converting.
var baseNullableInt32Converter = (JsonConverter <int?>)options.GetConverter(typeof(int?));
var baseNullableInt64Converter = (JsonConverter <long?>)options.GetConverter(typeof(long?));
options.Converters.Add(new JsonGuidConverter());
options.Converters.Add(new JsonStringEnumConverter());
options.Converters.Add(new JsonNullableStructConverter <int>(baseNullableInt32Converter));
options.Converters.Add(new JsonNullableStructConverter <long>(baseNullableInt64Converter));
return(options);
}
public DictionaryInt32StringKeyValueConverter(JsonSerializerOptions options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
_intToStringConverter = (JsonConverter <KeyValuePair <int, string> >)options.GetConverter(typeof(KeyValuePair <int, string>));
// KeyValuePair<> converter is built-in.
Debug.Assert(_intToStringConverter != null);
}
public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)
{
Debug.Assert(typeToConvert.GetGenericArguments().Length > 0);
Type valueTypeToConvert = typeToConvert.GetGenericArguments()[0];
JsonConverter valueConverter = options.GetConverter(valueTypeToConvert);
Debug.Assert(valueConverter != null);
return(CreateValueConverter(valueTypeToConvert, valueConverter));
}
public override void Write(Utf8JsonWriter writer, SearchResult value, JsonSerializerOptions options)
{
void WritePaging <TObject>(string propertyName, Paging <TObject>?paging, JsonConverter <Paging <TObject> > converter)
{
if (paging is not null)
{
writer.WritePropertyName(propertyName);
converter.Write(writer, paging, options);
}
else
{
writer.WriteNull(propertyName);
}
}
var artistPagingConverter = options.GetConverter <Paging <Artist> >();
var playlistPagingConverter = options.GetConverter <Paging <Playlist> >();
var simplifiedAlbumPagingConverter = options.GetConverter <Paging <SimplifiedAlbum> >();
var simplifiedEpisodePagingConverter = options.GetConverter <Paging <SimplifiedEpisode> >();
var simplifiedShowPagingConverter = options.GetConverter <Paging <SimplifiedShow> >();
var trackPagingConverter = options.GetConverter <Paging <Track> >();
writer.WriteStartObject();
WritePaging("artists", value.Artists, artistPagingConverter);
WritePaging("albums", value.Albums, simplifiedAlbumPagingConverter);
WritePaging("tracks", value.Tracks, trackPagingConverter);
WritePaging("shows", value.Shows, simplifiedShowPagingConverter);
WritePaging("episodes", value.Episodes, simplifiedEpisodePagingConverter);
WritePaging("playlists", value.Playlists, playlistPagingConverter);
writer.WriteEndObject();
}
/// <summary>
/// Read Value in the Array
/// </summary>
/// <typeparam name="T">Tuple Element Type</typeparam>
/// <param name="reader">Reader</param>
/// <param name="options">Existing Options</param>
/// <returns>Deserialized Value</returns>
protected T ReadValue <T>(ref Utf8JsonReader reader, JsonSerializerOptions options)
{
var converter = (JsonConverter <T>)options.GetConverter(typeof(T));
if (converter == null)
{
return(JsonSerializer.Deserialize <T>(ref reader, options));
}
else
{
return(converter.Read(ref reader, typeof(T), options));
}
}
public void TestWhyObjectForWhichNoConverterIsDefinedIsStillConverted()
{
var options = new JsonSerializerOptions();
var converter = options.GetConverter(typeof(TestClass));
Contract.Assert(converter == null);
// ok there's no converter, but why DOES it convert?
var serialized = JsonSerializer.Serialize(new TestClass());
Contract.Assert(serialized == "{\"S\":\"S\"}");
// lesson: apparently there's default JsonConverters in the JsonSerializer which are not in the JsonSerializerOptions.Converters collection...
}