diff --git a/head/csharp/test/inputs/json/misc/31189.json/default/QuickType.cs b/head/csharp/test/inputs/json/misc/31189.json/default/QuickType.cs new file mode 100644 index 0000000..ad87dbb --- /dev/null +++ b/head/csharp/test/inputs/json/misc/31189.json/default/QuickType.cs @@ -0,0 +1,206 @@ +// +// +// To parse this JSON data, add NuGet 'Newtonsoft.Json' then do: +// +// using QuickType; +// +// var topLevel = TopLevel.FromJson(jsonString); +#nullable enable +#pragma warning disable CS8618 +#pragma warning disable CS8601 +#pragma warning disable CS8602 +#pragma warning disable CS8603 +#pragma warning disable CS8604 +#pragma warning disable CS8625 +#pragma warning disable CS8765 + +namespace QuickType +{ + using System; + using System.Collections.Generic; + + using System.Globalization; + using Newtonsoft.Json; + using Newtonsoft.Json.Converters; + + public partial class TopLevel + { + [JsonProperty("details", Required = Required.Always)] + public Uri Details { get; set; } + + [JsonProperty("rates", Required = Required.Always)] + public Rate[] Rates { get; set; } + + [JsonProperty("version", Required = Required.AllowNull)] + public object Version { get; set; } + } + + public partial class Rate + { + [JsonProperty("code", Required = Required.Always)] + public string Code { get; set; } + + [JsonProperty("country_code", Required = Required.Always)] + public string CountryCode { get; set; } + + [JsonProperty("name", Required = Required.Always)] + public string Name { get; set; } + + [JsonProperty("periods", Required = Required.Always)] + public Period[] Periods { get; set; } + } + + public partial class Period + { + [JsonProperty("effective_from", Required = Required.Always)] + public EffectiveFromUnion EffectiveFrom { get; set; } + + [JsonProperty("rates", Required = Required.Always)] + public Rates Rates { get; set; } + } + + public partial class Rates + { + [JsonProperty("parking", Required = Required.DisallowNull, NullValueHandling = NullValueHandling.Ignore)] + public double? Parking { get; set; } + + [JsonProperty("reduced", Required = Required.DisallowNull, NullValueHandling = NullValueHandling.Ignore)] + public double? Reduced { get; set; } + + [JsonProperty("reduced1", Required = Required.DisallowNull, NullValueHandling = NullValueHandling.Ignore)] + public double? Reduced1 { get; set; } + + [JsonProperty("reduced2", Required = Required.DisallowNull, NullValueHandling = NullValueHandling.Ignore)] + public double? Reduced2 { get; set; } + + [JsonProperty("standard", Required = Required.Always)] + public double Standard { get; set; } + + [JsonProperty("super_reduced", Required = Required.DisallowNull, NullValueHandling = NullValueHandling.Ignore)] + public double? SuperReduced { get; set; } + } + + public enum EffectiveFromEnum { The00000101 }; + + public partial struct EffectiveFromUnion + { + public DateTimeOffset? DateTime; + public EffectiveFromEnum? Enum; + + public static implicit operator EffectiveFromUnion(DateTimeOffset DateTime) => new EffectiveFromUnion { DateTime = DateTime }; + public static implicit operator EffectiveFromUnion(EffectiveFromEnum Enum) => new EffectiveFromUnion { Enum = Enum }; + } + + public partial class TopLevel + { + public static TopLevel FromJson(string json) => JsonConvert.DeserializeObject(json, QuickType.Converter.Settings); + } + + public static partial class Serialize + { + public static string ToJson(this TopLevel self) => JsonConvert.SerializeObject(self, QuickType.Converter.Settings); + } + + internal static partial class Converter + { + public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings + { + MetadataPropertyHandling = MetadataPropertyHandling.Ignore, + DateParseHandling = DateParseHandling.None, + Converters = + { + EffectiveFromUnionConverter.Singleton, + EffectiveFromEnumConverter.Singleton, + new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal } + }, + }; + } + + internal class EffectiveFromUnionConverter : JsonConverter + { + public override bool CanConvert(Type t) => t == typeof(EffectiveFromUnion) || t == typeof(EffectiveFromUnion?); + + public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer) + { + switch (reader.TokenType) + { + case JsonToken.String: + case JsonToken.Date: + var stringValue = serializer.Deserialize(reader); + DateTimeOffset dt; + if (DateTimeOffset.TryParse(stringValue, out dt)) + { + return new EffectiveFromUnion { DateTime = dt }; + } + if (stringValue == "0000-01-01") + { + return new EffectiveFromUnion { Enum = EffectiveFromEnum.The00000101 }; + } + break; + } + throw new Exception("Cannot unmarshal type EffectiveFromUnion"); + } + + public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer) + { + var value = (EffectiveFromUnion)untypedValue; + if (value.DateTime != null) + { + serializer.Serialize(writer, value.DateTime.Value.ToString("o", System.Globalization.CultureInfo.InvariantCulture)); + return; + } + if (value.Enum != null) + { + if (value.Enum == EffectiveFromEnum.The00000101) + { + serializer.Serialize(writer, "0000-01-01"); + return; + } + } + throw new Exception("Cannot marshal type EffectiveFromUnion"); + } + + public static readonly EffectiveFromUnionConverter Singleton = new EffectiveFromUnionConverter(); + } + + internal class EffectiveFromEnumConverter : JsonConverter + { + public override bool CanConvert(Type t) => t == typeof(EffectiveFromEnum) || t == typeof(EffectiveFromEnum?); + + public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer) + { + if (reader.TokenType == JsonToken.Null) return null; + var value = serializer.Deserialize(reader); + if (value == "0000-01-01") + { + return EffectiveFromEnum.The00000101; + } + throw new Exception("Cannot unmarshal type EffectiveFromEnum"); + } + + public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer) + { + if (untypedValue == null) + { + serializer.Serialize(writer, null); + return; + } + var value = (EffectiveFromEnum)untypedValue; + if (value == EffectiveFromEnum.The00000101) + { + serializer.Serialize(writer, "0000-01-01"); + return; + } + throw new Exception("Cannot marshal type EffectiveFromEnum"); + } + + public static readonly EffectiveFromEnumConverter Singleton = new EffectiveFromEnumConverter(); + } +} +#pragma warning restore CS8618 +#pragma warning restore CS8601 +#pragma warning restore CS8602 +#pragma warning restore CS8603 +#pragma warning restore CS8604 +#pragma warning restore CS8625 +#pragma warning restore CS8765 diff --git a/head/csharp-SystemTextJson/test/inputs/json/misc/31189.json/default/QuickType.cs b/head/csharp-SystemTextJson/test/inputs/json/misc/31189.json/default/QuickType.cs new file mode 100644 index 0000000..336bf34 --- /dev/null +++ b/head/csharp-SystemTextJson/test/inputs/json/misc/31189.json/default/QuickType.cs @@ -0,0 +1,316 @@ +// +// +// To parse this JSON data, add NuGet 'System.Text.Json' then do: +// +// using QuickType; +// +// var topLevel = TopLevel.FromJson(jsonString); +#nullable enable +#pragma warning disable CS8618 +#pragma warning disable CS8601 +#pragma warning disable CS8602 +#pragma warning disable CS8603 + +namespace QuickType +{ + using System; + using System.Collections.Generic; + + using System.Text.Json; + using System.Text.Json.Serialization; + using System.Globalization; + + public partial class TopLevel + { + [JsonRequired] + [JsonPropertyName("details")] + public Uri Details { get; set; } + + [JsonRequired] + [JsonPropertyName("rates")] + public Rate[] Rates { get; set; } + + [JsonRequired] + [JsonPropertyName("version")] + public object Version { get; set; } + } + + public partial class Rate + { + [JsonRequired] + [JsonPropertyName("code")] + public string Code { get; set; } + + [JsonRequired] + [JsonPropertyName("country_code")] + public string CountryCode { get; set; } + + [JsonRequired] + [JsonPropertyName("name")] + public string Name { get; set; } + + [JsonRequired] + [JsonPropertyName("periods")] + public Period[] Periods { get; set; } + } + + public partial class Period + { + [JsonRequired] + [JsonPropertyName("effective_from")] + public EffectiveFromUnion EffectiveFrom { get; set; } + + [JsonRequired] + [JsonPropertyName("rates")] + public Rates Rates { get; set; } + } + + public partial class Rates + { + [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)] + [JsonPropertyName("parking")] + public double? Parking { get; set; } + + [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)] + [JsonPropertyName("reduced")] + public double? Reduced { get; set; } + + [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)] + [JsonPropertyName("reduced1")] + public double? Reduced1 { get; set; } + + [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)] + [JsonPropertyName("reduced2")] + public double? Reduced2 { get; set; } + + [JsonRequired] + [JsonPropertyName("standard")] + public double Standard { get; set; } + + [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)] + [JsonPropertyName("super_reduced")] + public double? SuperReduced { get; set; } + } + + public enum EffectiveFromEnum { The00000101 }; + + public partial struct EffectiveFromUnion + { + public DateTimeOffset? DateTime; + public EffectiveFromEnum? Enum; + + public static implicit operator EffectiveFromUnion(DateTimeOffset DateTime) => new EffectiveFromUnion { DateTime = DateTime }; + public static implicit operator EffectiveFromUnion(EffectiveFromEnum Enum) => new EffectiveFromUnion { Enum = Enum }; + } + + public partial class TopLevel + { + public static TopLevel FromJson(string json) => global::System.Text.Json.JsonSerializer.Deserialize(json, QuickType.Converter.Settings); + } + + public static partial class Serialize + { + public static string ToJson(this TopLevel self) => JsonSerializer.Serialize(self, QuickType.Converter.Settings); + } + + internal static partial class Converter + { + public static readonly JsonSerializerOptions Settings = new(JsonSerializerDefaults.General) + { + Converters = + { + EffectiveFromUnionConverter.Singleton, + EffectiveFromEnumConverter.Singleton, + new DateOnlyConverter(), + new TimeOnlyConverter(), + IsoDateTimeOffsetConverter.Singleton + }, + }; + } + + internal class EffectiveFromUnionConverter : JsonConverter + { + public override bool CanConvert(Type t) => t == typeof(EffectiveFromUnion); + + public override EffectiveFromUnion Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + switch (reader.TokenType) + { + case JsonTokenType.String: + var stringValue = reader.GetString(); + DateTimeOffset dt; + if (DateTimeOffset.TryParse(stringValue, out dt)) + { + return new EffectiveFromUnion { DateTime = dt }; + } + if (stringValue == "0000-01-01") + { + return new EffectiveFromUnion { Enum = EffectiveFromEnum.The00000101 }; + } + break; + } + throw new JsonException("Cannot unmarshal type EffectiveFromUnion"); + } + + public override void Write(Utf8JsonWriter writer, EffectiveFromUnion value, JsonSerializerOptions options) + { + if (value.DateTime != null) + { + JsonSerializer.Serialize(writer, value.DateTime.Value.ToString("o", System.Globalization.CultureInfo.InvariantCulture), options); + return; + } + if (value.Enum != null) + { + if (value.Enum == EffectiveFromEnum.The00000101) + { + JsonSerializer.Serialize(writer, "0000-01-01", options); + return; + } + } + throw new NotSupportedException("Cannot marshal type EffectiveFromUnion"); + } + + public static readonly EffectiveFromUnionConverter Singleton = new EffectiveFromUnionConverter(); + } + + internal class EffectiveFromEnumConverter : JsonConverter + { + public override bool CanConvert(Type t) => t == typeof(EffectiveFromEnum); + + public override EffectiveFromEnum Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + var value = reader.GetString(); + if (value == "0000-01-01") + { + return EffectiveFromEnum.The00000101; + } + throw new JsonException("Cannot unmarshal type EffectiveFromEnum"); + } + + public override void Write(Utf8JsonWriter writer, EffectiveFromEnum value, JsonSerializerOptions options) + { + if (value == EffectiveFromEnum.The00000101) + { + JsonSerializer.Serialize(writer, "0000-01-01", options); + return; + } + throw new NotSupportedException("Cannot marshal type EffectiveFromEnum"); + } + + public static readonly EffectiveFromEnumConverter Singleton = new EffectiveFromEnumConverter(); + } + + public class DateOnlyConverter : JsonConverter + { + private readonly string serializationFormat; + public DateOnlyConverter() : this(null) { } + + public DateOnlyConverter(string? serializationFormat) + { + this.serializationFormat = serializationFormat ?? "yyyy-MM-dd"; + } + + public override DateOnly Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + var value = reader.GetString(); + return DateOnly.Parse(value!); + } + + public override void Write(Utf8JsonWriter writer, DateOnly value, JsonSerializerOptions options) + => writer.WriteStringValue(value.ToString(serializationFormat)); + } + + public class TimeOnlyConverter : JsonConverter + { + private readonly string serializationFormat; + + public TimeOnlyConverter() : this(null) { } + + public TimeOnlyConverter(string? serializationFormat) + { + this.serializationFormat = serializationFormat ?? "HH:mm:ss.fff"; + } + + public override TimeOnly Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + var value = reader.GetString(); + return TimeOnly.Parse(value!); + } + + public override void Write(Utf8JsonWriter writer, TimeOnly value, JsonSerializerOptions options) + => writer.WriteStringValue(value.ToString(serializationFormat)); + } + + internal class IsoDateTimeOffsetConverter : JsonConverter + { + public override bool CanConvert(Type t) => t == typeof(DateTimeOffset); + + private const string DefaultDateTimeFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK"; + + private DateTimeStyles _dateTimeStyles = DateTimeStyles.RoundtripKind; + private string? _dateTimeFormat; + private CultureInfo? _culture; + + public DateTimeStyles DateTimeStyles + { + get => _dateTimeStyles; + set => _dateTimeStyles = value; + } + + public string? DateTimeFormat + { + get => _dateTimeFormat ?? string.Empty; + set => _dateTimeFormat = (string.IsNullOrEmpty(value)) ? null : value; + } + + public CultureInfo Culture + { + get => _culture ?? CultureInfo.CurrentCulture; + set => _culture = value; + } + + public override void Write(Utf8JsonWriter writer, DateTimeOffset value, JsonSerializerOptions options) + { + string text; + + + if ((_dateTimeStyles & DateTimeStyles.AdjustToUniversal) == DateTimeStyles.AdjustToUniversal + || (_dateTimeStyles & DateTimeStyles.AssumeUniversal) == DateTimeStyles.AssumeUniversal) + { + value = value.ToUniversalTime(); + } + + text = value.ToString(_dateTimeFormat ?? DefaultDateTimeFormat, Culture); + + writer.WriteStringValue(text); + } + + public override DateTimeOffset Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) + { + string? dateText = reader.GetString(); + + if (string.IsNullOrEmpty(dateText) == false) + { + if (!string.IsNullOrEmpty(_dateTimeFormat)) + { + return DateTimeOffset.ParseExact(dateText, _dateTimeFormat, Culture, _dateTimeStyles); + } + else + { + return DateTimeOffset.Parse(dateText, Culture, _dateTimeStyles); + } + } + else + { + return default(DateTimeOffset); + } + } + + + public static readonly IsoDateTimeOffsetConverter Singleton = new IsoDateTimeOffsetConverter(); + } +} +#pragma warning restore CS8618 +#pragma warning restore CS8601 +#pragma warning restore CS8602 +#pragma warning restore CS8603 diff --git a/head/csharp-records/test/inputs/json/misc/31189.json/default/QuickType.cs b/head/csharp-records/test/inputs/json/misc/31189.json/default/QuickType.cs new file mode 100644 index 0000000..728ad9c --- /dev/null +++ b/head/csharp-records/test/inputs/json/misc/31189.json/default/QuickType.cs @@ -0,0 +1,206 @@ +// +// +// To parse this JSON data, add NuGet 'Newtonsoft.Json' then do: +// +// using QuickType; +// +// var topLevel = TopLevel.FromJson(jsonString); +#nullable enable +#pragma warning disable CS8618 +#pragma warning disable CS8601 +#pragma warning disable CS8602 +#pragma warning disable CS8603 +#pragma warning disable CS8604 +#pragma warning disable CS8625 +#pragma warning disable CS8765 + +namespace QuickType +{ + using System; + using System.Collections.Generic; + + using System.Globalization; + using Newtonsoft.Json; + using Newtonsoft.Json.Converters; + + public partial record TopLevel + { + [JsonProperty("details", Required = Required.Always)] + public Uri Details { get; set; } + + [JsonProperty("rates", Required = Required.Always)] + public Rate[] Rates { get; set; } + + [JsonProperty("version", Required = Required.AllowNull)] + public object Version { get; set; } + } + + public partial record Rate + { + [JsonProperty("code", Required = Required.Always)] + public string Code { get; set; } + + [JsonProperty("country_code", Required = Required.Always)] + public string CountryCode { get; set; } + + [JsonProperty("name", Required = Required.Always)] + public string Name { get; set; } + + [JsonProperty("periods", Required = Required.Always)] + public Period[] Periods { get; set; } + } + + public partial record Period + { + [JsonProperty("effective_from", Required = Required.Always)] + public EffectiveFromUnion EffectiveFrom { get; set; } + + [JsonProperty("rates", Required = Required.Always)] + public Rates Rates { get; set; } + } + + public partial record Rates + { + [JsonProperty("parking", Required = Required.DisallowNull, NullValueHandling = NullValueHandling.Ignore)] + public double? Parking { get; set; } + + [JsonProperty("reduced", Required = Required.DisallowNull, NullValueHandling = NullValueHandling.Ignore)] + public double? Reduced { get; set; } + + [JsonProperty("reduced1", Required = Required.DisallowNull, NullValueHandling = NullValueHandling.Ignore)] + public double? Reduced1 { get; set; } + + [JsonProperty("reduced2", Required = Required.DisallowNull, NullValueHandling = NullValueHandling.Ignore)] + public double? Reduced2 { get; set; } + + [JsonProperty("standard", Required = Required.Always)] + public double Standard { get; set; } + + [JsonProperty("super_reduced", Required = Required.DisallowNull, NullValueHandling = NullValueHandling.Ignore)] + public double? SuperReduced { get; set; } + } + + public enum EffectiveFromEnum { The00000101 }; + + public partial struct EffectiveFromUnion + { + public DateTimeOffset? DateTime; + public EffectiveFromEnum? Enum; + + public static implicit operator EffectiveFromUnion(DateTimeOffset DateTime) => new EffectiveFromUnion { DateTime = DateTime }; + public static implicit operator EffectiveFromUnion(EffectiveFromEnum Enum) => new EffectiveFromUnion { Enum = Enum }; + } + + public partial record TopLevel + { + public static TopLevel FromJson(string json) => JsonConvert.DeserializeObject(json, QuickType.Converter.Settings); + } + + public static partial class Serialize + { + public static string ToJson(this TopLevel self) => JsonConvert.SerializeObject(self, QuickType.Converter.Settings); + } + + internal static partial class Converter + { + public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings + { + MetadataPropertyHandling = MetadataPropertyHandling.Ignore, + DateParseHandling = DateParseHandling.None, + Converters = + { + EffectiveFromUnionConverter.Singleton, + EffectiveFromEnumConverter.Singleton, + new IsoDateTimeConverter { DateTimeStyles = DateTimeStyles.AssumeUniversal } + }, + }; + } + + internal class EffectiveFromUnionConverter : JsonConverter + { + public override bool CanConvert(Type t) => t == typeof(EffectiveFromUnion) || t == typeof(EffectiveFromUnion?); + + public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer) + { + switch (reader.TokenType) + { + case JsonToken.String: + case JsonToken.Date: + var stringValue = serializer.Deserialize(reader); + DateTimeOffset dt; + if (DateTimeOffset.TryParse(stringValue, out dt)) + { + return new EffectiveFromUnion { DateTime = dt }; + } + if (stringValue == "0000-01-01") + { + return new EffectiveFromUnion { Enum = EffectiveFromEnum.The00000101 }; + } + break; + } + throw new Exception("Cannot unmarshal type EffectiveFromUnion"); + } + + public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer) + { + var value = (EffectiveFromUnion)untypedValue; + if (value.DateTime != null) + { + serializer.Serialize(writer, value.DateTime.Value.ToString("o", System.Globalization.CultureInfo.InvariantCulture)); + return; + } + if (value.Enum != null) + { + if (value.Enum == EffectiveFromEnum.The00000101) + { + serializer.Serialize(writer, "0000-01-01"); + return; + } + } + throw new Exception("Cannot marshal type EffectiveFromUnion"); + } + + public static readonly EffectiveFromUnionConverter Singleton = new EffectiveFromUnionConverter(); + } + + internal class EffectiveFromEnumConverter : JsonConverter + { + public override bool CanConvert(Type t) => t == typeof(EffectiveFromEnum) || t == typeof(EffectiveFromEnum?); + + public override object ReadJson(JsonReader reader, Type t, object existingValue, JsonSerializer serializer) + { + if (reader.TokenType == JsonToken.Null) return null; + var value = serializer.Deserialize(reader); + if (value == "0000-01-01") + { + return EffectiveFromEnum.The00000101; + } + throw new Exception("Cannot unmarshal type EffectiveFromEnum"); + } + + public override void WriteJson(JsonWriter writer, object untypedValue, JsonSerializer serializer) + { + if (untypedValue == null) + { + serializer.Serialize(writer, null); + return; + } + var value = (EffectiveFromEnum)untypedValue; + if (value == EffectiveFromEnum.The00000101) + { + serializer.Serialize(writer, "0000-01-01"); + return; + } + throw new Exception("Cannot marshal type EffectiveFromEnum"); + } + + public static readonly EffectiveFromEnumConverter Singleton = new EffectiveFromEnumConverter(); + } +} +#pragma warning restore CS8618 +#pragma warning restore CS8601 +#pragma warning restore CS8602 +#pragma warning restore CS8603 +#pragma warning restore CS8604 +#pragma warning restore CS8625 +#pragma warning restore CS8765 diff --git a/base/flow/test/inputs/json/misc/31189.json/default/TopLevel.js b/head/flow/test/inputs/json/misc/31189.json/default/TopLevel.js index cd33f16..fc27fd8 100644 --- a/base/flow/test/inputs/json/misc/31189.json/default/TopLevel.js +++ b/head/flow/test/inputs/json/misc/31189.json/default/TopLevel.js @@ -23,10 +23,15 @@ export type Rate = { }; export type Period = { - effective_from: Date; + effective_from: EffectiveFromUnion; rates: Rates; }; +export type EffectiveFromUnion = Date | EffectiveFromEnum; + +export type EffectiveFromEnum = + "0000-01-01"; + export type Rates = { parking?: number; reduced?: number; @@ -212,7 +217,7 @@ const typeMap: any = { { json: "periods", js: "periods", typ: a(r("Period")) }, ], false), "Period": o([ - { json: "effective_from", js: "effective_from", typ: Date }, + { json: "effective_from", js: "effective_from", typ: u(Date, r("EffectiveFromEnum")) }, { json: "rates", js: "rates", typ: r("Rates") }, ], false), "Rates": o([ @@ -223,6 +228,9 @@ const typeMap: any = { { json: "standard", js: "standard", typ: 3.14 }, { json: "super_reduced", js: "super_reduced", typ: u(undefined, 3.14) }, ], false), + "EffectiveFromEnum": [ + "0000-01-01", + ], }; module.exports = { diff --git a/head/java/test/inputs/json/misc/31189.json/default/src/main/java/io/quicktype/EffectiveFromEnum.java b/head/java/test/inputs/json/misc/31189.json/default/src/main/java/io/quicktype/EffectiveFromEnum.java new file mode 100644 index 0000000..5fc930b --- /dev/null +++ b/head/java/test/inputs/json/misc/31189.json/default/src/main/java/io/quicktype/EffectiveFromEnum.java @@ -0,0 +1,22 @@ +package io.quicktype; + +import java.io.IOException; +import com.fasterxml.jackson.annotation.*; + +public enum EffectiveFromEnum { + THE_00000101; + + @JsonValue + public String toValue() { + switch (this) { + case THE_00000101: return "0000-01-01"; + } + return null; + } + + @JsonCreator + public static EffectiveFromEnum forValue(String value) throws IOException { + if (value.equals("0000-01-01")) return THE_00000101; + throw new IOException("Cannot deserialize EffectiveFromEnum"); + } +} diff --git a/head/java/test/inputs/json/misc/31189.json/default/src/main/java/io/quicktype/EffectiveFromUnion.java b/head/java/test/inputs/json/misc/31189.json/default/src/main/java/io/quicktype/EffectiveFromUnion.java new file mode 100644 index 0000000..0264b2d --- /dev/null +++ b/head/java/test/inputs/json/misc/31189.json/default/src/main/java/io/quicktype/EffectiveFromUnion.java @@ -0,0 +1,55 @@ +package io.quicktype; + +import java.io.IOException; +import java.io.IOException; +import com.fasterxml.jackson.core.*; +import com.fasterxml.jackson.databind.*; +import com.fasterxml.jackson.databind.annotation.*; +import com.fasterxml.jackson.core.type.*; +import java.time.LocalDate; + +@JsonDeserialize(using = EffectiveFromUnion.Deserializer.class) +@JsonSerialize(using = EffectiveFromUnion.Serializer.class) +public class EffectiveFromUnion { + public LocalDate dateValue; + public EffectiveFromEnum enumValue; + + static class Deserializer extends JsonDeserializer { + @Override + public EffectiveFromUnion deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException { + EffectiveFromUnion value = new EffectiveFromUnion(); + switch (jsonParser.currentToken()) { + case VALUE_STRING: + String string = jsonParser.readValueAs(String.class); + try { + value.dateValue = LocalDate.parse(string); + } catch (Exception ex) { + // Ignored + } + try { + value.enumValue = EffectiveFromEnum.forValue(string); + } catch (Exception ex) { + // Ignored + } + break; + default: throw new IOException("Cannot deserialize EffectiveFromUnion"); + } + return value; + } + } + + static class Serializer extends JsonSerializer { + @Override + public void serialize(EffectiveFromUnion obj, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { + if (obj.dateValue != null) { + jsonGenerator.writeObject(obj.dateValue.format(java.time.format.DateTimeFormatter.ISO_DATE)); + return; + } + if (obj.enumValue != null) { + jsonGenerator.writeObject(obj.enumValue); + return; + } + throw new IOException("EffectiveFromUnion must not be null"); + } + } +} diff --git a/base/java/test/inputs/json/misc/31189.json/default/src/main/java/io/quicktype/Period.java b/head/java/test/inputs/json/misc/31189.json/default/src/main/java/io/quicktype/Period.java index 4ff9088..9e04efe 100644 --- a/base/java/test/inputs/json/misc/31189.json/default/src/main/java/io/quicktype/Period.java +++ b/head/java/test/inputs/json/misc/31189.json/default/src/main/java/io/quicktype/Period.java @@ -4,13 +4,13 @@ import com.fasterxml.jackson.annotation.*; import java.time.LocalDate; public class Period { - private LocalDate effectiveFrom; + private EffectiveFromUnion effectiveFrom; private Rates rates; @JsonProperty("effective_from") - public LocalDate getEffectiveFrom() { return effectiveFrom; } + public EffectiveFromUnion getEffectiveFrom() { return effectiveFrom; } @JsonProperty("effective_from") - public void setEffectiveFrom(LocalDate value) { this.effectiveFrom = value; } + public void setEffectiveFrom(EffectiveFromUnion value) { this.effectiveFrom = value; } @JsonProperty("rates") public Rates getRates() { return rates; } diff --git a/head/java-lombok/test/inputs/json/misc/31189.json/default/src/main/java/io/quicktype/EffectiveFromEnum.java b/head/java-lombok/test/inputs/json/misc/31189.json/default/src/main/java/io/quicktype/EffectiveFromEnum.java new file mode 100644 index 0000000..5fc930b --- /dev/null +++ b/head/java-lombok/test/inputs/json/misc/31189.json/default/src/main/java/io/quicktype/EffectiveFromEnum.java @@ -0,0 +1,22 @@ +package io.quicktype; + +import java.io.IOException; +import com.fasterxml.jackson.annotation.*; + +public enum EffectiveFromEnum { + THE_00000101; + + @JsonValue + public String toValue() { + switch (this) { + case THE_00000101: return "0000-01-01"; + } + return null; + } + + @JsonCreator + public static EffectiveFromEnum forValue(String value) throws IOException { + if (value.equals("0000-01-01")) return THE_00000101; + throw new IOException("Cannot deserialize EffectiveFromEnum"); + } +} diff --git a/head/java-lombok/test/inputs/json/misc/31189.json/default/src/main/java/io/quicktype/EffectiveFromUnion.java b/head/java-lombok/test/inputs/json/misc/31189.json/default/src/main/java/io/quicktype/EffectiveFromUnion.java new file mode 100644 index 0000000..0264b2d --- /dev/null +++ b/head/java-lombok/test/inputs/json/misc/31189.json/default/src/main/java/io/quicktype/EffectiveFromUnion.java @@ -0,0 +1,55 @@ +package io.quicktype; + +import java.io.IOException; +import java.io.IOException; +import com.fasterxml.jackson.core.*; +import com.fasterxml.jackson.databind.*; +import com.fasterxml.jackson.databind.annotation.*; +import com.fasterxml.jackson.core.type.*; +import java.time.LocalDate; + +@JsonDeserialize(using = EffectiveFromUnion.Deserializer.class) +@JsonSerialize(using = EffectiveFromUnion.Serializer.class) +public class EffectiveFromUnion { + public LocalDate dateValue; + public EffectiveFromEnum enumValue; + + static class Deserializer extends JsonDeserializer { + @Override + public EffectiveFromUnion deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException { + EffectiveFromUnion value = new EffectiveFromUnion(); + switch (jsonParser.currentToken()) { + case VALUE_STRING: + String string = jsonParser.readValueAs(String.class); + try { + value.dateValue = LocalDate.parse(string); + } catch (Exception ex) { + // Ignored + } + try { + value.enumValue = EffectiveFromEnum.forValue(string); + } catch (Exception ex) { + // Ignored + } + break; + default: throw new IOException("Cannot deserialize EffectiveFromUnion"); + } + return value; + } + } + + static class Serializer extends JsonSerializer { + @Override + public void serialize(EffectiveFromUnion obj, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException { + if (obj.dateValue != null) { + jsonGenerator.writeObject(obj.dateValue.format(java.time.format.DateTimeFormatter.ISO_DATE)); + return; + } + if (obj.enumValue != null) { + jsonGenerator.writeObject(obj.enumValue); + return; + } + throw new IOException("EffectiveFromUnion must not be null"); + } + } +} diff --git a/base/java-lombok/test/inputs/json/misc/31189.json/default/src/main/java/io/quicktype/Period.java b/head/java-lombok/test/inputs/json/misc/31189.json/default/src/main/java/io/quicktype/Period.java index 4ff9088..9e04efe 100644 --- a/base/java-lombok/test/inputs/json/misc/31189.json/default/src/main/java/io/quicktype/Period.java +++ b/head/java-lombok/test/inputs/json/misc/31189.json/default/src/main/java/io/quicktype/Period.java @@ -4,13 +4,13 @@ import com.fasterxml.jackson.annotation.*; import java.time.LocalDate; public class Period { - private LocalDate effectiveFrom; + private EffectiveFromUnion effectiveFrom; private Rates rates; @JsonProperty("effective_from") - public LocalDate getEffectiveFrom() { return effectiveFrom; } + public EffectiveFromUnion getEffectiveFrom() { return effectiveFrom; } @JsonProperty("effective_from") - public void setEffectiveFrom(LocalDate value) { this.effectiveFrom = value; } + public void setEffectiveFrom(EffectiveFromUnion value) { this.effectiveFrom = value; } @JsonProperty("rates") public Rates getRates() { return rates; } diff --git a/base/javascript/test/inputs/json/misc/31189.json/default/TopLevel.js b/head/javascript/test/inputs/json/misc/31189.json/default/TopLevel.js index b855085..3bab441 100644 --- a/base/javascript/test/inputs/json/misc/31189.json/default/TopLevel.js +++ b/head/javascript/test/inputs/json/misc/31189.json/default/TopLevel.js @@ -183,7 +183,7 @@ const typeMap = { { json: "periods", js: "periods", typ: a(r("Period")) }, ], false), "Period": o([ - { json: "effective_from", js: "effective_from", typ: Date }, + { json: "effective_from", js: "effective_from", typ: u(Date, r("EffectiveFromEnum")) }, { json: "rates", js: "rates", typ: r("Rates") }, ], false), "Rates": o([ @@ -194,6 +194,9 @@ const typeMap = { { json: "standard", js: "standard", typ: 3.14 }, { json: "super_reduced", js: "super_reduced", typ: u(undefined, 3.14) }, ], false), + "EffectiveFromEnum": [ + "0000-01-01", + ], }; module.exports = { diff --git a/base/kotlin/test/inputs/json/misc/31189.json/default/TopLevel.kt b/head/kotlin/test/inputs/json/misc/31189.json/default/TopLevel.kt index 9839430..abcba0b 100644 --- a/base/kotlin/test/inputs/json/misc/31189.json/default/TopLevel.kt +++ b/head/kotlin/test/inputs/json/misc/31189.json/default/TopLevel.kt @@ -17,7 +17,9 @@ private fun Klaxon.convert(k: kotlin.reflect.KClass<*>, fromJson: (JsonValue }) private val klaxon = Klaxon() - .convert(LocalDate::class, { LocalDate.parse(it.string!!) }, { "\"${java.time.format.DateTimeFormatter.ISO_LOCAL_DATE.format(it)}\"" }) + .convert(LocalDate::class, { LocalDate.parse(it.string!!) }, { "\"${java.time.format.DateTimeFormatter.ISO_LOCAL_DATE.format(it)}\"" }) + .convert(EffectiveFromEnum::class, { EffectiveFromEnum.fromValue(it.string!!) }, { "\"${it.value}\"" }) + .convert(EffectiveFromUnion::class, { EffectiveFromUnion.fromJson(it) }, { it.toJson() }, true) data class TopLevel ( val details: String, @@ -43,11 +45,39 @@ data class Rate ( data class Period ( @Json(name = "effective_from") - val effectiveFrom: LocalDate, + val effectiveFrom: EffectiveFromUnion, val rates: Rates ) +sealed class EffectiveFromUnion { + class DateValue(val value: LocalDate) : EffectiveFromUnion() + class EnumValue(val value: EffectiveFromEnum) : EffectiveFromUnion() + + public fun toJson(): String = klaxon.toJsonString(when (this) { + is DateValue -> this.value + is EnumValue -> this.value + }) + + companion object { + public fun fromJson(jv: JsonValue): EffectiveFromUnion = when (jv.inside) { + is String -> try { DateValue(jv.string?.let { LocalDate.parse(it) }!!) } catch (e: Exception) { EnumValue(jv.string?.let { EffectiveFromEnum.fromValue(it) }!!) } + else -> throw IllegalArgumentException() + } + } +} + +enum class EffectiveFromEnum(val value: String) { + The00000101("0000-01-01"); + + companion object { + public fun fromValue(value: String): EffectiveFromEnum = when (value) { + "0000-01-01" -> The00000101 + else -> throw IllegalArgumentException() + } + } +} + data class Rates ( val parking: Double? = null, val reduced: Double? = null, diff --git a/base/kotlin-jackson/test/inputs/json/misc/31189.json/default/TopLevel.kt b/head/kotlin-jackson/test/inputs/json/misc/31189.json/default/TopLevel.kt index d71d6c7..64a9480 100644 --- a/base/kotlin-jackson/test/inputs/json/misc/31189.json/default/TopLevel.kt +++ b/head/kotlin-jackson/test/inputs/json/misc/31189.json/default/TopLevel.kt @@ -29,7 +29,9 @@ private fun ObjectMapper.convert(k: kotlin.reflect.KClass<*>, fromJson: (Jso val mapper = jacksonObjectMapper().apply { propertyNamingStrategy = PropertyNamingStrategy.LOWER_CAMEL_CASE setSerializationInclusion(JsonInclude.Include.NON_NULL) - convert(LocalDate::class, { LocalDate.parse(it.asText()) }, { "\"${java.time.format.DateTimeFormatter.ISO_LOCAL_DATE.format(it)}\"" }) + convert(LocalDate::class, { LocalDate.parse(it.asText()) }, { "\"${java.time.format.DateTimeFormatter.ISO_LOCAL_DATE.format(it)}\"" }) + convert(EffectiveFromEnum::class, { EffectiveFromEnum.fromValue(it.asText()) }, { "\"${it.value}\"" }) + convert(EffectiveFromUnion::class, { EffectiveFromUnion.fromJson(it) }, { it.toJson() }, true) } data class TopLevel ( @@ -64,12 +66,40 @@ data class Rate ( data class Period ( @get:JsonProperty("effective_from", required=true)@field:JsonProperty("effective_from", required=true) - val effectiveFrom: LocalDate, + val effectiveFrom: EffectiveFromUnion, @get:JsonProperty(required=true)@field:JsonProperty(required=true) val rates: Rates ) +sealed class EffectiveFromUnion { + class DateValue(val value: LocalDate) : EffectiveFromUnion() + class EnumValue(val value: EffectiveFromEnum) : EffectiveFromUnion() + + fun toJson(): String = mapper.writeValueAsString(when (this) { + is DateValue -> this.value + is EnumValue -> this.value + }) + + companion object { + fun fromJson(jn: JsonNode): EffectiveFromUnion = when (jn) { + is TextNode -> try { DateValue(mapper.treeToValue(jn)) } catch (e: Exception) { EnumValue(mapper.treeToValue(jn)) } + else -> throw IllegalArgumentException() + } + } +} + +enum class EffectiveFromEnum(val value: String) { + The00000101("0000-01-01"); + + companion object { + fun fromValue(value: String): EffectiveFromEnum = when (value) { + "0000-01-01" -> The00000101 + else -> throw IllegalArgumentException() + } + } +} + data class Rates ( val parking: Double? = null, val reduced: Double? = null, diff --git a/base/kotlinx/test/inputs/json/misc/31189.json/default/TopLevel.kt b/head/kotlinx/test/inputs/json/misc/31189.json/default/TopLevel.kt index 9ecfa4b..b10a930 100644 --- a/base/kotlinx/test/inputs/json/misc/31189.json/default/TopLevel.kt +++ b/head/kotlinx/test/inputs/json/misc/31189.json/default/TopLevel.kt @@ -35,11 +35,22 @@ data class Rate ( @Serializable data class Period ( @SerialName("effective_from") - val effectiveFrom: LocalDate, + val effectiveFrom: EffectiveFromUnion, val rates: Rates ) +@Serializable +sealed class EffectiveFromUnion { + class DateValue(val value: LocalDate) : EffectiveFromUnion() + class EnumValue(val value: EffectiveFromEnum) : EffectiveFromUnion() +} + +@Serializable +enum class EffectiveFromEnum(val value: String) { + @SerialName("0000-01-01") The00000101("0000-01-01"); +} + @Serializable data class Rates ( val parking: Double? = null, diff --git a/head/python/test/inputs/json/misc/31189.json/default/quicktype.py b/head/python/test/inputs/json/misc/31189.json/default/quicktype.py new file mode 100644 index 0000000..cfcafc3 --- /dev/null +++ b/head/python/test/inputs/json/misc/31189.json/default/quicktype.py @@ -0,0 +1,173 @@ +import datetime +import re +from enum import Enum +from dataclasses import dataclass +from typing import Any, TypeVar, Type, cast, Callable +import dateutil.parser + + +T = TypeVar("T") +EnumT = TypeVar("EnumT", bound=Enum) + + +def from_float(x: Any) -> float: + assert isinstance(x, (float, int)) and not isinstance(x, bool) + return float(x) + + +def from_none(x: Any) -> Any: + assert x is None + return x + + +def from_union(fs, x): + for f in fs: + try: + return f(x) + except: + pass + assert False + + +def to_float(x: Any) -> float: + assert isinstance(x, (int, float)) + return x + + +def from_date(x: Any) -> datetime.date: + assert isinstance(x, str) and re.match(r"^\d{4}-\d{2}-\d{2}$", x) + return dateutil.parser.parse(x).date() + + +def to_enum(c: Type[EnumT], x: Any) -> EnumT: + assert isinstance(x, c) + return x.value + + +def to_class(c: Type[T], x: Any) -> dict: + assert isinstance(x, c) + return cast(Any, x).to_dict() + + +def from_str(x: Any) -> str: + assert isinstance(x, str) + return x + + +def from_list(f: Callable[[Any], T], x: Any) -> list[T]: + assert isinstance(x, list) + return [f(y) for y in x] + + +class EffectiveFromEnum(Enum): + THE_00000101 = "0000-01-01" + + +@dataclass +class Rates: + standard: float + parking: float | None + reduced: float | None + reduced1: float | None + reduced2: float | None + super_reduced: float | None + + @staticmethod + def from_dict(obj: Any) -> 'Rates': + assert isinstance(obj, dict) + standard = from_float(obj.get("standard")) + parking = from_union([from_float, from_none], obj.get("parking")) + reduced = from_union([from_float, from_none], obj.get("reduced")) + reduced1 = from_union([from_float, from_none], obj.get("reduced1")) + reduced2 = from_union([from_float, from_none], obj.get("reduced2")) + super_reduced = from_union([from_float, from_none], obj.get("super_reduced")) + return Rates(standard, parking, reduced, reduced1, reduced2, super_reduced) + + def to_dict(self) -> dict: + result: dict = {} + result["standard"] = to_float(self.standard) + if self.parking is not None: + result["parking"] = from_union([to_float, from_none], self.parking) + if self.reduced is not None: + result["reduced"] = from_union([to_float, from_none], self.reduced) + if self.reduced1 is not None: + result["reduced1"] = from_union([to_float, from_none], self.reduced1) + if self.reduced2 is not None: + result["reduced2"] = from_union([to_float, from_none], self.reduced2) + if self.super_reduced is not None: + result["super_reduced"] = from_union([to_float, from_none], self.super_reduced) + return result + + +@dataclass +class Period: + effective_from: datetime.date | EffectiveFromEnum + rates: Rates + + @staticmethod + def from_dict(obj: Any) -> 'Period': + assert isinstance(obj, dict) + effective_from = from_union([from_date, EffectiveFromEnum], obj.get("effective_from")) + rates = Rates.from_dict(obj.get("rates")) + return Period(effective_from, rates) + + def to_dict(self) -> dict: + result: dict = {} + result["effective_from"] = from_union([lambda x: x.isoformat(), lambda x: to_enum(EffectiveFromEnum, x)], self.effective_from) + result["rates"] = to_class(Rates, self.rates) + return result + + +@dataclass +class Rate: + code: str + country_code: str + name: str + periods: list[Period] + + @staticmethod + def from_dict(obj: Any) -> 'Rate': + assert isinstance(obj, dict) + code = from_str(obj.get("code")) + country_code = from_str(obj.get("country_code")) + name = from_str(obj.get("name")) + periods = from_list(Period.from_dict, obj.get("periods")) + return Rate(code, country_code, name, periods) + + def to_dict(self) -> dict: + result: dict = {} + result["code"] = from_str(self.code) + result["country_code"] = from_str(self.country_code) + result["name"] = from_str(self.name) + result["periods"] = from_list(lambda x: to_class(Period, x), self.periods) + return result + + +@dataclass +class TopLevel: + details: str + rates: list[Rate] + version: None + + @staticmethod + def from_dict(obj: Any) -> 'TopLevel': + assert isinstance(obj, dict) + details = from_str(obj.get("details")) + rates = from_list(Rate.from_dict, obj.get("rates")) + version = from_none(obj.get("version")) + return TopLevel(details, rates, version) + + def to_dict(self) -> dict: + result: dict = {} + result["details"] = from_str(self.details) + result["rates"] = from_list(lambda x: to_class(Rate, x), self.rates) + result["version"] = from_none(self.version) + return result + + +def top_level_from_dict(s: Any) -> TopLevel: + return TopLevel.from_dict(s) + + +def top_level_to_dict(x: TopLevel) -> Any: + return to_class(TopLevel, x) diff --git a/base/typescript/test/inputs/json/misc/31189.json/default/TopLevel.ts b/head/typescript/test/inputs/json/misc/31189.json/default/TopLevel.ts index 9249c88..e8c999b 100644 --- a/base/typescript/test/inputs/json/misc/31189.json/default/TopLevel.ts +++ b/head/typescript/test/inputs/json/misc/31189.json/default/TopLevel.ts @@ -21,10 +21,14 @@ export interface Rate { } export interface Period { - effective_from: Date; + effective_from: EffectiveFromUnion; rates: Rates; } +export type EffectiveFromUnion = Date | EffectiveFromEnum; + +export type EffectiveFromEnum = "0000-01-01"; + export interface Rates { parking?: number; reduced?: number; @@ -212,7 +216,7 @@ const typeMap: any = { { json: "periods", js: "periods", typ: a(r("Period")) }, ], false), "Period": o([ - { json: "effective_from", js: "effective_from", typ: Date }, + { json: "effective_from", js: "effective_from", typ: u(Date, r("EffectiveFromEnum")) }, { json: "rates", js: "rates", typ: r("Rates") }, ], false), "Rates": o([ @@ -223,4 +227,7 @@ const typeMap: any = { { json: "standard", js: "standard", typ: 3.14 }, { json: "super_reduced", js: "super_reduced", typ: u(undefined, 3.14) }, ], false), + "EffectiveFromEnum": [ + "0000-01-01", + ], };