binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractAugmentGenerator.java

   1 /*
   2  * Copyright (c) 2021 PANTHEON.tech, s.r.o. and others.  All rights reserved.
   3  *
   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
   7  */
   8 package org.opendaylight.mdsal.binding.generator.impl.reactor;
   9
  10 import static com.google.common.base.Verify.verify;
  11 import static com.google.common.base.Verify.verifyNotNull;
  12 import static java.util.Objects.requireNonNull;
  13
  14 import java.util.Comparator;
  15 import java.util.Iterator;
  16 import java.util.List;
  17 import org.eclipse.jdt.annotation.NonNull;
  18 import org.opendaylight.mdsal.binding.generator.impl.reactor.CollisionDomain.Member;
  19 import org.opendaylight.mdsal.binding.generator.impl.rt.DefaultAugmentRuntimeType;
  20 import org.opendaylight.mdsal.binding.model.api.GeneratedType;
  21 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilder;
  22 import org.opendaylight.mdsal.binding.model.api.type.builder.GeneratedTypeBuilderBase;
  23 import org.opendaylight.mdsal.binding.model.ri.BindingTypes;
  24 import org.opendaylight.mdsal.binding.runtime.api.AugmentRuntimeType;
  25 import org.opendaylight.mdsal.binding.runtime.api.RuntimeType;
  26 import org.opendaylight.yangtools.odlext.model.api.AugmentIdentifierEffectiveStatement;
  27 import org.opendaylight.yangtools.yang.common.AbstractQName;
  28 import org.opendaylight.yangtools.yang.common.QName;
  29 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
  30 import org.opendaylight.yangtools.yang.model.api.stmt.AugmentEffectiveStatement;
  31 import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeAwareEffectiveStatement;
  32 import org.opendaylight.yangtools.yang.model.util.SchemaInferenceStack;
  33
  34 /**
  35  * A generator corresponding to a {@code augment} statement. This class is further specialized for the two distinct uses
  36  * an augment is used.
  37  */
  38 abstract class AbstractAugmentGenerator
  39         extends AbstractCompositeGenerator<AugmentEffectiveStatement, AugmentRuntimeType> {
  40     /**
  41      * Comparator comparing target path length. This is useful for quickly determining order the order in which two
  42      * (or more) {@link AbstractAugmentGenerator}s need to be evaluated. This is necessary when augments are layered on
  43      * top of each other:
  44      *
  45      * <p>
  46      * <pre>
  47      *   <code>
  48      *     container foo;
  49      *
  50      *     augment /foo/bar {
  51      *       container baz;
  52      *     }
  53      *
  54      *     augment /foo {
  55      *       container bar;
  56      *     }
  57      *   </code>
  58      * </pre>
  59      *
  60      * <p>
  61      * Evaluating these in the order of increasing argument component count solves this without having to perform a full
  62      * analysis.
  63      *
  64      * <p>
  65      * Another problem we are solving here is augmentation target stability, as the declared order in YANG text may
  66      * change, which does not really change the semantics. If we only relied on length of argument, such a move would
  67      * result in changing the results of {@link #createMember(CollisionDomain)} and make upgrades rather unpredictable.
  68      * We solve this by using {@link QName#compareTo(QName)} to determine order.
  69      */
  70     static final Comparator<? super AbstractAugmentGenerator> COMPARATOR = (o1, o2) -> {
  71         final Iterator<QName> thisIt = o1.statement().argument().getNodeIdentifiers().iterator();
  72         final Iterator<QName> otherIt = o2.statement().argument().getNodeIdentifiers().iterator();
  73
  74         while (thisIt.hasNext()) {
  75             if (!otherIt.hasNext()) {
  76                 return 1;
  77             }
  78
  79             final int comp = thisIt.next().compareTo(otherIt.next());
  80             if (comp != 0) {
  81                 return comp;
  82             }
  83         }
  84
  85         return otherIt.hasNext() ? -1 : 0;
  86     };
  87
  88     private AugmentEffectiveStatement effectiveStatement;
  89     private AbstractCompositeGenerator<?, ?> targetGen;
  90
  91     AbstractAugmentGenerator(final AugmentEffectiveStatement statement, final AbstractCompositeGenerator<?, ?> parent) {
  92         super(statement, parent);
  93     }
  94
  95     @Override
  96     final void pushToInference(final SchemaInferenceStack dataTree) {
  97         dataTree.enterSchemaTree(statement().argument());
  98     }
  99
 100     @Override
 101     final AbstractQName localName() {
 102         throw new UnsupportedOperationException();
 103     }
 104
 105     @Override
 106     ClassPlacement classPlacement() {
 107         // if the target is a choice we are NOT creating an explicit augmentation, but we still need a phantom to
 108         // reserve the appropriate package name
 109         final AbstractCompositeGenerator<?, ?> target = targetGenerator();
 110         return target instanceof ChoiceGenerator ? ClassPlacement.PHANTOM : super.classPlacement();
 111     }
 112
 113     @Override
 114     final Member createMember(final CollisionDomain domain) {
 115         final AbstractQName explicitIdentifier = statement()
 116             .findFirstEffectiveSubstatementArgument(AugmentIdentifierEffectiveStatement.class).orElse(null);
 117         if (explicitIdentifier != null) {
 118             return domain.addPrimary(this, new CamelCaseNamingStrategy(StatementNamespace.DEFAULT, explicitIdentifier));
 119         }
 120
 121         final Member target = targetGenerator().getMember();
 122         int offset = 1;
 123         for (Generator gen : getParent()) {
 124             if (gen == this) {
 125                 break;
 126             }
 127             if (gen instanceof AbstractAugmentGenerator
 128                 && target.equalRoot(((AbstractAugmentGenerator) gen).targetGenerator().getMember())) {
 129                 offset++;
 130             }
 131         }
 132
 133         return domain.addSecondary(this, target, String.valueOf(offset), statement().argument());
 134     }
 135
 136     @Override
 137     final GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
 138         final GeneratedTypeBuilder builder = builderFactory.newGeneratedTypeBuilder(typeName());
 139
 140         builder.addImplementsType(BindingTypes.augmentation(targetGenerator().getGeneratedType(builderFactory)));
 141         addUsesInterfaces(builder, builderFactory);
 142         addConcreteInterfaceMethods(builder);
 143
 144         addGetterMethods(builder, builderFactory);
 145         annotateDeprecatedIfNecessary(builder);
 146
 147         return builder.build();
 148     }
 149
 150     @Override
 151     final AugmentEffectiveStatement effectiveStatement() {
 152         return verifyNotNull(effectiveStatement, "Effective statement not set in %s", this);
 153     }
 154
 155     @Override
 156     final AugmentRuntimeType createRuntimeType(final GeneratedType type, final AugmentEffectiveStatement statement,
 157             final List<RuntimeType> children, final List<AugmentRuntimeType> augments) {
 158         verify(statement instanceof TargetAugmentEffectiveStatement, "Unexpected statement %s", statement);
 159         return new DefaultAugmentRuntimeType(type, ((TargetAugmentEffectiveStatement) statement).delegate(), children,
 160             augments);
 161     }
 162
 163     @Override
 164     final void addAsGetterMethod(final GeneratedTypeBuilderBase<?> builder, final TypeBuilderFactory builderFactory) {
 165         // Augments are never added as getters, as they are handled via Augmentable mechanics
 166     }
 167
 168     final void setTargetGenerator(final AbstractCompositeGenerator<?, ?> targetGenerator) {
 169         verify(targetGen == null, "Attempted to relink %s, already have target %s", this, targetGen);
 170         targetGen = requireNonNull(targetGenerator);
 171     }
 172
 173     final @NonNull AbstractCompositeGenerator<?, ?> targetGenerator() {
 174         return verifyNotNull(targetGen, "No target for %s", this);
 175     }
 176
 177     final void setTargetStatement(final EffectiveStatement<?, ?> targetStatement) {
 178         verify(targetStatement instanceof SchemaTreeAwareEffectiveStatement, "Unexpected target statement %s",
 179             targetStatement);
 180         effectiveStatement = new TargetAugmentEffectiveStatement(statement(),
 181             (SchemaTreeAwareEffectiveStatement<?, ?>) targetStatement);
 182     }
 183 }