Propagate notification status to generated listener methods

[mdsal.git] / binding / mdsal-binding-generator-impl / src / main / java / org / opendaylight / mdsal / binding / generator / impl / AbstractTypeGenerator.java

diff --git a/binding/mdsal-binding-generator-impl/src/main/java/org/opendaylight/mdsal/binding/generator/impl/AbstractTypeGenerator.java b/binding/mdsal-binding-generator-impl/src/main/java/org/opendaylight/mdsal/binding/generator/impl/AbstractTypeGenerator.java
index 571fbd8a30c13e1d9e01cf8f0ea40c44a7af6ef3..96c880171dbd37d6450fab0710703665f82f328e 100644 (file)
--- a/binding/mdsal-binding-generator-impl/src/main/java/org/opendaylight/mdsal/binding/generator/impl/AbstractTypeGenerator.java
+++ b/binding/mdsal-binding-generator-impl/src/main/java/org/opendaylight/mdsal/binding/generator/impl/AbstractTypeGenerator.java
@@ -42,6 +42,8 @@ import static org.opendaylight.mdsal.binding.model.util.Types.classType;
 import static org.opendaylight.mdsal.binding.model.util.Types.listTypeFor;
 import static org.opendaylight.mdsal.binding.model.util.Types.listenableFutureTypeFor;
 import static org.opendaylight.mdsal.binding.model.util.Types.mapTypeFor;
+import static org.opendaylight.mdsal.binding.model.util.Types.primitiveBooleanType;
+import static org.opendaylight.mdsal.binding.model.util.Types.primitiveIntType;
 import static org.opendaylight.mdsal.binding.model.util.Types.primitiveVoidType;
 import static org.opendaylight.mdsal.binding.model.util.Types.wildcardTypeFor;
 import static org.opendaylight.yangtools.yang.model.util.SchemaContextUtil.findDataSchemaNode;
@@ -67,9 +69,11 @@ import org.eclipse.jdt.annotation.Nullable;
 import org.opendaylight.mdsal.binding.model.api.AccessModifier;
 import org.opendaylight.mdsal.binding.model.api.Constant;
 import org.opendaylight.mdsal.binding.model.api.DefaultType;
+import org.opendaylight.mdsal.binding.model.api.Enumeration;
 import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
 import org.opendaylight.mdsal.binding.model.api.GeneratedType;
 import org.opendaylight.mdsal.binding.model.api.JavaTypeName;
+import org.opendaylight.mdsal.binding.model.api.MethodSignature.ValueMechanics;
 import org.opendaylight.mdsal.binding.model.api.ParameterizedType;
 import org.opendaylight.mdsal.binding.model.api.Restrictions;
 import org.opendaylight.mdsal.binding.model.api.Type;
@@ -98,14 +102,17 @@ import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.AugmentationSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.CaseSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.ContainerLike;
 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.DataNodeContainer;
 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.DerivableSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.DocumentedNode;
 import org.opendaylight.yangtools.yang.model.api.DocumentedNode.WithStatus;
+import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
 import org.opendaylight.yangtools.yang.model.api.GroupingDefinition;
 import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
+import org.opendaylight.yangtools.yang.model.api.InputSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.LeafSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
@@ -113,16 +120,19 @@ import org.opendaylight.yangtools.yang.model.api.Module;
 import org.opendaylight.yangtools.yang.model.api.ModuleImport;
 import org.opendaylight.yangtools.yang.model.api.NotificationDefinition;
 import org.opendaylight.yangtools.yang.model.api.NotificationNodeContainer;
+import org.opendaylight.yangtools.yang.model.api.OutputSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
-import org.opendaylight.yangtools.yang.model.api.SchemaContext;
 import org.opendaylight.yangtools.yang.model.api.SchemaNode;
 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.Status;
 import org.opendaylight.yangtools.yang.model.api.TypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.TypedDataSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.UsesNode;
 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
 import org.opendaylight.yangtools.yang.model.api.type.BitsTypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.EnumTypeDefinition;
+import org.opendaylight.yangtools.yang.model.api.type.LeafrefTypeDefinition;
 import org.opendaylight.yangtools.yang.model.api.type.PatternConstraint;
 import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
 import org.opendaylight.yangtools.yang.model.util.ModuleDependencySort;
