import static com.google.common.base.Verify.verifyNotNull;
import static java.util.Objects.requireNonNull;
-import com.google.common.annotations.Beta;
import com.google.common.base.VerifyException;
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableList;
* @param <D> Declared Statement representation
* @param <E> Effective Statement representation
*/
-
public abstract class StatementContextBase<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
+abstract class StatementContextBase<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
extends ReactorStmtCtx<A, D, E> implements CopyHistory {
/**
* Event listener when an item is added to model namespace.
// Bottom 4 bits, encoding a CopyHistory, aight?
private static final byte COPY_ORIGINAL = 0x00;
private static final byte COPY_LAST_TYPE_MASK = 0x03;
- @Deprecated(since = "7.0.9")
+ @Deprecated(since = "7.0.9", forRemoval = true)
private static final byte COPY_ADDED_BY_USES = 0x04;
private static final byte COPY_ADDED_BY_AUGMENTATION = 0x08;
// Top four bits, of which we define the topmost two to 0. We use the bottom two to encode last CopyType, aight?
private static final int COPY_CHILD_TYPE_SHIFT = 4;
+ private static final CopyType @NonNull [] COPY_TYPE_VALUES = CopyType.values();
+
static {
- final int copyTypes = CopyType.values().length;
+ final int copyTypes = COPY_TYPE_VALUES.length;
// This implies CopyType.ordinal() is <= COPY_TYPE_MASK
verify(copyTypes == COPY_LAST_TYPE_MASK + 1, "Unexpected %s CopyType values", copyTypes);
}
}
@Override
- public Collection<? extends StmtContext<?, ?, ?>> getEffectOfStatement() {
+ public final Collection<? extends StmtContext<?, ?, ?>> getEffectOfStatement() {
return effectOfStatement;
}
@Override
- public void addAsEffectOfStatement(final Collection<? extends StmtContext<?, ?, ?>> ctxs) {
+ public final void addAsEffectOfStatement(final Collection<? extends StmtContext<?, ?, ?>> ctxs) {
if (ctxs.isEmpty()) {
return;
}
}
@Override
- @Deprecated(since = "7.0.9")
+ @Deprecated(since = "7.0.9", forRemoval = true)
public final boolean isAddedByUses() {
return (bitsAight & COPY_ADDED_BY_USES) != 0;
}
@Override
+ @Deprecated(since = "8.0.0")
public final boolean isAugmenting() {
return (bitsAight & COPY_ADDED_BY_AUGMENTATION) != 0;
}
@Override
public final CopyType getLastOperation() {
- return CopyType.values()[bitsAight & COPY_LAST_TYPE_MASK];
+ return COPY_TYPE_VALUES[bitsAight & COPY_LAST_TYPE_MASK];
}
// This method exists only for space optimization of InferredStatementContext
final CopyType childCopyType() {
- return CopyType.values()[bitsAight >> COPY_CHILD_TYPE_SHIFT & COPY_LAST_TYPE_MASK];
+ return COPY_TYPE_VALUES[bitsAight >> COPY_CHILD_TYPE_SHIFT & COPY_LAST_TYPE_MASK];
}
//
return effective.isEmpty() ? ImmutableList.of() : effective;
}
- public abstract void removeStatementFromEffectiveSubstatements(StatementDefinition statementDef);
-
static final List<ReactorStmtCtx<?, ?, ?>> removeStatementFromEffectiveSubstatements(
final List<ReactorStmtCtx<?, ?, ?>> effective, final StatementDefinition statementDef) {
if (effective.isEmpty()) {
return shrinkEffective(effective);
}
- /**
- * Removes a statement context from the effective substatements based on its statement definition (i.e statement
- * keyword) and raw (in String form) statement argument. The statement context is removed only if both statement
- * definition and statement argument match with one of the effective substatements' statement definition
- * and argument.
- *
- * <p>
- * If the statementArg parameter is null, the statement context is removed based only on its statement definition.
- *
- * @param statementDef statement definition of the statement context to remove
- * @param statementArg statement argument of the statement context to remove
- */
- public abstract void removeStatementFromEffectiveSubstatements(StatementDefinition statementDef,
- String statementArg);
-
static final List<ReactorStmtCtx<?, ?, ?>> removeStatementFromEffectiveSubstatements(
final List<ReactorStmtCtx<?, ?, ?>> effective, final StatementDefinition statementDef,
final String statementArg) {
return shrinkEffective(effective);
}
- // YANG example: RPC/action statements always have 'input' and 'output' defined
- @Beta
- public <X, Y extends DeclaredStatement<X>, Z extends EffectiveStatement<X, Y>> @NonNull Mutable<X, Y, Z>
- appendImplicitSubstatement(final StatementSupport<X, Y, Z> support, final String rawArg) {
+ @Override
+ public final <X, Y extends DeclaredStatement<X>, Z extends EffectiveStatement<X, Y>>
+ Mutable<X, Y, Z> addEffectiveSubstatement(final StatementSupport<X, Y, Z> support, final X arg) {
// FIXME: YANGTOOLS-652: This does not need to be a SubstatementContext, in can be a specialized
// StatementContextBase subclass.
final Mutable<X, Y, Z> ret = new SubstatementContext<>(this, new StatementDefinitionContext<>(support),
- ImplicitSubstatement.of(sourceReference()), rawArg);
+ ImplicitSubstatement.of(sourceReference()), arg);
support.onStatementAdded(ret);
addEffectiveSubstatement(ret);
return ret;
}
- /**
- * Adds an effective statement to collection of substatements.
- *
- * @param substatement substatement
- * @throws IllegalStateException if added in declared phase
- * @throws NullPointerException if statement parameter is null
- */
- public abstract void addEffectiveSubstatement(Mutable<?, ?, ?> substatement);
-
final List<ReactorStmtCtx<?, ?, ?>> addEffectiveSubstatement(final List<ReactorStmtCtx<?, ?, ?>> effective,
final Mutable<?, ?, ?> substatement) {
verifyStatement(substatement);
return resized;
}
- /**
- * Adds an effective statement to collection of substatements.
- *
- * @param statements substatements
- * @throws IllegalStateException
- * if added in declared phase
- * @throws NullPointerException
- * if statement parameter is null
- */
+ @Override
public final void addEffectiveSubstatements(final Collection<? extends Mutable<?, ?, ?>> statements) {
if (!statements.isEmpty()) {
statements.forEach(StatementContextBase::verifyStatement);
return resized;
}
- abstract Iterable<ReactorStmtCtx<?, ?, ?>> effectiveChildrenToComplete();
+ abstract Iterator<ReactorStmtCtx<?, ?, ?>> effectiveChildrenToComplete();
// exposed for InferredStatementContext only
final void ensureCompletedPhase(final Mutable<?, ?, ?> stmt) {
for (final StatementContextBase<?, ?, ?> child : mutableDeclaredSubstatements()) {
finished &= child.tryToCompletePhase(targetOrder);
}
- for (final ReactorStmtCtx<?, ?, ?> child : effectiveChildrenToComplete()) {
- finished &= child.tryToCompletePhase(targetOrder);
+ final var it = effectiveChildrenToComplete();
+ while (it.hasNext()) {
+ finished &= it.next().tryToCompletePhase(targetOrder);
}
return finished;
}
}
}
- /**
- * Ends declared section of current node.
- */
- void endDeclared(final ModelProcessingPhase phase) {
- definition.onDeclarationFinished(this, phase);
- }
-
@Override
final StatementDefinitionContext<A, D, E> definition() {
return definition;
}
@Override
- public <K, KT extends K, N extends StatementNamespace<K, ?, ?>> void addContext(final Class<@NonNull N> namespace,
- final KT key,final StmtContext<?, ?, ?> stmt) {
+ public final <K, KT extends K, N extends StatementNamespace<K, ?, ?>> void addContext(
+ final Class<@NonNull N> namespace, final KT key,final StmtContext<?, ?, ?> stmt) {
addContextToNamespace(namespace, key, stmt);
}
@Override
- public Optional<? extends Mutable<?, ?, ?>> copyAsChildOf(final Mutable<?, ?, ?> parent, final CopyType type,
+ public final Optional<? extends Mutable<?, ?, ?>> copyAsChildOf(final Mutable<?, ?, ?> parent, final CopyType type,
final QNameModule targetModule) {
checkEffectiveModelCompleted(this);
return Optional.ofNullable(copyAsChildOfImpl(parent, type, targetModule));
"Attempted to copy statement %s which has completed phase %s", stmt, phase);
}
- @Beta
- // FIXME: this information should be exposed as a well-known Namespace
+ @Override
public final boolean hasImplicitParentSupport() {
return definition.getFactory() instanceof ImplicitParentAwareStatementSupport;
}
- @Beta
- public final StatementContextBase<?, ?, ?> wrapWithImplicit(final StatementContextBase<?, ?, ?> original) {
+ @Override
+ public final StmtContext<?, ?, ?> wrapWithImplicit(final StmtContext<?, ?, ?> original) {
final var optImplicit = definition.getImplicitParentFor(this, original.publicDefinition());
if (optImplicit.isEmpty()) {
return original;
final StatementDefinitionContext<?, ?, ?> def = new StatementDefinitionContext<>(optImplicit.orElseThrow());
final CopyType type = original.history().getLastOperation();
- final SubstatementContext<?, ?, ?> result = new SubstatementContext(original.getParentContext(), def,
+
+ checkArgument(original instanceof StatementContextBase, "Unsupported original %s", original);
+ final var origBase = (StatementContextBase<?, ?, ?>)original;
+
+ @SuppressWarnings({ "rawtypes", "unchecked"})
+ final SubstatementContext<?, ?, ?> result = new SubstatementContext(origBase.getParentContext(), def,
original.sourceReference(), original.rawArgument(), original.argument(), type);
- result.addEffectiveSubstatement(original.reparent(result));
+ result.addEffectiveSubstatement(origBase.reparent(result));
result.setCompletedPhase(original.getCompletedPhase());
return result;
}
Code Review / yangtools.git / blobdiff