VersionConverter.cs

Go to the documentation of this file.

using System;
 
using Newtonsoft.Json;
 
using Tgstation.Server.Api;
 
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Serialization;
 
namespace Tgstation.Server.Host.Extensions.Converters
{
    sealed class VersionConverter : JsonConverter, IYamlTypeConverter
    {
        static bool CheckSupportsType(Type type, bool validate)
        {
            ArgumentNullException.ThrowIfNull(type);
 
            var supported = type == typeof(global::System.Version);
            if (!supported && validate)
                throw new NotSupportedException($"{nameof(VersionConverter)} does not convert {type}s!");
 
            return supported;
        }
 
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            if (value == null)
            {
                writer.WriteNull();
            }
            else if (value is global::System.Version version)
            {
                writer.WriteValue(version.Semver().ToString());
            }
            else
            {
                throw new ArgumentException("Expected Version object!", nameof(value));
            }
        }
 
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            ArgumentNullException.ThrowIfNull(reader);
 
            CheckSupportsType(objectType, true);
 
            if (reader.TokenType == JsonToken.Null)
                return null;
 
            if (reader.TokenType == JsonToken.String)
            {
                try
                {
                    var v = global::System.Version.Parse((string)reader.Value);
                    return v.Semver();
                }
                catch (Exception ex)
                {
                    throw new JsonSerializationException($"Error parsing version string: {reader.Value}", ex);
                }
            }
 
            throw new JsonSerializationException(
                $"Unexpected token or value when parsing version. Token: {reader.TokenType}, Value: {reader.Value}");
        }
 
        public override bool CanConvert(Type objectType) => CheckSupportsType(objectType, false);
 
        public bool Accepts(Type type) => CheckSupportsType(type, false);
 
        public object ReadYaml(IParser parser, Type type) => throw new NotSupportedException("Deserialization not supported!"); // The default implementation is fine at handling this
 
        public void WriteYaml(IEmitter emitter, object value, Type type)
        {
            ArgumentNullException.ThrowIfNull(emitter);
 
            CheckSupportsType(type, true);
 
            if (value == null)
                throw new NotSupportedException("Null values not supported!");
 
            var version = (global::System.Version)value;
            emitter.Emit(
                new Scalar(
                    version
                        .Semver()
                        .ToString()));
        }
    }
}