@@ -136,6 +146,9 @@ abstract class AbstractTypeGenerator {
     private static final Splitter COLON_SPLITTER = Splitter.on(':');
     private static final JavaTypeName DEPRECATED_ANNOTATION = JavaTypeName.create(Deprecated.class);
     private static final JavaTypeName OVERRIDE_ANNOTATION = JavaTypeName.create(Override.class);
+    private static final JavaTypeName CHECK_RETURN_VALUE_ANNOTATION =
+            // Do not refer to annotation class, as it may not be available at runtime
+            JavaTypeName.create("edu.umd.cs.findbugs.annotations", "CheckReturnValue");
     private static final Type LIST_STRING_TYPE = listTypeFor(BaseYangTypes.STRING_TYPE);
 
     /**
@@ -186,14 +199,14 @@ abstract class AbstractTypeGenerator {
     /**
      * Holds reference to schema context to resolve data of augmented element when creating augmentation builder.
      */
-    private final @NonNull SchemaContext schemaContext;
+    private final @NonNull EffectiveModelContext schemaContext;
 
     /**
      * Holds renamed elements.
      */
     private final Map<SchemaNode, JavaTypeName> renames;
 
-    AbstractTypeGenerator(final SchemaContext context, final AbstractTypeProvider typeProvider,
+    AbstractTypeGenerator(final EffectiveModelContext context, final AbstractTypeProvider typeProvider,
             final Map<SchemaNode, JavaTypeName> renames) {
         this.schemaContext = requireNonNull(context);
         this.typeProvider = requireNonNull(typeProvider);
@@ -208,7 +221,7 @@ abstract class AbstractTypeGenerator {
         contexts.forEach(this::allAugmentsToGenTypes);
     }
 
-    final @NonNull SchemaContext schemaContext() {
+    final @NonNull EffectiveModelContext schemaContext() {
         return schemaContext;
     }
 
@@ -233,20 +246,24 @@ abstract class AbstractTypeGenerator {
 
     abstract void addComment(TypeMemberBuilder<?> genType, DocumentedNode node);
 
+    abstract void addRpcMethodComment(TypeMemberBuilder<?> genType, RpcDefinition node);
+
     private ModuleContext moduleToGenTypes(final Module module) {
         final ModuleContext context = new ModuleContext(module);
         genCtx.put(module.getQNameModule(), context);
         allTypeDefinitionsToGenTypes(context);
         groupingsToGenTypes(context, module.getGroupings());
-        rpcMethodsToGenType(context);
         allIdentitiesToGenTypes(context);
-        notificationsToGenType(context);
 
         if (!module.getChildNodes().isEmpty()) {
             final GeneratedTypeBuilder moduleType = moduleToDataType(context);
             context.addModuleNode(moduleType);
             resolveDataSchemaNodes(context, moduleType, moduleType, module.getChildNodes(), false);
         }
+
+        // Resolve RPCs and notifications only after we have created instantiated tree
+        rpcMethodsToGenType(context);
+        notificationsToGenType(context);
         return context;
     }
 
@@ -285,7 +302,7 @@ abstract class AbstractTypeGenerator {
             return null;
         }
         final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(context, node, baseInterface);
-        defaultImplementedInterace(genType);
+        addConcreteInterfaceMethods(genType);
         annotateDeprecatedIfNecessary(node, genType);
 
         final Module module = context.module();
@@ -335,7 +352,7 @@ abstract class AbstractTypeGenerator {
                 listType = listTypeFor(genType);
             }
 
-            constructGetter(parent, listType, node);
+            constructGetter(parent, listType, node).setMechanics(ValueMechanics.NULLIFY_EMPTY);
             constructNonnull(parent, listType, node);
 
             actionsToGenType(context, genType, node, keyTypeBuilder, inGrouping);
@@ -433,6 +450,11 @@ abstract class AbstractTypeGenerator {
         final Module module = context.module();
         addImplementedInterfaceFromUses(module, moduleDataTypeBuilder);
         moduleDataTypeBuilder.addImplementsType(DATA_ROOT);
+        // if we have more than 2 top level uses statements we need to define getImplementedInterface() on the
+        // top level DataRoot object
+        if (module.getUses().size() > 1) {
+            narrowImplementedInterface(moduleDataTypeBuilder);
+        }
 
         addCodegenInformation(moduleDataTypeBuilder, module);
         return moduleDataTypeBuilder;
@@ -496,7 +518,7 @@ abstract class AbstractTypeGenerator {
     }
 
     private GeneratedType actionContainer(final ModuleContext context, final Type baseInterface,
-            final ContainerSchemaNode schema, final boolean inGrouping) {
+            final ContainerLike schema, final boolean inGrouping) {
         final GeneratedTypeBuilder genType = processDataSchemaNode(context, baseInterface, schema, inGrouping);
         resolveDataSchemaNodes(context, genType, genType, schema.getChildNodes(), inGrouping);
         return genType.build();
@@ -539,8 +561,8 @@ abstract class AbstractTypeGenerator {
                 final MethodSignatureBuilder method = interfaceBuilder.addMethod(rpcMethodName);
 
                 // Do not refer to annotation class, as it may not be available at runtime
-                method.addAnnotation("edu.umd.cs.findbugs.annotations", "CheckReturnValue");
-                addComment(method, rpc);
+                method.addAnnotation(CHECK_RETURN_VALUE_ANNOTATION);
+                addRpcMethodComment(method, rpc);
                 method.addParameter(
                     createRpcContainer(context, rpcName, rpc, verifyNotNull(rpc.getInput()), RPC_INPUT), "input");
                 method.setReturnType(listenableFutureTypeFor(
@@ -552,7 +574,7 @@ abstract class AbstractTypeGenerator {
     }
 
     private Type createRpcContainer(final ModuleContext context, final String rpcName, final RpcDefinition rpc,
-            final ContainerSchemaNode schema, final Type type) {
+            final ContainerLike schema, final Type type) {
         processUsesAugments(schema, context, false);
         final GeneratedTypeBuilder outType = addRawInterfaceDefinition(context,
             JavaTypeName.create(context.modulePackageName(), rpcName + BindingMapping.getClassName(schema.getQName())),
@@ -560,7 +582,7 @@ abstract class AbstractTypeGenerator {
         addImplementedInterfaceFromUses(schema, outType);
         outType.addImplementsType(type);
         outType.addImplementsType(augmentable(outType));
-        defaultImplementedInterace(outType);
+        addConcreteInterfaceMethods(outType);
         annotateDeprecatedIfNecessary(rpc, outType);
         resolveDataSchemaNodes(context, outType, outType, schema.getChildNodes(), false);
         context.addChildNodeType(schema, outType);
@@ -600,7 +622,7 @@ abstract class AbstractTypeGenerator {
 
                 final GeneratedTypeBuilder notificationInterface = addDefaultInterfaceDefinition(
                     context.modulePackageName(), notification, DATA_OBJECT, context);
-                defaultImplementedInterace(notificationInterface);
+                addConcreteInterfaceMethods(notificationInterface);
                 annotateDeprecatedIfNecessary(notification, notificationInterface);
                 notificationInterface.addImplementsType(NOTIFICATION);
                 context.addChildNodeType(notification, notificationInterface);
@@ -609,9 +631,16 @@ abstract class AbstractTypeGenerator {
                 resolveDataSchemaNodes(context, notificationInterface, notificationInterface,
                     notification.getChildNodes(), false);
 
-                addComment(listenerInterface.addMethod("on" + notificationInterface.getName())
+                final MethodSignatureBuilder notificationMethod =
+                    listenerInterface.addMethod("on" + notificationInterface.getName())
                     .setAccessModifier(AccessModifier.PUBLIC).addParameter(notificationInterface, "notification")
-                    .setReturnType(primitiveVoidType()), notification);
+                    .setReturnType(primitiveVoidType());
+
+                annotateDeprecatedIfNecessary(notification, notificationMethod);
+                if (notification.getStatus().equals(Status.OBSOLETE)) {
+                    notificationMethod.setDefault(true);
+                }
+                addComment(notificationMethod, notification);
             }
         }
 
@@ -641,7 +670,7 @@ abstract class AbstractTypeGenerator {
 
             final GeneratedTypeBuilder notifInterface = addDefaultInterfaceDefinition(
                 packageNameForGeneratedType(context.modulePackageName(), notif.getPath()), notif, DATA_OBJECT, context);
-            defaultImplementedInterace(notifInterface);
+            addConcreteInterfaceMethods(notifInterface);
             annotateDeprecatedIfNecessary(notif, notifInterface);
 
             notifInterface.addImplementsType(keyType != null ? keyedListNotification(notifInterface, parent, keyType)
@@ -775,16 +804,15 @@ abstract class AbstractTypeGenerator {
      * @param module Module in which type should be generated
      * @return enumeration builder which contains data from <code>enumTypeDef</code>
      */
-    private EnumBuilder resolveInnerEnumFromTypeDefinition(final EnumTypeDefinition enumTypeDef, final QName enumName,
+    private Enumeration resolveInnerEnumFromTypeDefinition(final EnumTypeDefinition enumTypeDef, final QName enumName,
             final GeneratedTypeBuilder typeBuilder, final ModuleContext context) {
-        if (enumTypeDef != null && typeBuilder != null && enumTypeDef.getQName().getLocalName() != null) {
-            final EnumBuilder enumBuilder = typeBuilder.addEnumeration(BindingMapping.getClassName(enumName));
-            typeProvider.addEnumDescription(enumBuilder, enumTypeDef);
-            enumBuilder.updateEnumPairsFromEnumTypeDef(enumTypeDef);
-            context.addInnerTypedefType(enumTypeDef.getPath(), enumBuilder);
-            return enumBuilder;
-        }
-        return null;
+        final EnumBuilder enumBuilder = typeBuilder.addEnumeration(BindingMapping.getClassName(enumName));
+        typeProvider.addEnumDescription(enumBuilder, enumTypeDef);
+        enumBuilder.updateEnumPairsFromEnumTypeDef(enumTypeDef);
+        final Enumeration ret = enumBuilder.toInstance(typeBuilder);
+        context.addTypeToSchema(ret, enumTypeDef);
+        context.addInnerTypedefType(enumTypeDef.getPath(), ret);
+        return ret;
     }
 
     /**
@@ -939,8 +967,8 @@ abstract class AbstractTypeGenerator {
                 final ActionDefinition action = (ActionDefinition) result;
                 final QName resultNode = node.bindTo(result.getQName().getModule());
 
-                final ContainerSchemaNode input = action.getInput();
-                final ContainerSchemaNode output = action.getOutput();
+                final InputSchemaNode input = action.getInput();
+                final OutputSchemaNode output = action.getOutput();
                 if (resultNode.equals(input.getQName())) {
                     result = input;
                 } else if (resultNode.equals(output.getQName())) {
@@ -1010,7 +1038,7 @@ abstract class AbstractTypeGenerator {
             JavaTypeName.create(augmentPackageName, augTypeName));
 
         augTypeBuilder.addImplementsType(augmentation(targetTypeRef));
-        defaultImplementedInterace(augTypeBuilder);
+        addConcreteInterfaceMethods(augTypeBuilder);
 
         annotateDeprecatedIfNecessary(augSchema, augTypeBuilder);
         addImplementedInterfaceFromUses(augSchema, augTypeBuilder);
@@ -1223,7 +1251,7 @@ abstract class AbstractTypeGenerator {
             if (caseNode != null && !caseNode.isAddedByUses() && !caseNode.isAugmenting()) {
                 final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(context, caseNode);
                 caseTypeBuilder.addImplementsType(refChoiceType);
-                defaultImplementedInterace(caseTypeBuilder);
+                addConcreteInterfaceMethods(caseTypeBuilder);
                 annotateDeprecatedIfNecessary(caseNode, caseTypeBuilder);
                 context.addCaseType(caseNode.getPath(), caseTypeBuilder);
                 context.addChoiceToCaseMapping(refChoiceType, caseTypeBuilder, caseNode);
@@ -1303,7 +1331,7 @@ abstract class AbstractTypeGenerator {
             if (caseNode != null) {
                 final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(context, caseNode);
                 caseTypeBuilder.addImplementsType(targetType);
-                defaultImplementedInterace(caseTypeBuilder);
+                addConcreteInterfaceMethods(caseTypeBuilder);
 
                 CaseSchemaNode node = null;
                 final String caseLocalName = caseNode.getQName().getLocalName();
@@ -1410,13 +1438,8 @@ abstract class AbstractTypeGenerator {
         final TypeDefinition<?> typeDef = CompatUtils.compatType(leaf);
         if (isInnerType(leaf, typeDef)) {
             if (typeDef instanceof EnumTypeDefinition) {
-                returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, leaf, inGrouping);
                 final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) typeDef;
-                final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, leaf.getQName(),
-                    typeBuilder, context);
-                if (enumBuilder != null) {
-                    returnType = enumBuilder.toInstance(typeBuilder);
-                }
+                returnType = resolveInnerEnumFromTypeDefinition(enumTypeDef, leaf.getQName(), typeBuilder, context);
                 typeProvider.putReferencedType(leaf.getPath(), returnType);
             } else if (typeDef instanceof UnionTypeDefinition) {
                 final UnionTypeDefinition unionDef = (UnionTypeDefinition)typeDef;
@@ -1430,13 +1453,25 @@ abstract class AbstractTypeGenerator {
                     returnType = genTOBuilder.build();
                 }
             } else {
-                // It is constrained version of already declared type (inner declared type exists,
-                // onlyfor special cases (Enum, Union, Bits), which were already checked.
-                // In order to get proper class we need to look up closest derived type
-                // and apply restrictions from leaf type
+                // It is constrained version of already declared type (inner declared type exists, only for special
+                // cases (Enum, Union, Bits), which were already checked.
+                // In order to get proper class we need to look up closest derived type and apply restrictions from leaf
+                // type
                 final Restrictions restrictions = BindingGeneratorUtil.getRestrictions(typeDef);
-                returnType = typeProvider.javaTypeForSchemaDefinitionType(getBaseOrDeclaredType(typeDef), leaf,
-                        restrictions, inGrouping);
+                final TypeDefinition<?> baseOrDeclaredType = getBaseOrDeclaredType(typeDef);
+                // we need to try to lookup an already generated type in case the leafref is targetting a generated type
+                if (baseOrDeclaredType instanceof LeafrefTypeDefinition) {
+                    final SchemaNode leafrefTarget =
+                            typeProvider.getTargetForLeafref((LeafrefTypeDefinition) baseOrDeclaredType, leaf);
+                    if (leafrefTarget instanceof TypedDataSchemaNode) {
+                        returnType = context.getInnerType(((TypedDataSchemaNode) leafrefTarget).getType().getPath());
+                    }
+                }
+                if (returnType == null) {
+                    returnType = typeProvider.javaTypeForSchemaDefinitionType(baseOrDeclaredType, leaf,
+                            restrictions, inGrouping);
+                }
+
                 addPatternConstant(typeBuilder, leaf.getQName().getLocalName(), restrictions.getPatternConstraints());
             }
         } else {
@@ -1607,11 +1642,8 @@ abstract class AbstractTypeGenerator {
         Type returnType = null;
         if (typeDef.getBaseType() == null) {
             if (typeDef instanceof EnumTypeDefinition) {
-                returnType = typeProvider.javaTypeForSchemaDefinitionType(typeDef, node, inGrouping);
                 final EnumTypeDefinition enumTypeDef = (EnumTypeDefinition) typeDef;
-                final EnumBuilder enumBuilder = resolveInnerEnumFromTypeDefinition(enumTypeDef, nodeName,
-                    typeBuilder, context);
-                returnType = DefaultType.of(enumBuilder);
+                returnType = resolveInnerEnumFromTypeDefinition(enumTypeDef, nodeName, typeBuilder, context);
                 typeProvider.putReferencedType(node.getPath(), returnType);
             } else if (typeDef instanceof UnionTypeDefinition) {
                 final UnionTypeDefinition unionDef = (UnionTypeDefinition)typeDef;
@@ -2042,6 +2074,23 @@ abstract class AbstractTypeGenerator {
         }
     }
 
+    private static void addConcreteInterfaceMethods(final GeneratedTypeBuilder typeBuilder) {
+        defaultImplementedInterace(typeBuilder);
+
+        typeBuilder.addMethod(BindingMapping.BINDING_HASHCODE_NAME)
+            .setAccessModifier(AccessModifier.PUBLIC)
+            .setStatic(true)
+            .setReturnType(primitiveIntType());
+        typeBuilder.addMethod(BindingMapping.BINDING_EQUALS_NAME)
+            .setAccessModifier(AccessModifier.PUBLIC)
+            .setStatic(true)
+            .setReturnType(primitiveBooleanType());
+        typeBuilder.addMethod(BindingMapping.BINDING_TO_STRING_NAME)
+            .setAccessModifier(AccessModifier.PUBLIC)
+            .setStatic(true)
+            .setReturnType(STRING);
+    }
+
     private static void narrowImplementedInterface(final GeneratedTypeBuilder typeBuilder) {
         defineImplementedInterfaceMethod(typeBuilder, wildcardTypeFor(typeBuilder.getIdentifier()));
     }