Generate javadoc for augments

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

diff --git a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractAugmentGenerator.java b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractAugmentGenerator.java
index d52d09632b0ace7f9401967a1b4611f5db1b165f..d48e841929b81ff106c8cc81729270e0f08b9099 100644 (file)
--- a/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractAugmentGenerator.java
+++ b/binding/mdsal-binding-generator/src/main/java/org/opendaylight/mdsal/binding/generator/impl/reactor/AbstractAugmentGenerator.java
@@ -15,12 +15,12 @@ import com.google.common.collect.ImmutableList;
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Optional;
+import java.util.function.Function;
 import org.eclipse.jdt.annotation.NonNull;
-import org.eclipse.jdt.annotation.Nullable;
 import org.opendaylight.mdsal.binding.generator.impl.reactor.CollisionDomain.Member;
 import org.opendaylight.mdsal.binding.generator.impl.rt.DefaultAugmentRuntimeType;
 import org.opendaylight.mdsal.binding.model.api.GeneratedType;
+import org.opendaylight.mdsal.binding.model.api.YangSourceDefinition;
 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;
@@ -92,9 +92,7 @@ abstract class AbstractAugmentGenerator
         return otherIt.hasNext() ? -1 : 0;
     };
 
-    private SchemaTreeAwareEffectiveStatement<?, ?> targetStatement;
     private AbstractCompositeGenerator<?, ?> targetGen;
-    private Optional<AugmentRuntimeType> internalRuntimeType;
 
     AbstractAugmentGenerator(final AugmentEffectiveStatement statement, final AbstractCompositeGenerator<?, ?> parent) {
         super(statement, parent);
@@ -145,6 +143,7 @@ abstract class AbstractAugmentGenerator
     final GeneratedType createTypeImpl(final TypeBuilderFactory builderFactory) {
         final GeneratedTypeBuilder builder = builderFactory.newGeneratedTypeBuilder(typeName());
 
+        YangSourceDefinition.of(currentModule().statement(), statement()).ifPresent(builder::setYangSourceDefinition);
         builder.addImplementsType(BindingTypes.augmentation(targetGenerator().getGeneratedType(builderFactory)));
         addUsesInterfaces(builder, builderFactory);
         addConcreteInterfaceMethods(builder);
@@ -155,43 +154,34 @@ abstract class AbstractAugmentGenerator
         return builder.build();
     }
 
-    @NonNull List<CaseRuntimeType> augmentedCasesIn(final ChildLookup lookup, final ChoiceEffectiveStatement stmt) {
-        final var target = verifyNotNull(targetStatement);
-        if (!stmt.equals(target)) {
-            return List.of();
-        }
-
-        final var result = createBuilder(effectiveStatement(statement(), target))
-            .fillTypes(ChildLookup.of(target), this)
-            .getCaseChilden();
-        internalRuntimeType = Optional.empty();
-        return result;
+    boolean matchesInstantiated(final AugmentEffectiveStatement statement) {
+        return statement().equals(statement);
     }
 
-    @Nullable AugmentRuntimeType runtimeTypeIn(final ChildLookup lookup, final EffectiveStatement<?, ?> stmt) {
-        final var target = verifyNotNull(targetStatement);
-        if (!stmt.equals(target)) {
-            return null;
-        }
-        if (internalRuntimeType != null) {
-            return internalRuntimeType.orElseThrow();
-        }
+    final void fillRuntimeCasesIn(final AugmentResolver resolver, final ChoiceEffectiveStatement stmt,
+            final List<CaseRuntimeType> toList) {
+        toList.addAll(createBuilder(effectiveIn(stmt)).populate(resolver, this).getCaseChilden());
+    }
 
-        final var result = verifyNotNull(createInternalRuntimeType(ChildLookup.of(target),
-            effectiveStatement(statement(), target)));
-        internalRuntimeType = Optional.of(result);
-        return result;
+    final @NonNull AugmentRuntimeType runtimeTypeIn(final AugmentResolver resolver,
+            final EffectiveStatement<?, ?> stmt) {
+        verify(stmt instanceof SchemaTreeAwareEffectiveStatement, "Unexpected target statement %s", stmt);
+        return verifyNotNull(createInternalRuntimeType(resolver,
+            effectiveIn((SchemaTreeAwareEffectiveStatement<?, ?>) stmt)));
     }
 
-    private static @NonNull AugmentEffectiveStatement effectiveStatement(final AugmentEffectiveStatement augment,
-            final SchemaTreeAwareEffectiveStatement<?, ?> target) {
+    abstract @NonNull TargetAugmentEffectiveStatement effectiveIn(SchemaTreeAwareEffectiveStatement<?, ?> target);
+
+    final @NonNull TargetAugmentEffectiveStatement effectiveIn(final SchemaTreeAwareEffectiveStatement<?, ?> target,
+            final Function<QName, QName> transform) {
+        final var augment = statement();
         final var stmts = augment.effectiveSubstatements();
         final var builder = ImmutableList.<EffectiveStatement<?, ?>>builderWithExpectedSize(stmts.size());
         for (var child : stmts) {
             if (child instanceof SchemaTreeEffectiveStatement) {
                 final var qname = ((SchemaTreeEffectiveStatement<?>) child).getIdentifier();
-                // FIXME: orElseThrow()?
-                target.get(SchemaTreeNamespace.class, qname).ifPresent(builder::add);
+                // Note: a match in target may be missing -- for example if it was 'deviate unsupported'
+                target.get(SchemaTreeNamespace.class, transform.apply(qname)).ifPresent(builder::add);
             } else {
                 builder.add(child);
             }
@@ -199,10 +189,6 @@ abstract class AbstractAugmentGenerator
         return new TargetAugmentEffectiveStatement(augment, target, builder.build());
     }
 
-    final @Nullable AugmentRuntimeType getInternalRuntimeType() {
-        return verifyNotNull(internalRuntimeType, "Internal runtime not resolved in %s", this).orElse(null);
-    }
-
     @Override
     final void addAsGetterMethod(final GeneratedTypeBuilderBase<?> builder, final TypeBuilderFactory builderFactory) {
         // Augments are never added as getters, as they are handled via Augmentable mechanics
@@ -230,10 +216,4 @@ abstract class AbstractAugmentGenerator
     final @NonNull AbstractCompositeGenerator<?, ?> targetGenerator() {
         return verifyNotNull(targetGen, "No target for %s", this);
     }
-
-    final void setTargetStatement(final EffectiveStatement<?, ?> targetStatement) {
-        verify(targetStatement instanceof SchemaTreeAwareEffectiveStatement, "Unexpected target statement %s",
-            targetStatement);
-        this.targetStatement = (SchemaTreeAwareEffectiveStatement<?, ?>) targetStatement;
-    }
 }