yang/yang-parser-rfc7950/src/main/java/org/opendaylight/yangtools/yang/parser/rfc7950/stmt/BaseStatementSupport.java

   1 /*
   2  * Copyright (c) 2020 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.yangtools.yang.parser.rfc7950.stmt;
   9
  10 import static com.google.common.base.Verify.verifyNotNull;
  11
  12 import com.google.common.annotations.Beta;
  13 import com.google.common.collect.ImmutableList;
  14 import java.util.ArrayList;
  15 import java.util.Collection;
  16 import java.util.HashSet;
  17 import java.util.List;
  18 import java.util.Set;
  19 import org.eclipse.jdt.annotation.NonNull;
  20 import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
  21 import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
  22 import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
  23 import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
  24 import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
  25
  26 /**
  27  * Implementation-internal base class for {@link AbstractStatementSupport} implementations.
  28  *
  29  * @param <A> Argument type
  30  * @param <D> Declared Statement representation
  31  * @param <E> Effective Statement representation
  32  */
  33 @Beta
  34 public abstract class BaseStatementSupport<A, D extends DeclaredStatement<A>,
  35         E extends EffectiveStatement<A, D>> extends AbstractStatementSupport<A, D, E> {
  36     protected BaseStatementSupport(final StatementDefinition publicDefinition) {
  37         super(publicDefinition);
  38     }
  39
  40     @Override
  41     public final E createEffective(final StmtContext<A, D, E> ctx) {
  42         final D declared = buildDeclared(ctx);
  43         final ImmutableList<? extends EffectiveStatement<?, ?>> substatements = buildEffectiveSubstatements(ctx);
  44         return substatements.isEmpty() ? createEmptyEffective(ctx, declared)
  45                 : createEffective(ctx, declared, substatements);
  46     }
  47
  48     protected abstract @NonNull E createEffective(@NonNull StmtContext<A, D, E> ctx, @NonNull D declared,
  49             @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements);
  50
  51     protected abstract @NonNull E createEmptyEffective(@NonNull StmtContext<A, D, E> ctx, @NonNull D declared);
  52
  53     static final <A, D extends DeclaredStatement<A>> @NonNull D buildDeclared(final StmtContext<A, D, ?> ctx) {
  54         /*
  55          * Share original instance of declared statement between all effective
  56          * statements which have been copied or derived from this original
  57          * declared statement.
  58          */
  59         @SuppressWarnings("unchecked")
  60         final StmtContext<?, D, ?> lookupCtx = (StmtContext<?, D, ?>) ctx.getOriginalCtx().orElse(ctx);
  61         return verifyNotNull(lookupCtx.buildDeclared(), "Statement %s failed to build declared statement", lookupCtx);
  62     }
  63
  64     /**
  65      * Create a set of substatements. This method is split out so it can be overridden in
  66      * ExtensionEffectiveStatementImpl to leak a not-fully-initialized instance.
  67      *
  68      * @param substatements proposed substatements
  69      * @return Filtered substatements
  70      */
  71     private static ImmutableList<? extends EffectiveStatement<?, ?>> buildEffectiveSubstatements(
  72             final List<? extends StmtContext<?, ?, ?>> substatements) {
  73         return substatements.stream()
  74                 .filter(StmtContext::isSupportedToBuildEffective)
  75                 .map(StmtContext::buildEffective)
  76                 .collect(ImmutableList.toImmutableList());
  77     }
  78
  79     static final ImmutableList<? extends EffectiveStatement<?, ?>> buildEffectiveSubstatements(
  80             final StmtContext<?, ?, ?> ctx) {
  81         return buildEffectiveSubstatements(declaredSubstatements(ctx));
  82     }
  83
  84     static final @NonNull List<StmtContext<?, ?, ?>> declaredSubstatements(final StmtContext<?, ?, ?> ctx) {
  85         /*
  86          * This dance is required to ensure that effects of 'uses' nodes are applied in the same order as
  87          * the statements were defined -- i.e. if we have something like this:
  88          *
  89          * container foo {
  90          *   uses bar;
  91          *   uses baz;
  92          * }
  93          *
  94          * grouping baz {
  95          *   leaf baz {
  96          *     type string;
  97          *   }
  98          * }
  99          *
 100          * grouping bar {
 101          *   leaf bar {
 102          *     type string;
 103          *   }
 104          * }
 105          *
 106          * The reactor would first inline 'uses baz' as that definition is the first one completely resolved and then
 107          * inline 'uses bar'. Here we are iterating in declaration order re-inline the statements.
 108          *
 109          * FIXME: 5.0.0: this really should be handled by UsesStatementSupport such that 'uses baz' would have a
 110          *               prerequisite of a resolved 'uses bar'.
 111          */
 112         final List<StmtContext<?, ?, ?>> substatementsInit = new ArrayList<>();
 113         Set<StmtContext<?, ?, ?>> filteredStatements = null;
 114         for (final StmtContext<?, ?, ?> declaredSubstatement : ctx.declaredSubstatements()) {
 115             if (declaredSubstatement.isSupportedByFeatures()) {
 116                 substatementsInit.add(declaredSubstatement);
 117
 118                 final Collection<? extends StmtContext<?, ?, ?>> effect = declaredSubstatement.getEffectOfStatement();
 119                 if (!effect.isEmpty()) {
 120                     if (filteredStatements == null) {
 121                         filteredStatements = new HashSet<>();
 122                     }
 123                     filteredStatements.addAll(effect);
 124                     substatementsInit.addAll(effect);
 125                 }
 126             }
 127         }
 128
 129         if (filteredStatements != null) {
 130             for (StmtContext<?, ?, ?> stmt : ctx.effectiveSubstatements()) {
 131                 if (!filteredStatements.contains(stmt)) {
 132                     substatementsInit.add(stmt);
 133                 }
 134             }
 135         } else {
 136             substatementsInit.addAll(ctx.effectiveSubstatements());
 137         }
 138
 139         return substatementsInit;
 140     }
 141 }