Share AbstractExplicitGenerator.runtimeJavaType()

Most implementations do the same thing, pull the implementation down
into the abstract class.

Change-Id: Iaf0b6cee34e62c89ea3d34b8c83fa4f02bce913e
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractCompositeGenerator.java b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractCompositeGenerator.java
index d7552006ebefb5c22b05b69206cde6162e9739e6..d63e6cf43893ad4fceed882ecaa5f580b5b54f5f 100644 (file)
--- a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractCompositeGenerator.java
+++ b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractCompositeGenerator.java
@@ -160,11 +160,6 @@ public abstract class AbstractCompositeGenerator<S extends EffectiveStatement<?,
         return childGenerators.iterator();
     }
 
-    @Override
-    final GeneratedType runtimeJavaType() {
-        return generatedType().orElse(null);
-    }
-
     final @NonNull List<AbstractAugmentGenerator> augments() {
         return augments;
     }
@@ -199,10 +194,10 @@ public abstract class AbstractCompositeGenerator<S extends EffectiveStatement<?,
     final @Nullable AbstractExplicitGenerator<?, ?> findGenerator(final MatchStrategy childStrategy,
             // TODO: Wouldn't this method be nicer with Deque<EffectiveStatement<?, ?>> ?
             final List<EffectiveStatement<?, ?>> stmtPath, final int offset) {
-        final EffectiveStatement<?, ?> stmt = stmtPath.get(offset);
+        final var stmt = stmtPath.get(offset);
 
         // Try direct children first, which is simple
-        AbstractExplicitGenerator<?, ?> ret = childStrategy.findGenerator(stmt, childGenerators);
+        var ret = childStrategy.findGenerator(stmt, childGenerators);
         if (ret != null) {
             final int next = offset + 1;
             if (stmtPath.size() == next) {
@@ -254,17 +249,17 @@ public abstract class AbstractCompositeGenerator<S extends EffectiveStatement<?,
         // - we propagate those groupings as anchors to any augment statements, which takes out some amount of guesswork
         //   from augment+uses resolution case, as groupings know about their immediate augments as soon as uses linkage
         //   is resolved
-        final List<GroupingGenerator> tmp = new ArrayList<>();
-        for (EffectiveStatement<?, ?> stmt : statement().effectiveSubstatements()) {
+        final var tmp = new ArrayList<GroupingGenerator>();
+        for (var stmt : statement().effectiveSubstatements()) {
             if (stmt instanceof UsesEffectiveStatement uses) {
-                final GroupingGenerator grouping = context.resolveTreeScoped(GroupingGenerator.class, uses.argument());
+                final var grouping = context.resolveTreeScoped(GroupingGenerator.class, uses.argument());
                 tmp.add(grouping);
 
                 // Trigger resolution of uses/augment statements. This looks like guesswork, but there may be multiple
                 // 'augment' statements in a 'uses' statement and keeping a ListMultimap here seems wasteful.
                 for (Generator gen : this) {
-                    if (gen instanceof UsesAugmentGenerator) {
-                        ((UsesAugmentGenerator) gen).resolveGrouping(uses, grouping);
+                    if (gen instanceof UsesAugmentGenerator usesGen) {
+                        usesGen.resolveGrouping(uses, grouping);
                     }
                 }
             }
@@ -273,12 +268,12 @@ public abstract class AbstractCompositeGenerator<S extends EffectiveStatement<?,
     }
 
     final void startUsesAugmentLinkage(final List<AugmentRequirement> requirements) {
-        for (Generator child : childGenerators) {
-            if (child instanceof UsesAugmentGenerator) {
-                requirements.add(((UsesAugmentGenerator) child).startLinkage());
+        for (var child : childGenerators) {
+            if (child instanceof UsesAugmentGenerator uses) {
+                requirements.add(uses.startLinkage());
             }
-            if (child instanceof AbstractCompositeGenerator) {
-                ((AbstractCompositeGenerator<?, ?>) child).startUsesAugmentLinkage(requirements);
+            if (child instanceof AbstractCompositeGenerator<?, ?> composite) {
+                composite.startUsesAugmentLinkage(requirements);
             }
         }
     }
@@ -321,11 +316,11 @@ public abstract class AbstractCompositeGenerator<S extends EffectiveStatement<?,
                         it.remove();
 
                         // If this is a composite generator we need to process is further
-                        if (child instanceof AbstractCompositeGenerator) {
+                        if (child instanceof AbstractCompositeGenerator<?, ?> composite) {
                             if (unlinkedComposites.isEmpty()) {
                                 unlinkedComposites = new ArrayList<>();
                             }
-                            unlinkedComposites.add((AbstractCompositeGenerator<?, ?>) child);
+                            unlinkedComposites.add(composite);
                         }
                     }
                 }
@@ -392,7 +387,7 @@ public abstract class AbstractCompositeGenerator<S extends EffectiveStatement<?,
 
     @Override
     final AbstractExplicitGenerator<?, ?> findSchemaTreeGenerator(final QName qname) {
-        final AbstractExplicitGenerator<?, ?> found = super.findSchemaTreeGenerator(qname);
+        final var found = super.findSchemaTreeGenerator(qname);
         return found != null ? found : findInferredGenerator(qname);
     }
 
@@ -407,7 +402,7 @@ public abstract class AbstractCompositeGenerator<S extends EffectiveStatement<?,
     }
 
     final @Nullable GroupingGenerator findGroupingForGenerator(final QName qname) {
-        for (GroupingGenerator grouping : groupings) {
+        for (var grouping : groupings) {
             final var gen = grouping.findSchemaTreeGenerator(qname.bindTo(grouping.statement().argument().getModule()));
             if (gen != null) {
                 return grouping;
@@ -443,7 +438,7 @@ public abstract class AbstractCompositeGenerator<S extends EffectiveStatement<?,
      * @return The number of groupings this type uses.
      */
     final int addUsesInterfaces(final GeneratedTypeBuilder builder, final TypeBuilderFactory builderFactory) {
-        for (GroupingGenerator grp : groupings) {
+        for (var grp : groupings) {
             builder.addImplementsType(grp.getGeneratedType(builderFactory));
         }
         return groupings.size();
@@ -454,17 +449,17 @@ public abstract class AbstractCompositeGenerator<S extends EffectiveStatement<?,
     }
 
     final void addGetterMethods(final GeneratedTypeBuilder builder, final TypeBuilderFactory builderFactory) {
-        for (Generator child : this) {
+        for (var child : this) {
             // Only process explicit generators here
-            if (child instanceof AbstractExplicitGenerator) {
-                ((AbstractExplicitGenerator<?, ?>) child).addAsGetterMethod(builder, builderFactory);
+            if (child instanceof AbstractExplicitGenerator<?, ?> explicit) {
+                explicit.addAsGetterMethod(builder, builderFactory);
             }
 
-            final GeneratedType enclosedType = child.enclosedType(builderFactory);
-            if (enclosedType instanceof GeneratedTransferObject) {
-                builder.addEnclosingTransferObject((GeneratedTransferObject) enclosedType);
-            } else if (enclosedType instanceof Enumeration) {
-                builder.addEnumeration((Enumeration) enclosedType);
+            final var enclosedType = child.enclosedType(builderFactory);
+            if (enclosedType instanceof GeneratedTransferObject gto) {
+                builder.addEnclosingTransferObject(gto);
+            } else if (enclosedType instanceof Enumeration enumeration) {
+                builder.addEnumeration(enumeration);
             } else {
                 verify(enclosedType == null, "Unhandled enclosed type %s in %s", enclosedType, child);
             }
@@ -596,9 +591,9 @@ public abstract class AbstractCompositeGenerator<S extends EffectiveStatement<?,
     // Utility equivalent of (!isAddedByUses(stmt) && !isAugmenting(stmt)). Takes advantage of relationship between
     // CopyableNode and AddedByUsesAware
     private static boolean isOriginalDeclaration(final EffectiveStatement<?, ?> stmt) {
-        if (stmt instanceof AddedByUsesAware) {
-            if (((AddedByUsesAware) stmt).isAddedByUses()
-                || stmt instanceof CopyableNode && ((CopyableNode) stmt).isAugmenting()) {
+        if (stmt instanceof AddedByUsesAware aware) {
+            if (aware.isAddedByUses()
+                || stmt instanceof CopyableNode copyable && copyable.isAugmenting()) {
                 return false;
             }
         }
@@ -606,10 +601,10 @@ public abstract class AbstractCompositeGenerator<S extends EffectiveStatement<?,
     }
 
     private static boolean isAddedByUses(final EffectiveStatement<?, ?> stmt) {
-        return stmt instanceof AddedByUsesAware && ((AddedByUsesAware) stmt).isAddedByUses();
+        return stmt instanceof AddedByUsesAware aware && aware.isAddedByUses();
     }
 
     private static boolean isAugmenting(final EffectiveStatement<?, ?> stmt) {
-        return stmt instanceof CopyableNode && ((CopyableNode) stmt).isAugmenting();
+        return stmt instanceof CopyableNode copyable && copyable.isAugmenting();
     }
 }

diff --git a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractExplicitGenerator.java b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractExplicitGenerator.java
index 39456cbbaab1575ac2f9222de8d7225bc618a1b8..ad1f91154f1c173f2d10ea14f710d5eacfc025f7 100644 (file)
--- a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractExplicitGenerator.java
+++ b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractExplicitGenerator.java
@@ -112,7 +112,9 @@ public abstract class AbstractExplicitGenerator<S extends EffectiveStatement<?,
      */
     // FIXME: this should be a generic class argument
     // FIXME: this needs a better name, but 'runtimeType' is already taken.
-    abstract @Nullable Type runtimeJavaType();
+    @Nullable Type runtimeJavaType() {
+        return generatedType().orElse(null);
+    }
 
     /**
      * Create the externally-accessible {@link RuntimeType} view of this object. The difference between

diff --git a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/IdentityGenerator.java b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/IdentityGenerator.java
index efffb79ecc0b9e4e018eaee8cda25994fd8e76e4..39d4a2a61a26ad2a3e6872f999a1a27ed5b09958 100644 (file)
--- a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/IdentityGenerator.java
+++ b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/IdentityGenerator.java
@@ -15,7 +15,6 @@ import java.util.stream.Collectors;
 import org.opendaylight.mdsal.binding.generator.impl.rt.DefaultIdentityRuntimeType;
 import org.opendaylight.mdsal.binding.model.api.GeneratedType;
 import org.opendaylight.mdsal.binding.model.api.Type;
-import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
 import org.opendaylight.mdsal.binding.runtime.api.IdentityRuntimeType;
 import org.opendaylight.mdsal.binding.spec.naming.BindingMapping;
@@ -55,9 +54,9 @@ public final class IdentityGenerator
 
     @Override
     GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
-        final GeneratedTypeBuilder builder = builderFactory.newGeneratedTypeBuilder(typeName());
+        final var builder = builderFactory.newGeneratedTypeBuilder(typeName());
         if (!baseIdentities.isEmpty()) {
-            for (IdentityGenerator baseIdentity : baseIdentities) {
+            for (var baseIdentity : baseIdentities) {
                 builder.addImplementsType(baseIdentity.getGeneratedType(builderFactory));
             }
         } else {
@@ -79,11 +78,6 @@ public final class IdentityGenerator
         return builder.build();
     }
 
-    @Override
-    GeneratedType runtimeJavaType() {
-        return generatedType().orElse(null);
-    }
-
     @Override
     IdentityRuntimeType createExternalRuntimeType(final Type type) {
         verify(type instanceof GeneratedType, "Unexpected type %s", type);

diff --git a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/KeyGenerator.java b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/KeyGenerator.java
index d1c59d5e65e0aba3bf0137845a73325d935b9c7b..fcecf92b9eaa00214859b422a4afaf03f76def3d 100644 (file)
--- a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/KeyGenerator.java
+++ b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/KeyGenerator.java
@@ -10,14 +10,10 @@ package org.opendaylight.mdsal.binding.generator.impl.reactor;
 import static com.google.common.base.Verify.verify;
 import static java.util.Objects.requireNonNull;
 
-import java.util.Set;
 import org.opendaylight.mdsal.binding.generator.impl.reactor.CollisionDomain.Member;
 import org.opendaylight.mdsal.binding.generator.impl.rt.DefaultKeyRuntimeType;
 import org.opendaylight.mdsal.binding.model.api.GeneratedTransferObject;
-import org.opendaylight.mdsal.binding.model.api.GeneratedType;
 import org.opendaylight.mdsal.binding.model.api.Type;
-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;
 import org.opendaylight.mdsal.binding.model.ri.BindingTypes;
 import org.opendaylight.mdsal.binding.runtime.api.KeyRuntimeType;
@@ -47,17 +43,16 @@ final class KeyGenerator extends AbstractExplicitGenerator<KeyEffectiveStatement
 
     @Override
     GeneratedTransferObject createTypeImpl(final TypeBuilderFactory builderFactory) {
-        final GeneratedTOBuilder builder = builderFactory.newGeneratedTOBuilder(typeName());
+        final var builder = builderFactory.newGeneratedTOBuilder(typeName());
 
         builder.addImplementsType(BindingTypes.identifier(Type.of(listGen.typeName())));
 
-        final Set<QName> leafNames = statement().argument();
-        for (Generator listChild : listGen) {
-            if (listChild instanceof LeafGenerator) {
-                final LeafGenerator leafGen = (LeafGenerator) listChild;
+        final var leafNames = statement().argument();
+        for (var listChild : listGen) {
+            if (listChild instanceof LeafGenerator leafGen) {
                 final QName qname = leafGen.statement().argument();
                 if (leafNames.contains(qname)) {
-                    final GeneratedPropertyBuilder prop = builder
+                    final var prop = builder
                         .addProperty(BindingMapping.getPropertyName(qname.getLocalName()))
                         .setReturnType(leafGen.methodReturnType(builderFactory))
                         .setReadOnly(true);
@@ -77,11 +72,6 @@ final class KeyGenerator extends AbstractExplicitGenerator<KeyEffectiveStatement
         return builder.build();
     }
 
-    @Override
-    GeneratedType runtimeJavaType() {
-        return generatedType().orElse(null);
-    }
-
     @Override
     KeyRuntimeType createExternalRuntimeType(final Type type) {
         verify(type instanceof GeneratedTransferObject, "Unexpected type %s", type);

diff --git a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/OpaqueObjectGenerator.java b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/OpaqueObjectGenerator.java
index ce10cd1877d9c7f0b7d3a6fef67420ed444abf6d..a7175644333c672ad5e1ca0eb25352757c38dff2 100644 (file)
--- a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/OpaqueObjectGenerator.java
+++ b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/OpaqueObjectGenerator.java
@@ -14,7 +14,6 @@ import org.opendaylight.mdsal.binding.generator.impl.rt.DefaultAnydataRuntimeTyp
 import org.opendaylight.mdsal.binding.generator.impl.rt.DefaultAnyxmlRuntimeType;
 import org.opendaylight.mdsal.binding.model.api.GeneratedType;
 import org.opendaylight.mdsal.binding.model.api.Type;
-import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
 import org.opendaylight.mdsal.binding.model.ri.BindingTypes;
 import org.opendaylight.mdsal.binding.runtime.api.AnydataRuntimeType;
@@ -75,13 +74,13 @@ abstract class OpaqueObjectGenerator<S extends DataTreeEffectiveStatement<?>, R
 
     @Override
     GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
-        final GeneratedTypeBuilder builder = builderFactory.newGeneratedTypeBuilder(typeName());
+        final var builder = builderFactory.newGeneratedTypeBuilder(typeName());
         builder.addImplementsType(BindingTypes.opaqueObject(builder));
         addImplementsChildOf(builder);
         defaultImplementedInterace(builder);
         annotateDeprecatedIfNecessary(builder);
 
-        final ModuleGenerator module = currentModule();
+        final var module = currentModule();
         module.addQNameConstant(builder, localName());
 
         builderFactory.addCodegenInformation(module, statement(), builder);
@@ -96,11 +95,6 @@ abstract class OpaqueObjectGenerator<S extends DataTreeEffectiveStatement<?>, R
         constructRequireImpl(builder, returnType);
     }
 
-    @Override
-    final GeneratedType runtimeJavaType() {
-        return generatedType().orElse(null);
-    }
-
     @Override
     final @NonNull R createExternalRuntimeType(final Type type) {
         verify(type instanceof GeneratedType, "Unexpected type %s", type);