2 * Copyright (c) 2021 PANTHEON.tech, s.r.o. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.mdsal.binding.generator.impl.reactor;
10 import static com.google.common.base.Verify.verify;
11 import static com.google.common.base.Verify.verifyNotNull;
13 import java.util.Comparator;
14 import java.util.Iterator;
15 import org.eclipse.jdt.annotation.NonNull;
16 import org.opendaylight.mdsal.binding.generator.impl.reactor.CollisionDomain.Member;
17 import org.opendaylight.mdsal.binding.model.api.GeneratedType;
18 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
19 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
20 import org.opendaylight.mdsal.binding.model.util.BindingTypes;
21 import org.opendaylight.yangtools.odlext.model.api.AugmentIdentifierEffectiveStatement;
22 import org.opendaylight.yangtools.yang.common.AbstractQName;
23 import org.opendaylight.yangtools.yang.common.QName;
24 import org.opendaylight.yangtools.yang.model.api.stmt.AugmentEffectiveStatement;
25 import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
28 * A generator corresponding to a {@code augment} statement. This class is further specialized for the two distinct uses
31 abstract class AbstractAugmentGenerator extends AbstractCompositeGenerator<AugmentEffectiveStatement> {
33 * Comparator comparing target path length. This is useful for quickly determining order the order in which two
34 * (or more) {@link AbstractAugmentGenerator}s need to be evaluated. This is necessary when augments are layered on
53 * Evaluating these in the order of increasing argument component count solves this without having to perform a full
57 * Another problem we are solving here is augmentation target stability, as the declared order in YANG text may
58 * change, which does not really change the semantics. If we only relied on length of argument, such a move would
59 * result in changing the results of {@link #createMember(CollisionDomain)} and make upgrades rather unpredictable.
60 * We solve this by using {@link QName#compareTo(QName)} to determine order.
62 static final Comparator<? super AbstractAugmentGenerator> COMPARATOR = (o1, o2) -> {
63 final Iterator<QName> thisIt = o1.statement().argument().getNodeIdentifiers().iterator();
64 final Iterator<QName> otherIt = o2.statement().argument().getNodeIdentifiers().iterator();
66 while (thisIt.hasNext()) {
67 if (!otherIt.hasNext()) {
71 final int comp = thisIt.next().compareTo(otherIt.next());
77 return otherIt.hasNext() ? -1 : 0;
80 private AbstractCompositeGenerator<?> targetGen;
82 AbstractAugmentGenerator(final AugmentEffectiveStatement statement, final AbstractCompositeGenerator<?> parent) {
83 super(statement, parent);
87 final void pushToInference(final SchemaInferenceStack dataTree) {
88 dataTree.enterSchemaTree(statement().argument());
92 final AbstractQName localName() {
93 throw new UnsupportedOperationException();
97 ClassPlacement classPlacement() {
98 // if the target is a choice we are NOT creating an explicit augmentation, but we still need a phantom to
99 // reserve the appropriate package name
100 final AbstractCompositeGenerator<?> target = targetGenerator();
101 return target instanceof ChoiceGenerator ? ClassPlacement.PHANTOM : super.classPlacement();
105 final Member createMember(final CollisionDomain domain) {
106 final AbstractQName explicitIdentifier = statement()
107 .findFirstEffectiveSubstatementArgument(AugmentIdentifierEffectiveStatement.class).orElse(null);
108 if (explicitIdentifier != null) {
109 return domain.addPrimary(this, new CamelCaseNamingStrategy(StatementNamespace.DEFAULT, explicitIdentifier));
112 final Member target = targetGenerator().getMember();
114 for (Generator gen : getParent()) {
118 if (gen instanceof AbstractAugmentGenerator
119 && target.equalRoot(((AbstractAugmentGenerator) gen).targetGenerator().getMember())) {
124 return domain.addSecondary(this, target, String.valueOf(offset), statement().argument());
128 final GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
129 final GeneratedTypeBuilder builder = builderFactory.newGeneratedTypeBuilder(typeName());
131 builder.addImplementsType(BindingTypes.augmentation(targetGenerator().getGeneratedType(builderFactory)));
132 addUsesInterfaces(builder, builderFactory);
133 addConcreteInterfaceMethods(builder);
135 addGetterMethods(builder, builderFactory);
136 annotateDeprecatedIfNecessary(builder);
138 return builder.build();
142 final void addAsGetterMethod(final GeneratedTypeBuilderBase<?> builder, final TypeBuilderFactory builderFactory) {
143 // Augments are never added as getters, as they are handled via Augmentable mechanics
146 final void setTargetGenerator(final AbstractExplicitGenerator<?> target) {
147 verify(target instanceof AbstractCompositeGenerator, "Unexpected target %s", target);
148 targetGen = (AbstractCompositeGenerator<?>) target;
149 targetGen.addAugment(this);
152 final @NonNull AbstractCompositeGenerator<?> targetGenerator() {
153 final AbstractCompositeGenerator<?> existing = targetGen;
154 if (existing != null) {
155 return existing.getOriginal();
158 loadTargetGenerator();
159 return verifyNotNull(targetGen, "No target for %s", this).getOriginal();
162 abstract void loadTargetGenerator();