Optimize AbstractTypeGenerator.listKeys()

[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 97aa9f86b00cb1b197a1a905839e35b3a5a5bfc6..c9e43e795a2d23b749a6cdeebd843ec77480c8d6 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
@@ -51,6 +51,7 @@ import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import java.util.AbstractMap.SimpleImmutableEntry;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -89,8 +90,8 @@ import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.common.QNameModule;
 import org.opendaylight.yangtools.yang.model.api.ActionDefinition;
 import org.opendaylight.yangtools.yang.model.api.ActionNodeContainer;
-import org.opendaylight.yangtools.yang.model.api.AnyDataSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.AnyXmlSchemaNode;
+import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
+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;
@@ -99,6 +100,7 @@ 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.GroupingDefinition;
 import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
@@ -111,7 +113,6 @@ 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.UnknownSchemaNode;
 import org.opendaylight.yangtools.yang.model.api.UsesNode;
@@ -280,7 +281,7 @@ abstract class AbstractTypeGenerator {
         }
         final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(context, node, baseInterface);
         defaultImplementedInterace(genType);
-        annotateDeprecatedIfNecessary(node.getStatus(), genType);
+        annotateDeprecatedIfNecessary(node, genType);
 
         final Module module = context.module();
         genType.setModuleName(module.getName());
@@ -450,7 +451,7 @@ abstract class AbstractTypeGenerator {
                 qnameConstant(builder, JavaTypeName.create(context.modulePackageName(),
                     BindingMapping.MODULE_INFO_CLASS_NAME), qname.getLocalName());
 
-                annotateDeprecatedIfNecessary(action.getStatus(), builder);
+                annotateDeprecatedIfNecessary(action, builder);
                 builder.addImplementsType(keyType != null ? keyedListAction(parent, keyType, input, output)
                         : action(parent, input, output));
 
@@ -463,8 +464,7 @@ abstract class AbstractTypeGenerator {
     private Optional<ActionDefinition> findOrigAction(final DataNodeContainer parent, final ActionDefinition action) {
         for (UsesNode uses : parent.getUses()) {
             final GroupingDefinition grp = findUsedGrouping(uses);
-            final Optional<ActionDefinition> found = grp.getActions().stream()
-                    .filter(act -> action.getQName().equals(act.getQName())).findFirst();
+            final Optional<ActionDefinition> found = grp.findAction(action.getQName());
             if (found.isPresent()) {
                 final ActionDefinition result = found.get();
                 return result.isAddedByUses() ? findOrigAction(grp, result) : found;
@@ -540,7 +540,7 @@ abstract class AbstractTypeGenerator {
         outType.addImplementsType(type);
         outType.addImplementsType(augmentable(outType));
         defaultImplementedInterace(outType);
-        annotateDeprecatedIfNecessary(rpc.getStatus(), outType);
+        annotateDeprecatedIfNecessary(rpc, outType);
         resolveDataSchemaNodes(context, outType, outType, schema.getChildNodes(), false);
         context.addChildNodeType(schema, outType);
         return outType.build();
@@ -580,7 +580,7 @@ abstract class AbstractTypeGenerator {
                 final GeneratedTypeBuilder notificationInterface = addDefaultInterfaceDefinition(
                     context.modulePackageName(), notification, DATA_OBJECT, context);
                 defaultImplementedInterace(notificationInterface);
-                annotateDeprecatedIfNecessary(notification.getStatus(), notificationInterface);
+                annotateDeprecatedIfNecessary(notification, notificationInterface);
                 notificationInterface.addImplementsType(NOTIFICATION);
                 context.addChildNodeType(notification, notificationInterface);
 
@@ -700,7 +700,7 @@ abstract class AbstractTypeGenerator {
             // node of grouping is resolved to the method.
             final GeneratedTypeBuilder genType = addDefaultInterfaceDefinition(context, grouping);
             narrowImplementedInterface(genType);
-            annotateDeprecatedIfNecessary(grouping.getStatus(), genType);
+            annotateDeprecatedIfNecessary(grouping, genType);
             context.addGroupingType(grouping, genType);
             resolveDataSchemaNodes(context, genType, genType, grouping.getChildNodes(), true);
             groupingsToGenTypes(context, grouping.getGroupings());
@@ -931,7 +931,7 @@ abstract class AbstractTypeGenerator {
         defaultImplementedInterace(augTypeBuilder);
 
         augTypeBuilder.addImplementsType(augmentationTypeFor(targetTypeRef));
-        annotateDeprecatedIfNecessary(augSchema.getStatus(), augTypeBuilder);
+        annotateDeprecatedIfNecessary(augSchema, augTypeBuilder);
         addImplementedInterfaceFromUses(augSchema, augTypeBuilder);
 
         augSchemaNodeToMethods(context, augTypeBuilder, augSchema.getChildNodes(), inGrouping);
@@ -1058,7 +1058,7 @@ abstract class AbstractTypeGenerator {
                 listToGenType(context, typeBuilder, baseInterface, (ListSchemaNode) node, inGrouping);
             } else if (node instanceof ChoiceSchemaNode) {
                 choiceToGeneratedType(context, typeBuilder, (ChoiceSchemaNode) node, inGrouping);
-            } else if (node instanceof AnyXmlSchemaNode || node instanceof AnyDataSchemaNode) {
+            } else if (node instanceof AnyxmlSchemaNode || node instanceof AnydataSchemaNode) {
                 opaqueToGeneratedType(context, typeBuilder, node);
             } else {
                 LOG.debug("Unable to add schema node {} as method in {}: unsupported type of node.", node.getClass(),
@@ -1090,7 +1090,7 @@ abstract class AbstractTypeGenerator {
                 JavaTypeName.create(packageNameForGeneratedType(context.modulePackageName(), choiceNode.getPath()),
                 BindingMapping.getClassName(choiceNode.getQName())), choiceNode);
             choiceTypeBuilder.addImplementsType(choiceIn(parent));
-            annotateDeprecatedIfNecessary(choiceNode.getStatus(), choiceTypeBuilder);
+            annotateDeprecatedIfNecessary(choiceNode, choiceTypeBuilder);
             context.addChildNodeType(choiceNode, choiceTypeBuilder);
 
             final GeneratedType choiceType = choiceTypeBuilder.build();
@@ -1108,7 +1108,7 @@ abstract class AbstractTypeGenerator {
                 BindingMapping.getClassName(anyNode.getQName())), anyNode);
             anyxmlTypeBuilder.addImplementsType(opaqueObject(anyxmlTypeBuilder)).addImplementsType(childOf(parent));
             defaultImplementedInterace(anyxmlTypeBuilder);
-            annotateDeprecatedIfNecessary(anyNode.getStatus(), anyxmlTypeBuilder);
+            annotateDeprecatedIfNecessary(anyNode, anyxmlTypeBuilder);
             context.addChildNodeType(anyNode, anyxmlTypeBuilder);
 
             constructGetter(parent, anyxmlTypeBuilder.build(), anyNode);
@@ -1140,7 +1140,7 @@ abstract class AbstractTypeGenerator {
                 final GeneratedTypeBuilder caseTypeBuilder = addDefaultInterfaceDefinition(context, caseNode);
                 caseTypeBuilder.addImplementsType(refChoiceType);
                 defaultImplementedInterace(caseTypeBuilder);
-                annotateDeprecatedIfNecessary(caseNode.getStatus(), caseTypeBuilder);
+                annotateDeprecatedIfNecessary(caseNode, caseTypeBuilder);
                 context.addCaseType(caseNode.getPath(), caseTypeBuilder);
                 context.addChoiceToCaseMapping(refChoiceType, caseTypeBuilder, caseNode);
                 final Iterable<DataSchemaNode> caseChildNodes = caseNode.getChildNodes();
@@ -1706,7 +1706,7 @@ abstract class AbstractTypeGenerator {
             getterMethodName(node.getQName().getLocalName(), returnType));
         getMethod.setReturnType(returnType);
 
-        annotateDeprecatedIfNecessary(node.getStatus(), getMethod);
+        annotateDeprecatedIfNecessary(node, getMethod);
         addComment(getMethod, node);
 
         return getMethod;
@@ -1717,7 +1717,7 @@ abstract class AbstractTypeGenerator {
         final MethodSignatureBuilder getMethod = interfaceBuilder.addMethod(
             BindingMapping.getNonnullMethodName(node.getQName().getLocalName()));
         getMethod.setReturnType(returnType).setDefault(true);
-        annotateDeprecatedIfNecessary(node.getStatus(), getMethod);
+        annotateDeprecatedIfNecessary(node, getMethod);
     }
 
     /**
@@ -1789,15 +1789,19 @@ abstract class AbstractTypeGenerator {
      *         an empty list is returned.
      */
     private static List<String> listKeys(final ListSchemaNode list) {
-        final List<String> listKeys = new ArrayList<>();
-
         final List<QName> keyDefinition = list.getKeyDefinition();
-        if (keyDefinition != null) {
-            for (final QName keyDef : keyDefinition) {
-                listKeys.add(keyDef.getLocalName());
-            }
+        switch (keyDefinition.size()) {
+            case 0:
+                return Collections.emptyList();
+            case 1:
+                return Collections.singletonList(keyDefinition.get(0).getLocalName());
+            default:
+                final List<String> listKeys = new ArrayList<>(keyDefinition.size());
+                for (final QName keyDef : keyDefinition) {
+                    listKeys.add(keyDef.getLocalName());
+                }
+                return listKeys;
         }
-        return listKeys;
     }
 
     /**
@@ -1928,9 +1932,20 @@ abstract class AbstractTypeGenerator {
         return parent.createEnclosed(BindingMapping.getClassName(child), "$");
     }
 
-    private static void annotateDeprecatedIfNecessary(final Status status, final AnnotableTypeBuilder builder) {
-        if (status == Status.DEPRECATED) {
-            builder.addAnnotation(DEPRECATED_ANNOTATION);
+    private static void annotateDeprecatedIfNecessary(final WithStatus node, final AnnotableTypeBuilder builder) {
+        switch (node.getStatus()) {
+            case DEPRECATED:
+                // FIXME: we really want to use a pre-made annotation
+                builder.addAnnotation(DEPRECATED_ANNOTATION);
+                break;
+            case OBSOLETE:
+                builder.addAnnotation(DEPRECATED_ANNOTATION).addParameter("forRemoval", "true");
+                break;
+            case CURRENT:
+                // No-op
+                break;
+            default:
+                throw new IllegalStateException("Unhandled status in " + node);
         }
     }