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;
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;
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;
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)) {
}
@Override
- final R createRuntimeType() {
+ final Type runtimeJavaType() {
if (methodReturnTypeElement != null) {
- return createRuntimeType(methodReturnTypeElement);
+ return methodReturnTypeElement;
}
final var genType = generatedType();
if (genType.isPresent()) {
- return createRuntimeType(genType.orElseThrow());
+ return genType.orElseThrow();
}
final var prev = verifyNotNull(previous(), "No previous generator for %s", this);
- return prev.runtimeType().orElse(null);
+ return prev.runtimeJavaType();
}
- abstract @NonNull R createRuntimeType(Type type);
-
final @NonNull Type methodReturnElementType(final @NonNull TypeBuilderFactory builderFactory) {
var local = methodReturnTypeElement;
if (local == null) {
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) {
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<GeneratedType> tmp = new ArrayList<>(1);
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());
}
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);
}
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);
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());
final List<String> 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();
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);
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
* @throws IllegalArgumentException if <code>typedef</code> equals null
*/
static Map<String, String> 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();
}
}
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);
+ };
}
}
Code Review / mdsal.git / blobdiff