X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=binding%2Fmdsal-binding-generator%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fmdsal%2Fbinding%2Fgenerator%2Fimpl%2Freactor%2FAbstractCompositeGenerator.java;h=5d74b61ad083ffde5e27683cd134c432daa13ada;hb=b1e88583f0d16ef8b8dab5d43f61978e064e27e5;hp=769830433f7ff6ebd94c6e29b5ef573818c9cdbc;hpb=0ee55d1f9da11dd03ff05fc67d10cbcbfe63fd2c;p=mdsal.git 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 769830433f..5d74b61ad0 100644 --- 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 @@ -14,17 +14,18 @@ import static java.util.Objects.requireNonNull; import java.util.ArrayList; import java.util.Iterator; import java.util.List; +import java.util.Set; import java.util.stream.Collectors; import org.eclipse.jdt.annotation.NonNull; import org.eclipse.jdt.annotation.Nullable; 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.Type; import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder; import org.opendaylight.mdsal.binding.model.ri.BindingTypes; import org.opendaylight.mdsal.binding.runtime.api.CompositeRuntimeType; import org.opendaylight.mdsal.binding.runtime.api.RuntimeType; +import org.opendaylight.yangtools.rfc8040.model.api.YangDataEffectiveStatement; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.model.api.AddedByUsesAware; import org.opendaylight.yangtools.yang.model.api.CopyableNode; @@ -36,6 +37,7 @@ import org.opendaylight.yangtools.yang.model.api.stmt.AugmentEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.CaseEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ChoiceEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.ContainerEffectiveStatement; +import org.opendaylight.yangtools.yang.model.api.stmt.FeatureEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.GroupingEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.IdentityEffectiveStatement; import org.opendaylight.yangtools.yang.model.api.stmt.InputEffectiveStatement; @@ -160,11 +162,6 @@ public abstract class AbstractCompositeGenerator augments() { return augments; } @@ -175,23 +172,14 @@ public abstract class AbstractCompositeGenerator createBuilder(S statement); @Override - final R createInternalRuntimeType(final ChildLookup lookup, final S statement, final Type type) { - verify(type instanceof GeneratedType, "Unexpected type %s", type); - return createBuilder(statement) - .fillTypes(lookup.inStatement(statement), this) - .build((GeneratedType) type); + final R createInternalRuntimeType(final AugmentResolver resolver, final S statement, final Type type) { + return createBuilder(statement).populate(resolver, this).build(verifyGeneratedType(type)); } @Override @@ -206,19 +194,19 @@ public abstract class AbstractCompositeGenerator findGenerator(final MatchStrategy childStrategy, // TODO: Wouldn't this method be nicer with Deque> ? final List> 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) { // Final step, return child return ret; } - if (ret instanceof AbstractCompositeGenerator) { + if (ret instanceof AbstractCompositeGenerator composite) { // We know how to descend down - return ((AbstractCompositeGenerator) ret).findGenerator(childStrategy, stmtPath, next); + return composite.findGenerator(childStrategy, stmtPath, next); } // Yeah, don't know how to continue here return null; @@ -261,18 +249,17 @@ public abstract class AbstractCompositeGenerator tmp = new ArrayList<>(); - for (EffectiveStatement stmt : statement().effectiveSubstatements()) { - if (stmt instanceof UsesEffectiveStatement) { - final UsesEffectiveStatement uses = (UsesEffectiveStatement) stmt; - final GroupingGenerator grouping = context.resolveTreeScoped(GroupingGenerator.class, uses.argument()); + final var tmp = new ArrayList(); + for (var stmt : statement().effectiveSubstatements()) { + if (stmt instanceof UsesEffectiveStatement uses) { + 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); } } } @@ -280,13 +267,36 @@ public abstract class AbstractCompositeGenerator skippedChildren) { + // Link to used groupings IFF we have a corresponding generated Java class + switch (classPlacement()) { + case NONE: + case PHANTOM: + break; + default: + for (var grouping : groupings()) { + grouping.addUser(this); + } + } + + for (var child : childGenerators) { + if (child instanceof GroupingGenerator grouping) { + skippedChildren.add(grouping); + } else if (child instanceof AbstractCompositeGenerator composite) { + composite.linkUsedGroupings(skippedChildren); + } + } + } + final void startUsesAugmentLinkage(final List 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); } } } @@ -322,19 +332,16 @@ public abstract class AbstractCompositeGenerator) child).linkOriginalGenerator()) { - progress = LinkageProgress.SOME; - it.remove(); - - // If this is a composite generator we need to process is further - if (child instanceof AbstractCompositeGenerator) { - if (unlinkedComposites.isEmpty()) { - unlinkedComposites = new ArrayList<>(); - } - unlinkedComposites.add((AbstractCompositeGenerator) child); + if (it.next() instanceof AbstractExplicitGenerator explicit && explicit.linkOriginalGenerator()) { + progress = LinkageProgress.SOME; + it.remove(); + + // If this is a composite generator we need to process is further + if (explicit instanceof AbstractCompositeGenerator composite) { + if (unlinkedComposites.isEmpty()) { + unlinkedComposites = new ArrayList<>(); } + unlinkedComposites.add(composite); } } } @@ -400,7 +407,7 @@ public abstract class AbstractCompositeGenerator findSchemaTreeGenerator(final QName qname) { - final AbstractExplicitGenerator found = super.findSchemaTreeGenerator(qname); + final var found = super.findSchemaTreeGenerator(qname); return found != null ? found : findInferredGenerator(qname); } @@ -415,7 +422,7 @@ public abstract class AbstractCompositeGenerator) 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); } @@ -484,70 +491,68 @@ public abstract class AbstractCompositeGenerator(); for (var stmt : statement.effectiveSubstatements()) { - if (stmt instanceof ActionEffectiveStatement) { - if (!isAugmenting(stmt)) { - tmp.add(new ActionGenerator((ActionEffectiveStatement) stmt, this)); + if (stmt instanceof ActionEffectiveStatement action) { + if (!isAugmenting(action)) { + tmp.add(new ActionGenerator(action, this)); } - } else if (stmt instanceof AnydataEffectiveStatement) { - if (!isAugmenting(stmt)) { - tmp.add(new OpaqueObjectGenerator.Anydata((AnydataEffectiveStatement) stmt, this)); + } else if (stmt instanceof AnydataEffectiveStatement anydata) { + if (!isAugmenting(anydata)) { + tmp.add(new OpaqueObjectGenerator.Anydata(anydata, this)); } - } else if (stmt instanceof AnyxmlEffectiveStatement) { - if (!isAugmenting(stmt)) { - tmp.add(new OpaqueObjectGenerator.Anyxml((AnyxmlEffectiveStatement) stmt, this)); + } else if (stmt instanceof AnyxmlEffectiveStatement anyxml) { + if (!isAugmenting(anyxml)) { + tmp.add(new OpaqueObjectGenerator.Anyxml(anyxml, this)); } - } else if (stmt instanceof CaseEffectiveStatement) { - tmp.add(new CaseGenerator((CaseEffectiveStatement) stmt, this)); - } else if (stmt instanceof ChoiceEffectiveStatement) { + } else if (stmt instanceof CaseEffectiveStatement cast) { + tmp.add(new CaseGenerator(cast, this)); + } else if (stmt instanceof ChoiceEffectiveStatement choice) { // FIXME: use isOriginalDeclaration() ? - if (!isAddedByUses(stmt)) { - tmp.add(new ChoiceGenerator((ChoiceEffectiveStatement) stmt, this)); + if (!isAddedByUses(choice)) { + tmp.add(new ChoiceGenerator(choice, this)); } - } else if (stmt instanceof ContainerEffectiveStatement) { - if (isOriginalDeclaration(stmt)) { - tmp.add(new ContainerGenerator((ContainerEffectiveStatement) stmt, this)); + } else if (stmt instanceof ContainerEffectiveStatement container) { + if (isOriginalDeclaration(container)) { + tmp.add(new ContainerGenerator(container, this)); } - } else if (stmt instanceof GroupingEffectiveStatement) { - tmp.add(new GroupingGenerator((GroupingEffectiveStatement) stmt, this)); - } else if (stmt instanceof IdentityEffectiveStatement) { - tmp.add(new IdentityGenerator((IdentityEffectiveStatement) stmt, this)); - } else if (stmt instanceof InputEffectiveStatement) { - final var cast = (InputEffectiveStatement) stmt; - // FIXME: do not generate legacy RPC layout - tmp.add(this instanceof RpcGenerator ? new RpcInputGenerator(cast, this) - : new InputGenerator(cast, this)); - } else if (stmt instanceof LeafEffectiveStatement) { - if (!isAugmenting(stmt)) { - tmp.add(new LeafGenerator((LeafEffectiveStatement) stmt, this)); + } else if (stmt instanceof FeatureEffectiveStatement feature && this instanceof ModuleGenerator parent) { + tmp.add(new FeatureGenerator(feature, parent)); + } else if (stmt instanceof GroupingEffectiveStatement grouping) { + tmp.add(new GroupingGenerator(grouping, this)); + } else if (stmt instanceof IdentityEffectiveStatement identity) { + tmp.add(new IdentityGenerator(identity, this)); + } else if (stmt instanceof InputEffectiveStatement input) { + tmp.add(new InputGenerator(input, this)); + } else if (stmt instanceof LeafEffectiveStatement leaf) { + if (!isAugmenting(leaf)) { + tmp.add(new LeafGenerator(leaf, this)); } - } else if (stmt instanceof LeafListEffectiveStatement) { - if (!isAugmenting(stmt)) { - tmp.add(new LeafListGenerator((LeafListEffectiveStatement) stmt, this)); + } else if (stmt instanceof LeafListEffectiveStatement leafList) { + if (!isAugmenting(leafList)) { + tmp.add(new LeafListGenerator(leafList, this)); } - } else if (stmt instanceof ListEffectiveStatement) { - if (isOriginalDeclaration(stmt)) { - final ListGenerator listGen = new ListGenerator((ListEffectiveStatement) stmt, this); + } else if (stmt instanceof ListEffectiveStatement list) { + if (isOriginalDeclaration(list)) { + final var listGen = new ListGenerator(list, this); tmp.add(listGen); - final KeyGenerator keyGen = listGen.keyGenerator(); + final var keyGen = listGen.keyGenerator(); if (keyGen != null) { tmp.add(keyGen); } } - } else if (stmt instanceof NotificationEffectiveStatement) { - if (!isAugmenting(stmt)) { - tmp.add(new NotificationGenerator((NotificationEffectiveStatement) stmt, this)); + } else if (stmt instanceof NotificationEffectiveStatement notification) { + if (!isAugmenting(notification)) { + tmp.add(new NotificationGenerator(notification, this)); + } + } else if (stmt instanceof OutputEffectiveStatement output) { + tmp.add(new OutputGenerator(output, this)); + } else if (stmt instanceof RpcEffectiveStatement rpc) { + if (this instanceof ModuleGenerator module) { + tmp.add(new RpcGenerator(rpc, module)); } - } else if (stmt instanceof OutputEffectiveStatement) { - final var cast = (OutputEffectiveStatement) stmt; - // FIXME: do not generate legacy RPC layout - tmp.add(this instanceof RpcGenerator ? new RpcOutputGenerator(cast, this) - : new OutputGenerator(cast, this)); - } else if (stmt instanceof RpcEffectiveStatement) { - tmp.add(new RpcGenerator((RpcEffectiveStatement) stmt, this)); - } else if (stmt instanceof TypedefEffectiveStatement) { - tmp.add(new TypedefGenerator((TypedefEffectiveStatement) stmt, this)); - } else if (stmt instanceof AugmentEffectiveStatement) { + } else if (stmt instanceof TypedefEffectiveStatement typedef) { + tmp.add(new TypedefGenerator(typedef, this)); + } else if (stmt instanceof AugmentEffectiveStatement augment) { // FIXME: MDSAL-695: So here we are ignoring any augment which is not in a module, while the 'uses' // processing takes care of the rest. There are two problems here: // @@ -562,16 +567,19 @@ public abstract class AbstractCompositeGenerator original map we provide to BindingRuntimeTypes. - if (this instanceof ModuleGenerator) { - tmpAug.add(new ModuleAugmentGenerator((AugmentEffectiveStatement) stmt, this)); + if (this instanceof ModuleGenerator module) { + tmpAug.add(new ModuleAugmentGenerator(augment, module)); } - } else if (stmt instanceof UsesEffectiveStatement) { - final UsesEffectiveStatement uses = (UsesEffectiveStatement) stmt; - for (EffectiveStatement usesSub : uses.effectiveSubstatements()) { - if (usesSub instanceof AugmentEffectiveStatement) { - tmpAug.add(new UsesAugmentGenerator((AugmentEffectiveStatement) usesSub, uses, this)); + } else if (stmt instanceof UsesEffectiveStatement uses) { + for (var usesSub : uses.effectiveSubstatements()) { + if (usesSub instanceof AugmentEffectiveStatement usesAug) { + tmpAug.add(new UsesAugmentGenerator(usesAug, uses, this)); } } + } else if (stmt instanceof YangDataEffectiveStatement yangData) { + if (this instanceof ModuleGenerator moduleGen) { + tmp.add(YangDataGenerator.of(yangData, moduleGen)); + } } else { LOG.trace("Ignoring statement {}", stmt); } @@ -583,48 +591,24 @@ public abstract class AbstractCompositeGenerator notifs = tmp.stream() - .filter(NotificationGenerator.class::isInstance) - .map(NotificationGenerator.class::cast) - .collect(Collectors.toUnmodifiableList()); - if (!notifs.isEmpty()) { - tmp.add(new NotificationServiceGenerator(moduleGen, notifs)); - } - - final List rpcs = tmp.stream() - .filter(RpcGenerator.class::isInstance) - .map(RpcGenerator.class::cast) - .collect(Collectors.toUnmodifiableList()); - if (!rpcs.isEmpty()) { - tmp.add(new RpcServiceGenerator(moduleGen, rpcs)); - } - } - return List.copyOf(tmp); } // 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()) { - return false; - } + if (stmt instanceof AddedByUsesAware aware + && (aware.isAddedByUses() || aware instanceof CopyableNode copyable && copyable.isAugmenting())) { + return false; } return true; } 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(); } }