From 01dd79f2bff48d983d808060b2328c146f97ca70 Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Sat, 16 Dec 2023 13:16:31 +0100 Subject: [PATCH] Modernize GeneratorReactor Use local variable type inference and instanceof patterns. Change-Id: I2f9222d0e6535bfaf7655ef6afccbb2ef431ddd4 Signed-off-by: Robert Varga --- .../impl/reactor/GeneratorReactor.java | 72 ++++++++++--------- 1 file changed, 38 insertions(+), 34 deletions(-) diff --git a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/GeneratorReactor.java b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/GeneratorReactor.java index 2907f0e232..fde702375b 100644 --- a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/GeneratorReactor.java +++ b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/GeneratorReactor.java @@ -7,7 +7,6 @@ */ package org.opendaylight.mdsal.binding.generator.impl.reactor; -import static com.google.common.base.Preconditions.checkState; import static com.google.common.base.Verify.verify; import static com.google.common.base.Verify.verifyNotNull; import static java.util.Objects.requireNonNull; @@ -18,7 +17,6 @@ import com.google.common.collect.Maps; import java.util.ArrayDeque; import java.util.ArrayList; import java.util.Deque; -import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.function.Function; @@ -37,7 +35,6 @@ import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext; import org.opendaylight.yangtools.yang.model.api.Module; import org.opendaylight.yangtools.yang.model.api.PathExpression; import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement; -import org.opendaylight.yangtools.yang.model.api.stmt.ModuleEffectiveStatement; import org.opendaylight.yangtools.yang.model.ri.type.TypeBuilder; import org.opendaylight.yangtools.yang.model.spi.ModuleDependencySort; import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack; @@ -121,7 +118,7 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable } // Start measuring time... - final Stopwatch sw = Stopwatch.createStarted(); + final var sw = Stopwatch.createStarted(); // Step 1a: Walk all composite generators and resolve 'uses' statements to the corresponding grouping generator, // establishing implied inheritance. During this walk we maintain 'stack' to aid this process. @@ -133,14 +130,14 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable // step of each 'augment' statement to its corresponding instantiated site. // Then start all UsesAugmentGenerators' target resolution. final var augments = new ArrayList(); - for (ModuleGenerator module : children) { - for (Generator gen : module) { + for (var module : children) { + for (var gen : module) { if (gen instanceof ModuleAugmentGenerator moduleGen) { augments.add(moduleGen.startLinkage(this)); } } } - for (ModuleGenerator module : children) { + for (var module : children) { module.startUsesAugmentLinkage(augments); } LOG.trace("Processing linkage of {} augment generators", augments.size()); @@ -148,7 +145,7 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable // Step 1c: Establish linkage along the reverse uses/augment axis. This is needed to route generated type // manifestations (isAddedByUses/isAugmenting) to their type generation sites. Since generator tree // iteration order does not match dependencies, we may need to perform multiple passes. - for (ModuleGenerator module : children) { + for (var module : children) { verify(module.linkOriginalGenerator(), "Module %s failed to link", module); } @@ -213,12 +210,12 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable * algorithm in CollisionDomain. Note that we may need to walk the domains multiple times, as the process of * solving a domain may cause another domain's solution to be invalidated. */ - final List domains = new ArrayList<>(); + final var domains = new ArrayList(); collectCollisionDomains(domains, children); boolean haveUnresolved; do { haveUnresolved = false; - for (CollisionDomain domain : domains) { + for (var domain : domains) { if (domain.findSolution()) { haveUnresolved = true; } @@ -230,7 +227,7 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable // We have now properly cross-linked all generators and have assigned their naming roots, so from this point // it looks as though we are performing a simple recursive execution. In reality, though, the actual path taken // through generators is dictated by us as well as generator linkage. - for (ModuleGenerator module : children) { + for (var module : children) { module.ensureType(builderFactory); } @@ -241,7 +238,7 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable private void collectCollisionDomains(final List result, final Iterable parent) { - for (Generator gen : parent) { + for (var gen : parent) { gen.ensureMember(); collectCollisionDomains(result, gen); if (gen instanceof AbstractCompositeGenerator compositeGen) { @@ -256,14 +253,16 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable LOG.trace("Searching for tree-scoped argument {} at {}", argument, stack); // Check if the requested QName matches current module, if it does search the stack - final Iterable last = stack.getLast(); - verify(last instanceof ModuleGenerator, "Unexpected last stack item %s", last); + final var last = stack.getLast(); + if (!(last instanceof ModuleGenerator lastModule)) { + throw new VerifyException("Unexpected last stack item " + last); + } - if (argument.getModule().equals(((ModuleGenerator) last).statement().localQNameModule())) { - for (Iterable ancestor : stack) { - for (Generator child : ancestor) { + if (argument.getModule().equals(lastModule.statement().localQNameModule())) { + for (var ancestor : stack) { + for (var child : ancestor) { if (type.isInstance(child)) { - final G cast = type.cast(child); + final var cast = type.cast(child); if (argument.equals(cast.statement().argument())) { LOG.trace("Found matching {}", child); return cast; @@ -272,11 +271,11 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable } } } else { - final ModuleGenerator module = generators.get(argument.getModule()); + final var module = generators.get(argument.getModule()); if (module != null) { - for (Generator child : module) { + for (var child : module) { if (type.isInstance(child)) { - final G cast = type.cast(child); + final var cast = type.cast(child); if (argument.equals(cast.statement().argument())) { LOG.trace("Found matching {}", child); return cast; @@ -291,8 +290,10 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable @Override ModuleGenerator resolveModule(final QNameModule namespace) { - final ModuleGenerator module = generators.get(requireNonNull(namespace)); - checkState(module != null, "Failed to find module for %s", namespace); + final var module = generators.get(requireNonNull(namespace)); + if (module == null) { + throw new IllegalStateException("Failed to find module for " + namespace); + } return module; } @@ -302,15 +303,18 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable verify(inferenceStack.isEmpty(), "Unexpected data tree state %s", inferenceStack); try { // Populate inferenceStack with a grouping + data tree equivalent of current stack's state. - final Iterator> it = stack.descendingIterator(); + final var it = stack.descendingIterator(); // Skip first item, as it points to our children verify(it.hasNext(), "Unexpected empty stack"); it.next(); while (it.hasNext()) { - final Iterable item = it.next(); - verify(item instanceof Generator, "Unexpected stack item %s", item); - ((Generator) item).pushToInference(inferenceStack); + final var item = it.next(); + if (item instanceof Generator generator) { + generator.pushToInference(inferenceStack); + } else { + throw new VerifyException("Unexpected stack item " + item); + } } return inferenceStack.inGrouping() ? lenientResolveLeafref(path) : strictResolvePath(path); @@ -341,13 +345,13 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable // Map a statement to the corresponding generator private @NonNull AbstractTypeAwareGenerator mapToGenerator() { // Some preliminaries first: we need to be in the correct module to walk the path - final ModuleEffectiveStatement module = inferenceStack.currentModule(); - final ModuleGenerator gen = verifyNotNull(generators.get(module.localQNameModule()), + final var module = inferenceStack.currentModule(); + final var gen = verifyNotNull(generators.get(module.localQNameModule()), "Cannot find generator for %s", module); // Now kick of the search - final List> stmtPath = inferenceStack.toInference().statementPath(); - final AbstractExplicitGenerator found = gen.findGenerator(stmtPath); + final var stmtPath = inferenceStack.toInference().statementPath(); + final var found = gen.findGenerator(stmtPath); if (found instanceof AbstractTypeAwareGenerator typeAware) { return typeAware; } @@ -356,7 +360,7 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable // Note: unlike other methods, this method pushes matching child to the stack private void linkUsesDependencies(final Iterable parent) { - for (Generator child : parent) { + for (var child : parent) { if (child instanceof AbstractCompositeGenerator composite) { LOG.trace("Visiting composite {}", composite); stack.push(composite); @@ -392,7 +396,7 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable } private void linkDependencies(final Iterable parent) { - for (Generator child : parent) { + for (var child : parent) { if (child instanceof AbstractDependentGenerator dependent) { dependent.linkDependencies(this); } else if (child instanceof AbstractCompositeGenerator) { @@ -404,7 +408,7 @@ public final class GeneratorReactor extends GeneratorContext implements Mutable } private void bindTypeDefinition(final Iterable parent) { - for (Generator child : parent) { + for (var child : parent) { stack.push(child); if (child instanceof AbstractTypeObjectGenerator typeObject) { typeObject.bindTypeDefinition(this); -- 2.36.6