X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=binding%2Fmdsal-binding-generator%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fmdsal%2Fbinding%2Fgenerator%2Fimpl%2Freactor%2FAbstractTypeObjectGenerator.java;h=a252abb624f20208b2f63d88786af5760881529b;hb=f7d9818a3836443049e8b6e51e262e1a3cc2377a;hp=845fb0dcba8b4f785f946ff92d50966b9c676581;hpb=0ee55d1f9da11dd03ff05fc67d10cbcbfe63fd2c;p=mdsal.git diff --git a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractTypeObjectGenerator.java b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractTypeObjectGenerator.java index 845fb0dcba..a252abb624 100644 --- a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractTypeObjectGenerator.java +++ b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractTypeObjectGenerator.java @@ -11,6 +11,7 @@ import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.base.Verify.verify; import static com.google.common.base.Verify.verifyNotNull; +import com.google.common.base.VerifyException; import com.google.common.collect.ImmutableMap; import com.google.common.collect.Maps; import java.util.ArrayList; @@ -23,7 +24,6 @@ import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.Nullable; import org.opendaylight.mdsal.binding.generator.BindingGeneratorUtil; import org.opendaylight.mdsal.binding.generator.impl.reactor.TypeReference.ResolvedLeafref; -import org.opendaylight.mdsal.binding.model.api.AccessModifier; import org.opendaylight.mdsal.binding.model.api.ConcreteType; import org.opendaylight.mdsal.binding.model.api.Enumeration; import org.opendaylight.mdsal.binding.model.api.GeneratedProperty; @@ -32,6 +32,7 @@ import org.opendaylight.mdsal.binding.model.api.GeneratedType; import org.opendaylight.mdsal.binding.model.api.JavaTypeName; import org.opendaylight.mdsal.binding.model.api.Restrictions; import org.opendaylight.mdsal.binding.model.api.Type; +import org.opendaylight.mdsal.binding.model.api.YangSourceDefinition; import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedPropertyBuilder; import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTOBuilder; import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase; @@ -236,8 +237,7 @@ abstract class AbstractTypeObjectGenerator, R private void resolveUnionDependencies(final GeneratorContext context, final TypeEffectiveStatement union) { for (EffectiveStatement stmt : union.effectiveSubstatements()) { - if (stmt instanceof TypeEffectiveStatement) { - final TypeEffectiveStatement type = (TypeEffectiveStatement) stmt; + if (stmt instanceof TypeEffectiveStatement type) { final QName typeName = type.argument(); if (TypeDefinitions.IDENTITYREF.equals(typeName)) { if (!identityTypes.containsKey(stmt)) { @@ -514,13 +514,12 @@ abstract class AbstractTypeObjectGenerator, R return baseType; } - if (!(baseType instanceof GeneratedTransferObject)) { + if (!(baseType instanceof GeneratedTransferObject gto)) { // This is a simple Java type, just wrap it with new restrictions return Types.restrictedType(baseType, restrictions); } // Base type is a GTO, we need to re-adjust it with new restrictions - final GeneratedTransferObject gto = (GeneratedTransferObject) baseType; final GeneratedTOBuilder builder = builderFactory.newGeneratedTOBuilder(gto.getIdentifier()); final GeneratedTransferObject parent = gto.getSuperType(); if (parent != null) { @@ -590,9 +589,10 @@ abstract class AbstractTypeObjectGenerator, R final boolean isTypedef = this instanceof TypedefGenerator; final QName arg = type.argument(); if (TypeDefinitions.BITS.equals(arg)) { - return createBits(builderFactory, typeName(), currentModule(), extractTypeDefinition(), isTypedef); + return createBits(builderFactory, statement(), typeName(), currentModule(), + (BitsTypeDefinition) extractTypeDefinition(), isTypedef); } else if (TypeDefinitions.ENUMERATION.equals(arg)) { - return createEnumeration(builderFactory, typeName(), currentModule(), + return createEnumeration(builderFactory, statement(), typeName(), currentModule(), (EnumTypeDefinition) extractTypeDefinition()); } else if (TypeDefinitions.UNION.equals(arg)) { final List tmp = new ArrayList<>(1); @@ -601,29 +601,31 @@ abstract class AbstractTypeObjectGenerator, R auxiliaryGeneratedTypes = List.copyOf(tmp); return ret; } else { - return createSimple(builderFactory, typeName(), currentModule(), + return createSimple(builderFactory, statement(), typeName(), currentModule(), verifyNotNull(SIMPLE_TYPES.get(arg), "Unhandled type %s", arg), extractTypeDefinition()); } } private static @NonNull GeneratedTransferObject createBits(final TypeBuilderFactory builderFactory, - final JavaTypeName typeName, final ModuleGenerator module, final TypeDefinition typedef, - final boolean isTypedef) { + final EffectiveStatement definingStatement, final JavaTypeName typeName, final ModuleGenerator module, + final BitsTypeDefinition typedef, final boolean isTypedef) { final GeneratedTOBuilder builder = builderFactory.newGeneratedTOBuilder(typeName); builder.setTypedef(isTypedef); - builder.addImplementsType(BindingTypes.TYPE_OBJECT); + builder.addImplementsType(BindingTypes.BITS_TYPE_OBJECT); builder.setBaseType(typedef); + YangSourceDefinition.of(module.statement(), definingStatement).ifPresent(builder::setYangSourceDefinition); - for (Bit bit : ((BitsTypeDefinition) typedef).getBits()) { + for (Bit bit : typedef.getBits()) { final String name = bit.getName(); GeneratedPropertyBuilder genPropertyBuilder = builder.addProperty(BindingMapping.getPropertyName(name)); genPropertyBuilder.setReadOnly(true); - genPropertyBuilder.setReturnType(BaseYangTypes.BOOLEAN_TYPE); + genPropertyBuilder.setReturnType(Types.primitiveBooleanType()); builder.addEqualsIdentity(genPropertyBuilder); builder.addHashIdentity(genPropertyBuilder); builder.addToStringProperty(genPropertyBuilder); } + builder.addConstant(Types.immutableSetTypeFor(Types.STRING), TypeConstants.VALID_NAMES_NAME, typedef); // builder.setSchemaPath(typedef.getPath()); builder.setModuleName(module.statement().argument().getLocalName()); @@ -634,9 +636,11 @@ abstract class AbstractTypeObjectGenerator, R } private static @NonNull Enumeration createEnumeration(final TypeBuilderFactory builderFactory, - final JavaTypeName typeName, final ModuleGenerator module, final EnumTypeDefinition typedef) { + final EffectiveStatement definingStatement, final JavaTypeName typeName, + final ModuleGenerator module, final EnumTypeDefinition typedef) { // TODO units for typedef enum final AbstractEnumerationBuilder builder = builderFactory.newEnumerationBuilder(typeName); + YangSourceDefinition.of(module.statement(), definingStatement).ifPresent(builder::setYangSourceDefinition); typedef.getDescription().map(BindingGeneratorUtil::encodeAngleBrackets) .ifPresent(builder::setDescription); @@ -648,12 +652,13 @@ abstract class AbstractTypeObjectGenerator, R } private static @NonNull GeneratedType createSimple(final TypeBuilderFactory builderFactory, - final JavaTypeName typeName, final ModuleGenerator module, final Type javaType, - final TypeDefinition typedef) { + final EffectiveStatement definingStatement, final JavaTypeName typeName, final ModuleGenerator module, + final Type javaType, final TypeDefinition typedef) { final String moduleName = module.statement().argument().getLocalName(); final GeneratedTOBuilder builder = builderFactory.newGeneratedTOBuilder(typeName); builder.setTypedef(true); builder.addImplementsType(BindingTypes.scalarTypeObject(javaType)); + YangSourceDefinition.of(module.statement(), definingStatement).ifPresent(builder::setYangSourceDefinition); final GeneratedPropertyBuilder genPropBuilder = builder.addProperty(TypeConstants.VALUE_PROP); genPropBuilder.setReturnType(javaType); @@ -685,7 +690,8 @@ abstract class AbstractTypeObjectGenerator, R final UnionDependencies dependencies, final JavaTypeName typeName, final ModuleGenerator module, final TypeEffectiveStatement type, final boolean isTypedef, final TypeDefinition typedef) { final GeneratedUnionBuilder builder = builderFactory.newGeneratedUnionBuilder(typeName); - builder.addImplementsType(BindingTypes.TYPE_OBJECT); + YangSourceDefinition.of(module.statement(), definingStatement).ifPresent(builder::setYangSourceDefinition); + builder.addImplementsType(BindingTypes.UNION_TYPE_OBJECT); builder.setIsUnion(true); // builder.setSchemaPath(typedef.getPath()); @@ -704,8 +710,7 @@ abstract class AbstractTypeObjectGenerator, R final List typeProperties = new ArrayList<>(); for (EffectiveStatement stmt : type.effectiveSubstatements()) { - if (stmt instanceof TypeEffectiveStatement) { - final TypeEffectiveStatement subType = (TypeEffectiveStatement) stmt; + if (stmt instanceof TypeEffectiveStatement subType) { final QName subName = subType.argument(); final String localName = subName.getLocalName(); @@ -721,18 +726,22 @@ abstract class AbstractTypeObjectGenerator, R propSource = subUnionName.simpleName(); generatedType = subUnion; } else if (TypeDefinitions.ENUMERATION.equals(subName)) { - final Enumeration subEnumeration = createEnumeration(builderFactory, + final Enumeration subEnumeration = createEnumeration(builderFactory, definingStatement, typeName.createEnclosed(BindingMapping.getClassName(localName), "$"), module, (EnumTypeDefinition) subType.getTypeDefinition()); builder.addEnumeration(subEnumeration); generatedType = subEnumeration; } else if (TypeDefinitions.BITS.equals(subName)) { - final GeneratedTransferObject subBits = createBits(builderFactory, + final GeneratedTransferObject subBits = createBits(builderFactory, definingStatement, typeName.createEnclosed(BindingMapping.getClassName(localName), "$"), module, - subType.getTypeDefinition(), isTypedef); + (BitsTypeDefinition) subType.getTypeDefinition(), isTypedef); builder.addEnclosingTransferObject(subBits); generatedType = subBits; } else if (TypeDefinitions.IDENTITYREF.equals(subName)) { + propSource = stmt.findFirstEffectiveSubstatement(BaseEffectiveStatement.class) + .orElseThrow(() -> new VerifyException(String.format("Invalid identityref " + + "definition %s in %s, missing BASE statement", stmt, definingStatement))) + .argument().getLocalName(); generatedType = verifyNotNull(dependencies.identityTypes.get(stmt), "Cannot resolve identityref %s in %s", stmt, definingStatement) .methodReturnType(builderFactory); @@ -819,29 +828,7 @@ abstract class AbstractTypeObjectGenerator, R addUnits(builder, typedef); makeSerializable(builder); - final GeneratedTransferObject ret = builder.build(); - - // Define a corresponding union builder. Typedefs are always anchored at a Java package root, - // so we are placing the builder alongside the union. - final GeneratedTOBuilder unionBuilder = builderFactory.newGeneratedTOBuilder(unionBuilderName(typeName)); - unionBuilder.setIsUnionBuilder(true); - unionBuilder.addMethod("getDefaultInstance") - .setAccessModifier(AccessModifier.PUBLIC) - .setStatic(true) - .setReturnType(ret) - .addParameter(Types.STRING, "defaultValue"); - auxiliaryGeneratedTypes.add(unionBuilder.build()); - - return ret; - } - - // FIXME: this can be a source of conflicts as we are not guarding against nesting - private static @NonNull JavaTypeName unionBuilderName(final JavaTypeName unionName) { - final StringBuilder sb = new StringBuilder(); - for (String part : unionName.localNameComponents()) { - sb.append(part); - } - return JavaTypeName.create(unionName.packageName(), sb.append(BindingMapping.BUILDER_SUFFIX).toString()); + return builder.build(); } // FIXME: we should not rely on TypeDefinition @@ -872,9 +859,9 @@ abstract class AbstractTypeObjectGenerator, R * @throws IllegalArgumentException if typedef equals null */ static Map resolveRegExpressions(final TypeDefinition typedef) { - return typedef instanceof StringTypeDefinition + return typedef instanceof StringTypeDefinition stringTypedef // TODO: run diff against base ? - ? resolveRegExpressions(((StringTypeDefinition) typedef).getPatternConstraints()) + ? resolveRegExpressions(stringTypedef.getPatternConstraints()) : ImmutableMap.of(); } @@ -925,12 +912,8 @@ abstract class AbstractTypeObjectGenerator, R } private static String applyModifier(final ModifierKind modifier, final String pattern) { - switch (modifier) { - case INVERT_MATCH: - return RegexPatterns.negatePatternString(pattern); - default: - LOG.warn("Ignoring unhandled modifier {}", modifier); - return pattern; - } + return switch (modifier) { + case INVERT_MATCH -> RegexPatterns.negatePatternString(pattern); + }; } }