diff --git a/.github/workflows/samples-jdk17.yaml b/.github/workflows/samples-jdk17.yaml
index 085e5493ed9c..bc2b9d5b8f79 100644
--- a/.github/workflows/samples-jdk17.yaml
+++ b/.github/workflows/samples-jdk17.yaml
@@ -24,6 +24,7 @@ on:
- samples/server/petstore/java-helidon-server/v3/mp/**
- samples/server/petstore/java-helidon-server/v3/se/**
- samples/server/petstore/jaxrs-spec-sealed/**
+ - samples/server/petstore/jaxrs-spec-sealed-jsonb/**
- samples/server/petstore/jaxrs-spec/quarkus-security/**
- samples/server/petstore/jaxrs-spec-quarkus-jspecify/**
pull_request:
@@ -50,6 +51,7 @@ on:
- samples/server/petstore/java-helidon-server/v3/mp/**
- samples/server/petstore/java-helidon-server/v3/se/**
- samples/server/petstore/jaxrs-spec-sealed/**
+ - samples/server/petstore/jaxrs-spec-sealed-jsonb/**
- samples/server/petstore/jaxrs-spec/quarkus-security/**
- samples/server/petstore/jaxrs-spec-quarkus-jspecify/**
jobs:
@@ -82,6 +84,7 @@ jobs:
- samples/server/petstore/java-helidon-server/v3/mp/
- samples/server/petstore/java-helidon-server/v3/se
- samples/server/petstore/jaxrs-spec-sealed
+ - samples/server/petstore/jaxrs-spec-sealed-jsonb
- samples/server/petstore/jaxrs-spec/quarkus-security
- samples/server/petstore/jaxrs-spec-quarkus-jspecify
steps:
diff --git a/bin/configs/jaxrs-spec-sealed-jsonb.yaml b/bin/configs/jaxrs-spec-sealed-jsonb.yaml
new file mode 100644
index 000000000000..67cec588d1aa
--- /dev/null
+++ b/bin/configs/jaxrs-spec-sealed-jsonb.yaml
@@ -0,0 +1,14 @@
+generatorName: jaxrs-spec
+outputDir: samples/server/petstore/jaxrs-spec-sealed-jsonb
+inputSpec: modules/openapi-generator/src/test/resources/3_0/jaxrs-spec/jsonb_polymorphism_containers.yaml
+templateDir: modules/openapi-generator/src/main/resources/JavaJaxRS/spec
+additionalProperties:
+ artifactId: jaxrs-spec-sealed-jsonb-petstore-server
+ serializationLibrary: jsonb
+ jsonbDiscriminatorDeserializers: "true"
+ useJakartaEe: "true"
+ useOneOfInterfaces: "true"
+ useSealed: "true"
+ generateBuilders: "true"
+ serializableModel: "true"
+ hideGenerationTimestamp: "true"
diff --git a/docs/generators/jaxrs-spec.md b/docs/generators/jaxrs-spec.md
index 40b06c03e6ec..a4c27c9ba6be 100644
--- a/docs/generators/jaxrs-spec.md
+++ b/docs/generators/jaxrs-spec.md
@@ -58,6 +58,7 @@ These options may be applied as additional-properties (cli) or configOptions (pl
|implicitHeadersRegex|Skip header parameters that matches given regex in the generated API methods using @ApiImplicitParams annotation. The match is case insensitive, like HTTP header names. Note: this parameter is ignored when implicitHeaders=true| |null|
|interfaceOnly|Whether to generate only API interface stubs without the server files.| |false|
|invokerPackage|root package for generated code| |org.openapitools.api|
+|jsonbDiscriminatorDeserializers|With 'serializationLibrary=jsonb' and 'useJakartaEe=true': generate JSON-B deserializers that resolve the concrete class of a model, also in list, set and map properties, from its discriminator mapping, and create concrete models with their discriminator values. With Yasson before 3.0.5, this does not cover root containers, such as a request body of type Map<String, Pet> (with Yasson 3.0.2 also List<Pet>). With Johnzon 2.0.2 and 2.2.0, reading a model fails when a required list, set or map property with elements of such models is absent from the JSON (an explicit null is read).| |false|
|legacyDiscriminatorBehavior|Set to false for generators with better support for discriminators. (Python, Java, Go, PowerShell, C# have this enabled by default).|
**true**
The mapping in the discriminator includes descendent schemas that allOf inherit from self and the discriminator mapping schemas in the OAS document.
**false**
The mapping in the discriminator includes any descendent schemas that allOf inherit from self, any oneOf schemas, any anyOf schemas, any x-discriminator-values, and the discriminator mapping schemas in the OAS document AND Codegen validates that oneOf and anyOf schemas contain the required discriminator and throws an error if the discriminator is missing.
|true|
|library|library template (sub-template)|
**<default>**
JAXRS spec only, to be deployed in an app server (TomEE, JBoss, WLS, ...)
**quarkus**
Server using Quarkus
**thorntail**
Server using Thorntail
**openliberty**
Server using Open Liberty
**helidon**
Server using Helidon
**kumuluzee**
Server using KumuluzEE
|<default>|
|licenseName|The name of the license| |Unlicense|
@@ -75,7 +76,7 @@ These options may be applied as additional-properties (cli) or configOptions (pl
|scmDeveloperConnection|SCM developer connection in generated pom.xml| |scm:git:git@github.com:openapitools/openapi-generator.git|
|scmUrl|SCM URL in generated pom.xml| |https://github.com/openapitools/openapi-generator|
|serializableModel|boolean - toggle "implements Serializable" for generated models| |false|
-|serializationLibrary|Serialization library used for the generated models. 'jsonb' is only supported by the default library (<default>). With 'jsonb', dateLibrary defaults to 'java8' ('java8-localdatetime' is also supported, 'joda' and 'legacy' are not), openApiNullable is disabled and no type annotations are generated for discriminator/oneOf polymorphism. Models with additionalProperties are generated as subclasses of HashMap without a JSON-B specific mapping, so they are (de)serialized as plain maps: declared properties are not written and are read into map entries instead of their fields. Properties with a null value are omitted, except required nullable properties, which are written as null; JsonbConfig.withNullValues(true) does not change this because the generated @JsonbProperty annotations default to nillable = false. Depending on the JSON-B implementation, enum values inside maps (and, with older implementations, inside lists) may not use the generated enum serializers/deserializers.|
**jsonb**
Use JSON-B as serialization library
**jackson**
Use Jackson as serialization library
|jackson|
+|serializationLibrary|Serialization library used for the generated models. 'jsonb' is only supported by the default library (<default>). With 'jsonb', dateLibrary defaults to 'java8' ('java8-localdatetime' is also supported, 'joda' and 'legacy' are not), openApiNullable is disabled and no type annotations are generated for discriminator/oneOf polymorphism (see jsonbDiscriminatorDeserializers). Models with additionalProperties are generated as subclasses of HashMap without a JSON-B specific mapping, so they are (de)serialized as plain maps: declared properties are not written and are read into map entries instead of their fields. Properties with a null value are omitted, except required nullable properties, which are written as null; JsonbConfig.withNullValues(true) does not change this because the generated @JsonbProperty annotations default to nillable = false. Depending on the JSON-B implementation, enum values inside maps (and, with older implementations, inside lists) may not use the generated enum serializers/deserializers.|
**jsonb**
Use JSON-B as serialization library
**jackson**
Use Jackson as serialization library
|jackson|
|serverPort|The port on which the server should be started| |8080|
|snapshotVersion|Uses a SNAPSHOT version.|
**true**
Use a SnapShot Version
**false**
Use a Release Version
|null|
|sortModelPropertiesByRequiredFlag|Sort model properties to place required parameters before optional parameters.| |true|
@@ -110,6 +111,7 @@ These options may be applied as additional-properties (cli) or configOptions (pl
|x-content-type|Specify custom value for 'Content-Type' header for operation|OPERATION|null
|x-class-extra-annotation|Custom annotation(s) to be added to model; accepts a string or list of strings|MODEL|null
|x-field-extra-annotation|Custom annotation(s) to be added to property; on an array `items` schema, generators that support element-type annotations add it to the element type instead (e.g. `List<@Foo T>`); accepts a string or list of strings|FIELD, OPERATION_PARAMETER|null
+|x-abstract|Generate the model class as `abstract`, with `protected` constructors and without `builder()` and JSON creator. Every discriminator value must resolve to a concrete class: an explicit mapping to an abstract model fails the generation, an implicit one is replaced by mappings to its concrete subclasses. With `useSealed`, an abstract model needs a generated subclass.|MODEL|false
## IMPORT MAPPING
diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/VendorExtension.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/VendorExtension.java
index c9f652d114f0..38c762cff4d7 100644
--- a/modules/openapi-generator/src/main/java/org/openapitools/codegen/VendorExtension.java
+++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/VendorExtension.java
@@ -17,6 +17,7 @@ public enum VendorExtension {
X_SPRING_API_VERSION("x-spring-api-version", ExtensionLevel.OPERATION, "Value for 'version' attribute in @RequestMapping (for Spring 7 and above).", null),
X_SPRING_PROVIDE_ARGS("x-spring-provide-args", ExtensionLevel.OPERATION, "Allows adding additional hidden parameters in the API specification to allow access to content such as header values or properties", "empty array"),
X_DISCRIMINATOR_VALUE("x-discriminator-value", ExtensionLevel.MODEL, "Used with model inheritance to specify value for discriminator that identifies current model", ""),
+ X_ABSTRACT("x-abstract", ExtensionLevel.MODEL, "Generate the model class as `abstract`, with `protected` constructors and without `builder()` and JSON creator. Every discriminator value must resolve to a concrete class: an explicit mapping to an abstract model fails the generation, an implicit one is replaced by mappings to its concrete subclasses. With `useSealed`, an abstract model needs a generated subclass.", "false"),
X_SETTER_EXTRA_ANNOTATION("x-setter-extra-annotation", ExtensionLevel.FIELD, "Custom annotation that can be specified over java setter for specific field", "When field is array & uniqueItems, then this extension is used to add `@JsonDeserialize(as = LinkedHashSet.class)` over setter, otherwise no value"),
X_WEBCLIENT_BLOCKING("x-webclient-blocking", ExtensionLevel.OPERATION, "Specifies if method for specific operation should be blocking or non-blocking(ex: return `Mono/Flux` or `return T/List/Set` & execute `.block()` inside generated method)", "false"),
X_WEBCLIENT_RETURN_EXCEPT_LIST_OF_STRING("x-webclient-return-except-list-of-string", ExtensionLevel.OPERATION, "Specifies if method for specific operation should return the type except List and Set(ex: return type expect the `Mono>/Flux>` and `Mono>/Flux>`)", "false"),
diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/JavaJAXRSCXFCDIServerCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/JavaJAXRSCXFCDIServerCodegen.java
index e2d04d021796..638a8be2d66c 100644
--- a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/JavaJAXRSCXFCDIServerCodegen.java
+++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/JavaJAXRSCXFCDIServerCodegen.java
@@ -21,6 +21,7 @@
import org.openapitools.codegen.CodegenModel;
import org.openapitools.codegen.CodegenProperty;
import org.openapitools.codegen.SupportingFile;
+import org.openapitools.codegen.VendorExtension;
import org.openapitools.codegen.languages.features.BeanValidationFeatures;
import org.openapitools.codegen.model.ModelMap;
import org.openapitools.codegen.model.OperationsMap;
@@ -69,6 +70,7 @@ public JavaJAXRSCXFCDIServerCodegen() {
removeOption(USE_JSPECIFY);
// JSON-B support lives in the JavaJaxRS/spec templates as well; cxf-cdi always uses Jackson.
removeOption(CodegenConstants.SERIALIZATION_LIBRARY);
+ removeOption(JavaJAXRSSpecServerCodegen.JSONB_DISCRIMINATOR_DESERIALIZERS);
}
@Override
@@ -76,6 +78,19 @@ public String getName() {
return "jaxrs-cxf-cdi";
}
+ @Override
+ public List getSupportedVendorExtensions() {
+ // x-abstract is implemented by the JavaJaxRS/spec templates only; cxf-cdi uses its own templates.
+ List extensions = super.getSupportedVendorExtensions();
+ extensions.remove(VendorExtension.X_ABSTRACT);
+ return extensions;
+ }
+
+ @Override
+ protected boolean supportsAbstractModels() {
+ return false;
+ }
+
@Override
public void processOpts() {
// Force jspecify off before super.processOpts(), which is where applyJspecify() runs.
@@ -85,6 +100,7 @@ public void processOpts() {
additionalProperties.remove(USE_JSPECIFY);
setUseJspecify(false);
additionalProperties.remove(CodegenConstants.SERIALIZATION_LIBRARY);
+ additionalProperties.remove(JavaJAXRSSpecServerCodegen.JSONB_DISCRIMINATOR_DESERIALIZERS);
super.processOpts();
diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/JavaJAXRSSpecServerCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/JavaJAXRSSpecServerCodegen.java
index 50ef12c57b77..7980ea6bba5f 100644
--- a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/JavaJAXRSSpecServerCodegen.java
+++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/JavaJAXRSSpecServerCodegen.java
@@ -30,14 +30,24 @@
import org.openapitools.codegen.model.ModelMap;
import org.openapitools.codegen.model.ModelsMap;
import org.openapitools.codegen.model.OperationsMap;
+import org.openapitools.codegen.utils.ModelUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
+import java.util.ArrayList;
import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
import static org.openapitools.codegen.CodegenConstants.INTERFACE_ONLY;
import static org.openapitools.codegen.CodegenConstants.INTERFACE_ONLY_DESC;
@@ -66,6 +76,7 @@ public class JavaJAXRSSpecServerCodegen extends AbstractJavaJAXRSServerCodegen {
public static final String USE_JAKARTA_SECURITY_ANNOTATIONS = "useJakartaSecurityAnnotations";
public static final String USE_ENUM_CASE_INSENSITIVE = "useEnumCaseInsensitive";
public static final String USE_SEALED = "useSealed";
+ public static final String JSONB_DISCRIMINATOR_DESERIALIZERS = "jsonbDiscriminatorDeserializers";
public static final String SERIALIZATION_LIBRARY_JACKSON = "jackson";
public static final String SERIALIZATION_LIBRARY_JSONB = "jsonb";
@@ -93,6 +104,9 @@ public class JavaJAXRSSpecServerCodegen extends AbstractJavaJAXRSServerCodegen {
@Setter
protected boolean useSealed = false;
+ @Getter @Setter
+ protected boolean jsonbDiscriminatorDeserializers = false;
+
private final JakartaSecurityAnnotationProcessor jakartaSecurityAnnotationProcessor = new JakartaSecurityAnnotationProcessor();
@Getter @Setter
@@ -178,7 +192,13 @@ public JavaJAXRSSpecServerCodegen() {
cliOptions.add(CliOption.newBoolean(GENERATE_JSON_CREATOR, "Whether to generate a JSON creator constructor for required properties.", generateJsonCreator));
cliOptions.add(CliOption.newBoolean(USE_ENUM_CASE_INSENSITIVE, "Use `equalsIgnoreCase` when String for enum comparison", useEnumCaseInsensitive));
cliOptions.add(CliOption.newBoolean(USE_SEALED, "Whether to generate sealed model interfaces and classes.", useSealed));
- CliOption serializationLibraryOption = new CliOption(CodegenConstants.SERIALIZATION_LIBRARY, "Serialization library used for the generated models. 'jsonb' is only supported by the default library (" + DEFAULT_LIBRARY + "). With 'jsonb', dateLibrary defaults to 'java8' ('java8-localdatetime' is also supported, 'joda' and 'legacy' are not), openApiNullable is disabled and no type annotations are generated for discriminator/oneOf polymorphism. Models with additionalProperties are generated as subclasses of HashMap without a JSON-B specific mapping, so they are (de)serialized as plain maps: declared properties are not written and are read into map entries instead of their fields. Properties with a null value are omitted, except required nullable properties, which are written as null; JsonbConfig.withNullValues(true) does not change this because the generated @JsonbProperty annotations default to nillable = false. Depending on the JSON-B implementation, enum values inside maps (and, with older implementations, inside lists) may not use the generated enum serializers/deserializers.")
+ cliOptions.add(CliOption.newBoolean(JSONB_DISCRIMINATOR_DESERIALIZERS, "With 'serializationLibrary=jsonb' and 'useJakartaEe=true': generate "
+ + "JSON-B deserializers that resolve the concrete class of a model, also in list, set and map properties, from its "
+ + "discriminator mapping, and create concrete models with their discriminator values. With Yasson before 3.0.5, "
+ + "this does not cover root containers, such as a request body of type Map (with Yasson 3.0.2 also "
+ + "List). With Johnzon 2.0.2 and 2.2.0, reading a model fails when a required list, set or map property "
+ + "with elements of such models is absent from the JSON (an explicit null is read).", jsonbDiscriminatorDeserializers));
+ CliOption serializationLibraryOption = new CliOption(CodegenConstants.SERIALIZATION_LIBRARY, "Serialization library used for the generated models. 'jsonb' is only supported by the default library (" + DEFAULT_LIBRARY + "). With 'jsonb', dateLibrary defaults to 'java8' ('java8-localdatetime' is also supported, 'joda' and 'legacy' are not), openApiNullable is disabled and no type annotations are generated for discriminator/oneOf polymorphism (see jsonbDiscriminatorDeserializers). Models with additionalProperties are generated as subclasses of HashMap without a JSON-B specific mapping, so they are (de)serialized as plain maps: declared properties are not written and are read into map entries instead of their fields. Properties with a null value are omitted, except required nullable properties, which are written as null; JsonbConfig.withNullValues(true) does not change this because the generated @JsonbProperty annotations default to nillable = false. Depending on the JSON-B implementation, enum values inside maps (and, with older implementations, inside lists) may not use the generated enum serializers/deserializers.")
.defaultValue(SERIALIZATION_LIBRARY_JACKSON);
Map serializationOptions = new HashMap<>();
serializationOptions.put(SERIALIZATION_LIBRARY_JACKSON, "Use Jackson as serialization library");
@@ -231,6 +251,7 @@ public void processOpts() {
convertPropertyToBooleanAndWriteBack(GENERATE_JSON_CREATOR, this::setGenerateJsonCreator);
convertPropertyToBooleanAndWriteBack(USE_ENUM_CASE_INSENSITIVE, this::setUseEnumCaseInsensitive);
convertPropertyToBooleanAndWriteBack(USE_SEALED, this::setUseSealed);
+ convertPropertyToBooleanAndWriteBack(JSONB_DISCRIMINATOR_DESERIALIZERS, this::setJsonbDiscriminatorDeserializers);
if (additionalProperties.containsKey(OPEN_API_SPEC_FILE_LOCATION)) {
openApiSpecFileLocation = additionalProperties.get(OPEN_API_SPEC_FILE_LOCATION).toString();
@@ -270,6 +291,15 @@ public void processOpts() {
if (isJsonb()) {
applyJsonbSerialization();
}
+ if (jsonbDiscriminatorDeserializers && !isJsonb()) {
+ LOGGER.warn("'{}' only applies to '{}={}' and is ignored.", JSONB_DISCRIMINATOR_DESERIALIZERS, CodegenConstants.SERIALIZATION_LIBRARY, SERIALIZATION_LIBRARY_JSONB);
+ jsonbDiscriminatorDeserializers = false;
+ additionalProperties.put(JSONB_DISCRIMINATOR_DESERIALIZERS, false);
+ }
+ if (jsonbDiscriminatorDeserializers && !useJakartaEe) {
+ throw new IllegalArgumentException("'" + JSONB_DISCRIMINATOR_DESERIALIZERS + "=true' requires '" + USE_JAKARTA_EE
+ + "=true': the generated deserializers use the Jakarta JSON-B 3.0 API (jakarta.json.bind).");
+ }
// expose flags to templates
additionalProperties.put(USE_SWAGGER_ANNOTATIONS, useSwaggerAnnotations);
@@ -366,6 +396,13 @@ public String getName() {
return "jaxrs-spec";
}
+ @Override
+ public List getSupportedVendorExtensions() {
+ List extensions = super.getSupportedVendorExtensions();
+ extensions.add(VendorExtension.X_ABSTRACT);
+ return extensions;
+ }
+
public String getSerializationLibrary() {
return serializationLibrary;
}
@@ -492,6 +529,9 @@ public OperationsMap postProcessOperationsWithModels(OperationsMap objs, List postProcessAllModels(Map objs) {
Map result = super.postProcessAllModels(objs);
+ List allModels = new ArrayList<>();
+ result.values().forEach(modelsMap -> modelsMap.getModels().forEach(modelMap -> allModels.add(modelMap.getModel())));
+ List abstractModels = supportsAbstractModels() ? applyAbstractModels(allModels) : Collections.emptyList();
// Index the discriminators of the generated oneOf interfaces by classname. A child of a oneOf
// interface (useOneOfInterfaces) inherits a shared base via allOf and therefore has no Java
@@ -500,8 +540,7 @@ public Map postProcessAllModels(Map objs)
for (ModelsMap modelsMap : result.values()) {
for (ModelMap modelMap : modelsMap.getModels()) {
CodegenModel model = modelMap.getModel();
- if (Boolean.TRUE.equals(model.getVendorExtensions().get("x-is-one-of-interface"))
- && model.getDiscriminator() != null) {
+ if (isOneOfInterface(model) && model.getDiscriminator() != null) {
oneOfInterfaceDiscriminators.put(model.classname, model.getDiscriminator());
}
}
@@ -515,26 +554,275 @@ public Map postProcessAllModels(Map objs)
CodegenDiscriminator discriminator = model.parentModel != null
? model.parentModel.getDiscriminator()
: discriminatorOfImplementedOneOfInterface(model, oneOfInterfaceDiscriminators);
- if (discriminator != null) {
- for (CodegenDiscriminator.MappedModel mappedModel : discriminator.getMappedModels()) {
- if (mappedModel.getSchemaName().equals(model.schemaName)) {
- model.getVendorExtensions().put("x-discriminator-value", mappedModel.getMappingName());
- break;
- }
- }
+ String discriminatorValue = mappingNameOf(discriminator, model);
+ if (discriminatorValue == null) {
+ // a grandchild may be mapped by the discriminator of a more distant ancestor; without it Jackson
+ // would write the class name as type id
+ discriminatorValue = ancestorMappingNameOf(model);
+ }
+ if (discriminatorValue != null) {
+ model.getVendorExtensions().put("x-discriminator-value", discriminatorValue);
}
// A oneOf container rendered as a plain class (useOneOfInterfaces disabled or the model
// not selected for interface generation) must not be sealed over its oneOf members: they
// do not extend it, so a permits clause would not compile. Only child-derived permits
// (subclasses that actually extend the model) may remain.
- if (useSealed && !Boolean.TRUE.equals(model.getVendorExtensions().get("x-is-one-of-interface"))) {
+ if (useSealed && !isOneOfInterface(model)) {
model.permits.removeAll(model.oneOf);
}
}
}
+ validateAbstractModelsHaveSubclasses(allModels, abstractModels);
+ if (jsonbDiscriminatorDeserializers) {
+ new JsonbPolymorphismProcessor(this, allModels).apply();
+ }
return result;
}
+ /**
+ * Whether this generator's templates implement the {@code x-abstract} vendor extension.
+ */
+ protected boolean supportsAbstractModels() {
+ return true;
+ }
+
+ /**
+ * Normalizes {@code x-abstract} to a {@link Boolean} (a string {@code "false"} would be truthy in the templates) and
+ * ensures that no discriminator value resolves to an abstract class, which neither Jackson nor JSON-B can
+ * instantiate: an explicit mapping (a {@code mapping} entry or {@code x-discriminator-value}) to an abstract model
+ * fails the generation, an implicit one is replaced by mappings to its concrete subclasses. Every copy of a
+ * discriminator is checked, since with {@code legacyDiscriminatorBehavior=false} children inherit their parent's.
+ *
+ * @return the models marked abstract
+ */
+ private List applyAbstractModels(List allModels) {
+ String xAbstract = VendorExtension.X_ABSTRACT.getName();
+ Map abstractModelsBySchemaName = new HashMap<>();
+ for (CodegenModel model : allModels) {
+ Object value = model.getVendorExtensions().get(xAbstract);
+ if (value == null) {
+ continue;
+ }
+ boolean isAbstract = Boolean.parseBoolean(String.valueOf(value));
+ if (isAbstract && (model.isEnum || isOneOfInterface(model))) {
+ LOGGER.warn("Ignoring '{}' on model '{}': only model classes can be abstract.", xAbstract, model.name);
+ isAbstract = false;
+ }
+ model.getVendorExtensions().put(xAbstract, isAbstract);
+ if (isAbstract) {
+ abstractModelsBySchemaName.put(model.schemaName, model);
+ }
+ }
+ if (abstractModelsBySchemaName.isEmpty()) {
+ return Collections.emptyList();
+ }
+
+ // Visit the models that declare a discriminator before those that inherit a copy of it, so that an
+ // error names the schema where the offending mapping is written.
+ List discriminatorOwners = allModels.stream()
+ .filter(model -> model.getDiscriminator() != null && model.getDiscriminator().getMappedModels() != null)
+ .sorted(Comparator.comparing(model -> declaresDiscriminator(model) ? 0 : 1))
+ .collect(Collectors.toList());
+ for (CodegenModel owner : discriminatorOwners) {
+ CodegenDiscriminator discriminator = owner.getDiscriminator();
+ List droppedAbstractModels = new ArrayList<>();
+ Iterator mappedModels = discriminator.getMappedModels().iterator();
+ while (mappedModels.hasNext()) {
+ CodegenDiscriminator.MappedModel mappedModel = mappedModels.next();
+ CodegenModel target = abstractModelsBySchemaName.get(mappedModel.getSchemaName());
+ if (target == null) {
+ continue;
+ }
+ if (mappedModel.isExplicitMapping()) {
+ throw new IllegalArgumentException(String.format(Locale.ROOT,
+ "The discriminator value '%s' of property '%s' in model '%s' maps to model '%s', which is marked '%s'. "
+ + "An abstract class cannot be instantiated: map each discriminator value directly to a concrete "
+ + "subclass, or remove '%s'.",
+ mappedModel.getMappingName(), discriminator.getPropertyBaseName(), owner.name, target.name, xAbstract, xAbstract));
+ }
+ LOGGER.info("Dropping the implicit discriminator mapping '{}' of model '{}': model '{}' is marked '{}'.",
+ mappedModel.getMappingName(), owner.name, target.name, xAbstract);
+ mappedModels.remove();
+ droppedAbstractModels.add(target);
+ }
+ for (CodegenModel droppedAbstractModel : droppedAbstractModels) {
+ mapConcreteDescendants(owner, droppedAbstractModel, allModels);
+ }
+ }
+ return new ArrayList<>(abstractModelsBySchemaName.values());
+ }
+
+ /**
+ * Replaces a dropped implicit mapping to an abstract model by mappings to the concrete classes that extend it, under
+ * every value that Jackson would resolve them by transitively through the abstract model. Without this, a concrete
+ * descendant of an abstract oneOf member could not be read through the oneOf interface. The Java hierarchy and the
+ * {@code permits} clauses stay unchanged.
+ */
+ private void mapConcreteDescendants(CodegenModel owner, CodegenModel abstractModel, List allModels) {
+ CodegenDiscriminator discriminator = owner.getDiscriminator();
+ for (CodegenModel descendant : allModels) {
+ if (isAbstract(descendant) || !extendsModel(descendant, abstractModel)) {
+ continue;
+ }
+ for (String mappingName : transitiveMappingNamesOf(descendant, abstractModel)) {
+ Optional existing = discriminator.getMappedModels().stream()
+ .filter(mappedModel -> mappingName.equals(mappedModel.getMappingName()))
+ .findFirst();
+ if (existing.isPresent()) {
+ if (descendant.schemaName.equals(existing.get().getSchemaName())) {
+ continue;
+ }
+ throw new IllegalArgumentException(String.format(Locale.ROOT,
+ "The discriminator value '%s' of property '%s' in model '%s' would map to both model '%s' and model '%s' "
+ + "(a concrete subclass of the '%s' model '%s'). Give the models distinct discriminator values.",
+ mappingName, discriminator.getPropertyBaseName(), owner.name, existing.get().getModelName(), descendant.name,
+ VendorExtension.X_ABSTRACT.getName(), abstractModel.name));
+ }
+ // only a value that is not mapped yet must be dispatchable by the owner's discriminator property
+ validateSameDiscriminatorProperty(owner, abstractModel, descendant);
+ CodegenDiscriminator.MappedModel mappedModel =
+ new CodegenDiscriminator.MappedModel(mappingName, descendant.classname, descendant.schemaName, false);
+ mappedModel.setModel(descendant);
+ discriminator.getMappedModels().add(mappedModel);
+ LOGGER.info("Mapping the discriminator value '{}' of model '{}' to model '{}', a concrete subclass of the '{}' model '{}'.",
+ mappingName, owner.name, descendant.name, VendorExtension.X_ABSTRACT.getName(), abstractModel.name);
+ }
+ }
+ }
+
+ /**
+ * The values that Jackson resolves the descendant by through the abstract model: its own type name and every value
+ * that a model on the inheritance path up to the abstract model maps to it.
+ */
+ private static Set transitiveMappingNamesOf(CodegenModel descendant, CodegenModel abstractModel) {
+ Set mappingNames = new LinkedHashSet<>();
+ mappingNames.add(Objects.requireNonNullElse(ancestorMappingNameOf(descendant), descendant.schemaName));
+ for (CodegenModel ancestor = descendant.parentModel; ancestor != null; ancestor = ancestor.parentModel) {
+ CodegenDiscriminator ancestorDiscriminator = ancestor.getDiscriminator();
+ if (ancestorDiscriminator != null && ancestorDiscriminator.getMappedModels() != null) {
+ ancestorDiscriminator.getMappedModels().stream()
+ .filter(mappedModel -> descendant.schemaName.equals(mappedModel.getSchemaName()))
+ .forEach(mappedModel -> mappingNames.add(mappedModel.getMappingName()));
+ }
+ if (ancestor.classname.equals(abstractModel.classname)) {
+ break;
+ }
+ }
+ return mappingNames;
+ }
+
+ /**
+ * Multi-level discriminators are not supported here: every model on the inheritance path from the descendant up to
+ * the abstract model must dispatch by the owner's discriminator property (the abstract model must have a
+ * discriminator, intermediate models may have none), otherwise the owner cannot dispatch on the descendant's type id.
+ */
+ private static void validateSameDiscriminatorProperty(CodegenModel owner, CodegenModel abstractModel, CodegenModel descendant) {
+ String property = owner.getDiscriminator().getPropertyBaseName();
+ for (CodegenModel ancestor = descendant.parentModel; ancestor != null; ancestor = ancestor.parentModel) {
+ boolean isAbstractModel = ancestor.classname.equals(abstractModel.classname);
+ CodegenDiscriminator ancestorDiscriminator = ancestor.getDiscriminator();
+ if ((ancestorDiscriminator == null && isAbstractModel)
+ || (ancestorDiscriminator != null && !Objects.equals(ancestorDiscriminator.getPropertyBaseName(), property))) {
+ throw new IllegalArgumentException(String.format(Locale.ROOT,
+ "Model '%s' extends model '%s', which is marked '%s' and is implicitly mapped by the discriminator "
+ + "property '%s' of model '%s'. Model '%s' on this inheritance path resolves its subclasses by %s, "
+ + "so model '%s' cannot be mapped by '%s' instead: use the same discriminator property on every "
+ + "level or map the values of '%s' explicitly to concrete classes.",
+ descendant.name, abstractModel.name, VendorExtension.X_ABSTRACT.getName(), property, owner.name, ancestor.name,
+ ancestorDiscriminator == null
+ ? "no discriminator"
+ : "the discriminator property '" + ancestorDiscriminator.getPropertyBaseName() + "'",
+ descendant.name, property, owner.name));
+ }
+ if (isAbstractModel) {
+ return;
+ }
+ }
+ }
+
+ private static boolean extendsModel(CodegenModel model, CodegenModel ancestor) {
+ for (CodegenModel parent = model.parentModel; parent != null; parent = parent.parentModel) {
+ if (parent.classname.equals(ancestor.classname)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ static boolean isAbstract(CodegenModel model) {
+ return Boolean.TRUE.equals(model.getVendorExtensions().get(VendorExtension.X_ABSTRACT.getName()));
+ }
+
+ static boolean isOneOfInterface(CodegenModel model) {
+ return Boolean.TRUE.equals(model.getVendorExtensions().get(CodegenConstants.X_IS_ONE_OF_INTERFACE));
+ }
+
+ /**
+ * An abstract model without generated subclasses could only be extended by hand-written code. Under
+ * {@code useSealed} that subclass would have to be {@code non-sealed}, which reopens the sealed hierarchy, so such a
+ * model is rejected there.
+ */
+ private void validateAbstractModelsHaveSubclasses(List allModels, List abstractModels) {
+ if (abstractModels.isEmpty()) {
+ return;
+ }
+ String xAbstract = VendorExtension.X_ABSTRACT.getName();
+ Set extendedClassnames = allModels.stream()
+ .map(CodegenModel::getParent)
+ .filter(Objects::nonNull)
+ .collect(Collectors.toSet());
+ for (CodegenModel model : abstractModels) {
+ if (extendedClassnames.contains(model.classname)) {
+ continue;
+ }
+ Optional sealedSupertype = useSealed
+ ? allModels.stream().filter(candidate -> candidate.permits.contains(model.classname)).findFirst()
+ : Optional.empty();
+ if (sealedSupertype.isPresent()) {
+ throw new IllegalArgumentException(String.format(Locale.ROOT,
+ "Model '%s' is marked '%s' and is a permitted subtype of the sealed type '%s', but no generated model "
+ + "extends it. With '%s=true' it could only be declared non-sealed, which would reopen the sealed "
+ + "hierarchy. Remove '%s' or add a subclass to the specification.",
+ model.name, xAbstract, sealedSupertype.get().classname, USE_SEALED, xAbstract));
+ }
+ LOGGER.warn("Model '{}' is marked '{}', but no generated model extends it.", model.name, xAbstract);
+ }
+ }
+
+ /**
+ * Returns the discriminator value that the given discriminator maps to the model, or {@code null}.
+ */
+ private static String mappingNameOf(CodegenDiscriminator discriminator, CodegenModel model) {
+ if (discriminator == null || discriminator.getMappedModels() == null) {
+ return null;
+ }
+ for (CodegenDiscriminator.MappedModel mappedModel : discriminator.getMappedModels()) {
+ if (model.schemaName.equals(mappedModel.getSchemaName())) {
+ return mappedModel.getMappingName();
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Returns the discriminator value that the nearest ancestor whose discriminator maps the model assigns to it, or
+ * {@code null}.
+ */
+ private static String ancestorMappingNameOf(CodegenModel model) {
+ for (CodegenModel ancestor = model.parentModel; ancestor != null; ancestor = ancestor.parentModel) {
+ String mappingName = mappingNameOf(ancestor.getDiscriminator(), model);
+ if (mappingName != null) {
+ return mappingName;
+ }
+ }
+ return null;
+ }
+
+ private boolean declaresDiscriminator(CodegenModel model) {
+ Schema schema = ModelUtils.getSchema(openAPI, model.schemaName);
+ return schema != null && schema.getDiscriminator() != null;
+ }
+
/**
* Returns the discriminator of the oneOf interface (produced by useOneOfInterfaces) that the given
* model implements, or {@code null} if the model does not implement such an interface. The interface
diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/JsonbPolymorphismProcessor.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/JsonbPolymorphismProcessor.java
new file mode 100644
index 000000000000..8774913c09a3
--- /dev/null
+++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/JsonbPolymorphismProcessor.java
@@ -0,0 +1,419 @@
+/*
+ * Copyright 2026 OpenAPI-Generator Contributors (https://openapi-generator.tech)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.openapitools.codegen.languages;
+
+import org.openapitools.codegen.CodegenDiscriminator;
+import org.openapitools.codegen.CodegenModel;
+import org.openapitools.codegen.CodegenProperty;
+import org.openapitools.codegen.DefaultCodegen;
+import org.openapitools.codegen.VendorExtension;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.stream.Collectors;
+
+import static org.openapitools.codegen.languages.JavaJAXRSSpecServerCodegen.isAbstract;
+import static org.openapitools.codegen.languages.JavaJAXRSSpecServerCodegen.isOneOfInterface;
+
+/**
+ * Prepares the vendor extensions of the {@code jsonbDiscriminatorDeserializers} option: a JSON-B deserializer for every model whose
+ * discriminator maps subtypes (see {@code jsonbPolymorphicDeserializer.mustache}), and the discriminator values that
+ * concrete models are created with.
+ *
+ * JSON-B 3.0 {@code @JsonbTypeInfo} is not used: it requires the type key not to be a property of the class, but the
+ * generated models declare the discriminator as a property (Yasson fails to serialize such a model, Johnzon rejects it).
+ *
+ * The dispatch table of a model is the part of its discriminator mapping that targets the model itself or a subtype;
+ * with {@code legacyDiscriminatorBehavior=false} a child carries a copy of its parent's mapping, which also lists
+ * siblings and ancestors. A concrete model that no value maps to itself is also resolved under its Jackson type name.
+ * Each value is resolved by the deserializer of its target if it has one, otherwise by binding the target directly;
+ * the model itself is bound through a transfer object, which avoids recursing into its own deserializer.
+ */
+final class JsonbPolymorphismProcessor {
+
+ private final Logger LOGGER = LoggerFactory.getLogger(JsonbPolymorphismProcessor.class);
+
+ private final DefaultCodegen codegen;
+ private final List allModels;
+ // keyed by classname: CodegenModel#hashCode is deep and recurses through parent models
+ private final Map byClassname = new HashMap<>();
+ private final Map dispatchTables = new LinkedHashMap<>();
+
+ JsonbPolymorphismProcessor(DefaultCodegen codegen, List allModels) {
+ this.codegen = codegen;
+ this.allModels = allModels;
+ allModels.forEach(model -> byClassname.put(model.classname, model));
+ }
+
+ void apply() {
+ for (CodegenModel model : allModels) {
+ DispatchTable table = dispatchTableOf(model);
+ if (table != null) {
+ dispatchTables.put(model.classname, table);
+ }
+ }
+ // the helper classes are nested in the models and shadow equally named types in them and in their subclasses
+ Set usedTypeNames = usedTypeNames();
+ String deserializerName = uniqueTypeName("JsonbPolymorphicDeserializer", usedTypeNames);
+ usedTypeNames.add(deserializerName);
+ String dataName = uniqueTypeName("JsonbData", usedTypeNames);
+ usedTypeNames.add(dataName);
+ String containerDeserializerName = uniqueTypeName("JsonbPolymorphicContainerDeserializer", usedTypeNames);
+ dispatchTables.forEach((classname, table) -> applyDeserializer(byClassname.get(classname), table, deserializerName, dataName));
+ applyContainerDeserializers(containerDeserializerName);
+ applyDiscriminatorDefaults();
+ }
+
+ /**
+ * Gives every list, set or map property (also a nested one) whose elements are of a model with a deserializer the
+ * container deserializer of that model ({@code jsonbPolymorphicContainerDeserializer.mustache}): Yasson up to 3.0.4
+ * does not apply the class-level deserializer to the elements of some containers (fixed in 3.0.5).
+ */
+ private void applyContainerDeserializers(String name) {
+ for (CodegenModel model : allModels) {
+ // the lists the templates annotate, which hold separate instances of a property: vars (setters), requiredVars
+ // (creator parameters, also inherited ones) and allVars (fields of the transfer object JsonbData)
+ for (List vars : Arrays.asList(model.vars, model.requiredVars, model.allVars)) {
+ for (CodegenProperty var : vars) {
+ CodegenProperty element = var;
+ while (element.items != null) {
+ element = element.items;
+ }
+ if (var.isContainer && element.complexType != null && dispatchTables.containsKey(element.complexType)) {
+ byClassname.get(element.complexType).getVendorExtensions().put("x-jsonb-container-deserializer-name", name);
+ var.getVendorExtensions().put("x-jsonb-container-deserializer", qualifiedModelName(element.complexType) + "." + name);
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * The dispatch table of the model, or {@code null} if it does not map a subtype. An intermediate class without a
+ * discriminator of its own ({@code legacyDiscriminatorBehavior=true}) dispatches by that of its nearest ancestor, like
+ * Jackson does through the inherited {@code @JsonTypeInfo}.
+ */
+ private DispatchTable dispatchTableOf(CodegenModel model) {
+ CodegenDiscriminator discriminator = model.getDiscriminator();
+ for (CodegenModel ancestor = model.parentModel; discriminator == null && ancestor != null; ancestor = ancestor.parentModel) {
+ discriminator = ancestor.getDiscriminator();
+ }
+ if (model.isEnum || discriminator == null || discriminator.getMappedModels() == null) {
+ return null;
+ }
+ List mappings = discriminator.getMappedModels().stream()
+ .filter(mappedModel -> {
+ CodegenModel target = byClassname.get(mappedModel.getModelName());
+ return target != null && isAssignableTo(target, model);
+ })
+ .collect(Collectors.toList());
+ if (mappings.stream().allMatch(mappedModel -> mappedModel.getModelName().equals(model.classname))) {
+ return null;
+ }
+ boolean mapsItself = mappings.stream().anyMatch(mappedModel -> mappedModel.getModelName().equals(model.classname));
+ if (mapsItself && model.getAdditionalProperties() != null) {
+ LOGGER.warn("No JSON-B deserializer is generated for model '{}': it declares additionalProperties and maps a discriminator "
+ + "value to itself, which '{}' cannot bind.", model.name, JavaJAXRSSpecServerCodegen.JSONB_DISCRIMINATOR_DESERIALIZERS);
+ return null;
+ }
+ CodegenDiscriminator.MappedModel implicitSelf = null;
+ if (!mapsItself && model.getAdditionalProperties() == null && !isAbstract(model) && !isOneOfInterface(model)) {
+ implicitSelf = implicitSelfMapping(model, mappings);
+ if (implicitSelf != null) {
+ mappings.add(implicitSelf);
+ }
+ }
+ return new DispatchTable(discriminator.getPropertyBaseName(), mappings, implicitSelf);
+ }
+
+ /**
+ * The mapping of a concrete model to itself under its Jackson type name, or {@code null} if that name maps a subtype.
+ */
+ private CodegenDiscriminator.MappedModel implicitSelfMapping(CodegenModel model, List mappings) {
+ Object discriminatorValue = model.getVendorExtensions().get(VendorExtension.X_DISCRIMINATOR_VALUE.getName());
+ String typeName = discriminatorValue != null ? String.valueOf(discriminatorValue) : model.name;
+ if (mappings.stream().anyMatch(mappedModel -> mappedModel.getMappingName().equals(typeName))) {
+ LOGGER.warn("Model '{}' is not resolved as itself by its JSON-B deserializer: its type name '{}' is mapped to another model.",
+ model.name, typeName);
+ return null;
+ }
+ return new CodegenDiscriminator.MappedModel(typeName, model.classname, model.schemaName, false);
+ }
+
+ private void applyDeserializer(CodegenModel model, DispatchTable table, String deserializerName, String dataName) {
+ List> subtypes = new ArrayList<>();
+ boolean mapsItself = false;
+ for (CodegenDiscriminator.MappedModel mappedModel : table.mappings) {
+ String targetClassname = mappedModel.getModelName();
+ boolean self = targetClassname.equals(model.classname);
+ DispatchTable targetTable = self ? null : dispatchTables.get(targetClassname);
+ // a target that resolves its subclasses by another property is itself if that property has no value
+ boolean selfIfMissing = targetTable != null && !table.property.equals(targetTable.property) && targetTable.mapsItself(targetClassname);
+ if (selfIfMissing) {
+ byClassname.get(targetClassname).getVendorExtensions().put("x-jsonb-self-if-missing", true);
+ }
+ mapsItself |= self;
+ Map subtype = new HashMap<>();
+ subtype.put("jsonbValue", codegen.escapeText(mappedModel.getMappingName()));
+ subtype.put("jsonbType", qualifiedModelName(targetClassname));
+ subtype.put("jsonbSelf", self);
+ subtype.put("jsonbDelegate", targetTable != null);
+ subtype.put("jsonbSelfIfMissing", selfIfMissing);
+ subtype.put("jsonbBind", !self && targetTable == null);
+ subtypes.add(subtype);
+ }
+ Map vendorExtensions = model.getVendorExtensions();
+ vendorExtensions.put("x-jsonb-polymorphic", true);
+ vendorExtensions.put("x-jsonb-deserializer-name", deserializerName);
+ vendorExtensions.put("x-jsonb-data-name", dataName);
+ vendorExtensions.put("x-jsonb-discriminator-property", codegen.escapeText(table.property));
+ vendorExtensions.put("x-jsonb-self", mapsItself);
+ vendorExtensions.put("x-jsonb-subtypes", subtypes);
+ }
+
+ /**
+ * Sets the discriminator values of every concrete model. The constructor and the builder of a concrete ancestor run
+ * first, so a value that an ancestor sets and the model does not (for example an ambiguous one) is reset to null.
+ */
+ private void applyDiscriminatorDefaults() {
+ Map>> ownDefaults = new HashMap<>();
+ for (CodegenModel model : allModels) {
+ if (!model.isEnum && !isAbstract(model) && !isOneOfInterface(model)) {
+ ownDefaults.put(model.classname, discriminatorDefaults(model));
+ }
+ }
+ ownDefaults.forEach((classname, own) -> {
+ CodegenModel model = byClassname.get(classname);
+ List> defaults = new ArrayList<>(own);
+ Set properties = own.stream().map(entry -> (String) entry.get("jsonbDefaultProperty")).collect(Collectors.toSet());
+ for (CodegenModel ancestor = model.parentModel; ancestor != null; ancestor = ancestor.parentModel) {
+ for (Map inherited : ownDefaults.getOrDefault(ancestor.classname, Collections.emptyList())) {
+ if (properties.add((String) inherited.get("jsonbDefaultProperty"))) {
+ Map reset = new HashMap<>(inherited);
+ reset.put("jsonbDefaultValue", "null");
+ defaults.add(reset);
+ }
+ }
+ }
+ if (!defaults.isEmpty()) {
+ model.getVendorExtensions().put("x-jsonb-discriminator-defaults", defaults);
+ }
+ });
+ }
+
+ /**
+ * The discriminator values of a concrete model, one per discriminator property of the model and its supertypes, in
+ * this order of preference: the value an explicit mapping assigns to the model; the value that maps to the nearest
+ * ancestor that resolves its subclasses by another property (for example {@code kind=CAR} for a subclass of
+ * {@code Car}, which is resolved by {@code carType}); the value an implicit mapping assigns to the model. A property
+ * whose preferred values are ambiguous gets no default.
+ */
+ private List> discriminatorDefaults(CodegenModel model) {
+ Map> mappingsByProperty = new LinkedHashMap<>();
+ for (CodegenModel supertype : allModels) {
+ CodegenDiscriminator discriminator = supertype.getDiscriminator();
+ if (discriminator != null && discriminator.getMappedModels() != null && isAssignableTo(model, supertype)) {
+ mappingsByProperty.computeIfAbsent(discriminator.getPropertyBaseName(), property -> new ArrayList<>())
+ .addAll(discriminator.getMappedModels());
+ }
+ }
+ DispatchTable ownTable = dispatchTables.get(model.classname);
+ if (ownTable != null && ownTable.implicitSelf != null) {
+ mappingsByProperty.computeIfAbsent(ownTable.property, property -> new ArrayList<>()).add(ownTable.implicitSelf);
+ }
+
+ List> defaults = new ArrayList<>();
+ mappingsByProperty.forEach((property, mappings) -> {
+ Set values = mappingNames(mappings, model.classname, true);
+ for (CodegenModel ancestor = model.parentModel; values.isEmpty() && ancestor != null; ancestor = ancestor.parentModel) {
+ DispatchTable ancestorTable = dispatchTables.get(ancestor.classname);
+ if (ancestorTable != null && !property.equals(ancestorTable.property)) {
+ values = mappingNames(mappings, ancestor.classname, true);
+ if (values.isEmpty()) {
+ values = mappingNames(mappings, ancestor.classname, false);
+ }
+ }
+ }
+ if (values.isEmpty()) {
+ values = mappingNames(mappings, model.classname, false);
+ }
+ if (values.isEmpty()) {
+ return;
+ }
+ if (values.size() > 1) {
+ LOGGER.warn("Model '{}' is created without a value of its discriminator property '{}': the discriminator mappings assign "
+ + "it several values {}.", model.name, property, values);
+ return;
+ }
+ String value = values.iterator().next();
+ CodegenProperty var = model.allVars.stream().filter(candidate -> property.equals(candidate.baseName)).findFirst().orElse(null);
+ String expression = var == null ? null : discriminatorValueExpression(model, var, value);
+ if (expression == null) {
+ LOGGER.warn("Model '{}' is created without a value of its discriminator property '{}': '{}' cannot be assigned to it.",
+ model.name, property, value);
+ return;
+ }
+ Map discriminatorDefault = new HashMap<>();
+ discriminatorDefault.put("jsonbDefaultProperty", property);
+ discriminatorDefault.put("jsonbDefaultSetter", var.setter);
+ discriminatorDefault.put("jsonbDefaultBuilderMethod", var.name);
+ discriminatorDefault.put("jsonbDefaultValue", expression);
+ defaults.add(discriminatorDefault);
+ });
+ return defaults;
+ }
+
+ private static Set mappingNames(List mappings, String classname, boolean explicit) {
+ return mappings.stream()
+ .filter(mappedModel -> mappedModel.getModelName().equals(classname) && mappedModel.isExplicitMapping() == explicit)
+ .map(CodegenDiscriminator.MappedModel::getMappingName)
+ .collect(Collectors.toCollection(TreeSet::new));
+ }
+
+ /**
+ * A string literal or the fully qualified constant of an inline or referenced enum, or {@code null} if the value is no
+ * constant of the enum or the Java type is neither {@code String} nor an enum (a string of format uri is a {@code URI}).
+ */
+ private String discriminatorValueExpression(CodegenModel model, CodegenProperty property, String value) {
+ if (property.isEnum) {
+ // an inline enum is nested in the model that declares the property
+ CodegenModel declaringModel = model;
+ for (CodegenModel ancestor = model; ancestor != null; ancestor = ancestor.parentModel) {
+ if (ancestor.vars.stream().anyMatch(var -> property.baseName.equals(var.baseName))) {
+ declaringModel = ancestor;
+ break;
+ }
+ }
+ String constant = enumConstant(property.allowableValues, value, property.dataType);
+ return constant == null ? null : qualifiedModelName(declaringModel.classname) + "." + property.datatypeWithEnum + "." + constant;
+ }
+ if (property.isEnumRef) {
+ CodegenModel enumModel = byClassname.get(property.dataType);
+ String constant = enumModel == null ? null : enumConstant(enumModel.allowableValues, value, enumModel.dataType);
+ return constant == null ? null : qualifiedModelName(enumModel.classname) + "." + constant;
+ }
+ if ("String".equals(property.dataType) || "java.lang.String".equals(property.dataType)) {
+ return "\"" + codegen.escapeText(value) + "\"";
+ }
+ return null;
+ }
+
+ @SuppressWarnings("unchecked")
+ private String enumConstant(Map allowableValues, String value, String dataType) {
+ Object enumVars = allowableValues == null ? null : allowableValues.get("enumVars");
+ if (!(enumVars instanceof List)) {
+ return null;
+ }
+ String literal = codegen.toEnumValue(value, dataType);
+ for (Map enumVar : (List>) enumVars) {
+ if (literal.equals(String.valueOf(enumVar.get("value")))) {
+ return String.valueOf(enumVar.get("name"));
+ }
+ }
+ return null;
+ }
+
+ private String qualifiedModelName(String classname) {
+ return codegen.modelPackage() + "." + classname;
+ }
+
+ /**
+ * The simple type names that the models use: their class names, imports and the types of their properties.
+ */
+ private Set usedTypeNames() {
+ Set names = new HashSet<>();
+ for (CodegenModel model : allModels) {
+ names.add(model.classname);
+ model.imports.forEach(name -> names.add(name.substring(name.lastIndexOf('.') + 1)));
+ for (List vars : Arrays.asList(model.vars, model.allVars)) {
+ for (CodegenProperty var : vars) {
+ for (String type : Arrays.asList(var.datatypeWithEnum, var.dataType, var.baseType, var.complexType)) {
+ if (type != null) {
+ names.addAll(Arrays.asList(type.split("[^\\p{javaJavaIdentifierPart}]+")));
+ }
+ }
+ }
+ }
+ }
+ return names;
+ }
+
+ private static String uniqueTypeName(String name, Set usedTypeNames) {
+ String unique = name;
+ for (int i = 2; usedTypeNames.contains(unique); i++) {
+ unique = name + i;
+ }
+ return unique;
+ }
+
+ /**
+ * Whether instances of {@code target} are instances of {@code type}: the model itself, a subclass, or a class or
+ * interface that implements the oneOf interface {@code type}, directly or through an ancestor or sub-interface.
+ */
+ private boolean isAssignableTo(CodegenModel target, CodegenModel type) {
+ return isAssignableTo(target, type, new HashSet<>());
+ }
+
+ @SuppressWarnings("unchecked")
+ private boolean isAssignableTo(CodegenModel target, CodegenModel type, Set visited) {
+ for (CodegenModel current = target; current != null; current = current.parentModel) {
+ if (!visited.add(current.classname)) {
+ return false;
+ }
+ if (current.classname.equals(type.classname)) {
+ return true;
+ }
+ Object implemented = current.getVendorExtensions().get("x-implements");
+ if (implemented instanceof List) {
+ for (Object name : (List