// First check if we can reuse the entire prototype
if (!factory.canReuseCurrent(this, prototype, origSubstatements)) {
- return tryToReuseSubstatements(factory, origSubstatements);
+ return tryToReuseSubstatements(factory, origEffective);
}
// No substatements to deal with, we can freely reuse the original
return factory.createEffective(this, declared.stream(), effective.stream());
}
- private @NonNull E tryToReuseSubstatements(final StatementFactory<A, D, E> factory,
- final @NonNull Collection<? extends EffectiveStatement<?, ?>> origSubstatements) {
+ private @NonNull E tryToReuseSubstatements(final StatementFactory<A, D, E> factory, final @NonNull E original) {
if (allSubstatementsContextIndependent()) {
LOG.debug("Reusing substatements of: {}", prototype);
// FIXME: can we skip this if !haveRef()?
substatements = reusePrototypeReplicas();
prototype.decRef();
- return factory.createEffective(this, origSubstatements);
+ return factory.copyEffective(this, original);
}
// Fall back to full instantiation, which populates our substatements. Then check if we should be reusing
// the substatement list, as this operation turned out to not affect them.
final E effective = super.createEffective(factory);
- if (sameSubstatements(origSubstatements, effective)) {
+ if (sameSubstatements(original.effectiveSubstatements(), effective)) {
LOG.debug("Reusing unchanged substatements of: {}", prototype);
- return factory.createEffective(this, origSubstatements);
+ return factory.copyEffective(this, original);
}
return effective;
}
this.declared = requireNonNull(declared);
}
+ protected Default(final Default<A, D> original) {
+ this.declared = original.declared;
+ }
+
@Override
public final D getDeclared() {
return declared;
this.substatements = maskList(substatements);
}
+ protected WithSubstatements(final WithSubstatements<A, D> original) {
+ super(original);
+ this.substatements = original.substatements;
+ }
+
@Override
public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
return unmaskList(substatements);
super(declared);
}
+ protected DefaultArgument(final DefaultArgument<A, D> original) {
+ super(original);
+ }
+
@Override
public final A argument() {
return getDeclared().argument();
this.substatements = maskList(substatements);
}
+ protected WithSubstatements(final WithSubstatements<A, D, E> original) {
+ super(original);
+ this.substatements = original.substatements;
+ }
+
@Override
public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
return unmaskList(substatements);
this.schemaTree = ImmutableMap.copyOf(createSchemaTreeNamespace(substatements));
}
+ protected DefaultWithSchemaTree(final DefaultWithSchemaTree<A, D, E> original) {
+ this.declared = original.declared;
+ this.schemaTree = original.schemaTree;
+ }
+
@Override
public final D getDeclared() {
return declared;
this.substatements = maskList(substatements);
}
+ protected WithSubstatements(final WithSubstatements<A, D, E> original) {
+ super(original);
+ this.substatements = original.substatements;
+ }
+
@Override
public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
return unmaskList(substatements);
this.dataTree = createDataTreeNamespace(schema.values(), schemaTree);
}
+ protected DefaultWithDataTree(final DefaultWithDataTree<A, D, E> original) {
+ this.declared = original.declared;
+ this.schemaTree = original.schemaTree;
+ this.dataTree = original.dataTree;
+ }
+
@Override
public final D getDeclared() {
return declared;
this.substatements = maskList(substatements);
}
+ protected WithSubstatements(final WithSubstatements<A, D, E> original) {
+ super(original);
+ this.substatements = original.substatements;
+ }
+
@Override
public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
return unmaskList(substatements);
this.schemaTree = ImmutableMap.copyOf(createSchemaTreeNamespace(substatements));
}
+ protected DefaultWithSchemaTree(final DefaultWithSchemaTree<A, D, E> original) {
+ this.schemaTree = original.schemaTree;
+ }
+
@Override
protected final Map<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace() {
return schemaTree;
this.substatements = maskList(substatements);
}
+ protected WithSubstatements(final WithSubstatements<A, D, E> original) {
+ super(original);
+ this.substatements = original.substatements;
+ }
+
@Override
public final ImmutableList<? extends EffectiveStatement<?, ?>> effectiveSubstatements() {
return unmaskList(substatements);
this.dataTree = createDataTreeNamespace(schema.values(), schemaTree);
}
+ protected DefaultWithDataTree(final DefaultWithDataTree<A, D, E> original) {
+ this.schemaTree = original.schemaTree;
+ this.dataTree = original.dataTree;
+ }
+
@Override
protected final Map<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace() {
return schemaTree;
super(publicDefinition, policy);
}
+ @Override
+ public final E copyEffective(final Current<QName, D> stmt, final E original) {
+ final StatementSource source = stmt.source();
+ switch (source) {
+ case CONTEXT:
+ return copyUndeclaredEffective(stmt, original);
+ case DECLARATION:
+ return copyDeclaredEffective(stmt, original);
+ default:
+ throw new IllegalStateException("Unhandled statement source " + source);
+ }
+ }
+
@Override
protected E createEffective(final Current<QName, D> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
}
}
+ protected abstract @NonNull E copyDeclaredEffective(@NonNull Current<QName, D> stmt, @NonNull E original);
+
+ protected abstract @NonNull E copyUndeclaredEffective(@NonNull Current<QName, D> stmt, @NonNull E original);
+
protected abstract @NonNull E createDeclaredEffective(@NonNull Current<QName, D> stmt,
@NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements);
return createArgument.apply(StmtContextUtils.getRootModuleQName(ctx));
}
+ @Override
+ protected final @NonNull E copyDeclaredEffective(final Current<QName, D> stmt, final E original) {
+ return copyDeclaredEffective(
+ EffectiveStatementMixins.historyAndStatusFlags(stmt.history(), original.effectiveSubstatements()),
+ stmt, original);
+ }
+
+ protected abstract @NonNull E copyDeclaredEffective(int flags, @NonNull Current<QName, D> stmt,
+ @NonNull E original);
+
+ @Override
+ protected final @NonNull E copyUndeclaredEffective(final Current<QName, D> stmt, final E original) {
+ return copyUndeclaredEffective(
+ EffectiveStatementMixins.historyAndStatusFlags(stmt.history(), original.effectiveSubstatements()),
+ stmt, original);
+ }
+
+ protected abstract @NonNull E copyUndeclaredEffective(int flags, @NonNull Current<QName, D> stmt,
+ @NonNull E original);
+
@Override
protected final @NonNull E createDeclaredEffective(final Current<QName, D> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
import com.google.common.base.MoreObjects;
import com.google.common.base.Strings;
import com.google.common.collect.Collections2;
-import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import java.util.Collection;
import java.util.Optional;
}
public static int historyAndStatusFlags(final CopyHistory history,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ final Collection<? extends EffectiveStatement<?, ?>> substatements) {
return new FlagsBuilder()
.setHistory(history)
.setStatus(AbstractStatementSupport.findFirstArgument(substatements,
this.flags = flags;
}
+ ActionEffectiveStatementImpl(final ActionEffectiveStatementImpl original, final SchemaPath path, final int flags) {
+ super(original);
+ this.path = path;
+ this.flags = flags;
+ }
+
@Override
@Deprecated
public SchemaPath getPath() {
throw new SourceException(e.getMessage(), stmt, e);
}
}
+
+ @Override
+ public ActionEffectiveStatement copyEffective(final Current<QName, ActionStatement> stmt,
+ final ActionEffectiveStatement original) {
+ return new ActionEffectiveStatementImpl((ActionEffectiveStatementImpl) original, stmt.wrapSchemaPath(),
+ EffectiveStatementMixins.historyAndStatusFlags(stmt.history(), original.effectiveSubstatements()));
+ }
}
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import java.util.Collection;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
}
}
+ @Override
+ protected CaseEffectiveStatement copyDeclaredEffective(final Current<QName, CaseStatement> stmt,
+ final CaseEffectiveStatement original) {
+ return new DeclaredCaseEffectiveStatement((DeclaredCaseEffectiveStatement) original,
+ computeFlags(stmt, original.effectiveSubstatements()), stmt.wrapSchemaPath(), findOriginal(stmt));
+ }
+
+ @Override
+ protected CaseEffectiveStatement copyUndeclaredEffective(final Current<QName, CaseStatement> stmt,
+ final CaseEffectiveStatement original) {
+ return new UndeclaredCaseEffectiveStatement((UndeclaredCaseEffectiveStatement) original,
+ computeFlags(stmt, original.effectiveSubstatements()), stmt.wrapSchemaPath(), findOriginal(stmt));
+ }
+
@Override
protected CaseEffectiveStatement createDeclaredEffective(final Current<QName, CaseStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
}
private static int computeFlags(final Current<?, ?> stmt,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ final Collection<? extends EffectiveStatement<?, ?>> substatements) {
final Boolean config;
final EffectiveConfig effective = stmt.effectiveConfig();
switch (effective) {
@SuppressFBWarnings(value = "NP_BOOLEAN_RETURN_NULL", justification = "Internal use tagged with @Nullable")
private static @Nullable Boolean substatementEffectiveConfig(
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ final Collection<? extends EffectiveStatement<?, ?>> substatements) {
for (EffectiveStatement<?, ?> stmt : substatements) {
if (stmt instanceof DataSchemaNode) {
final Optional<Boolean> opt = ((DataSchemaNode) stmt).effectiveConfig();
this.original = original;
}
+ DeclaredCaseEffectiveStatement(final DeclaredCaseEffectiveStatement origEffective, final int flags,
+ final SchemaPath path, final @Nullable CaseSchemaNode original) {
+ super(origEffective);
+ this.flags = flags;
+ this.path = path;
+ this.original = original;
+ }
+
@Override
public int flags() {
return flags;
this.original = original;
}
+ UndeclaredCaseEffectiveStatement(final UndeclaredCaseEffectiveStatement origEffective, final int flags,
+ final SchemaPath path, final @Nullable CaseSchemaNode original) {
+ super(origEffective);
+ this.path = path;
+ this.flags = flags;
+ this.original = original;
+ }
+
@Override
public int flags() {
return flags;
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final int flags,
final SchemaPath path, final ContainerSchemaNode original) {
super(declared, substatements);
+ this.original = original;
+ this.flags = flags;
this.path = path;
+ }
+
+ ContainerEffectiveStatementImpl(final ContainerEffectiveStatementImpl origEffective,
+ final ContainerSchemaNode original, final int flags, final @Nullable SchemaPath path) {
+ super(origEffective);
this.original = original;
this.flags = flags;
+ this.path = path;
}
@Override
import com.google.common.annotations.Beta;
import com.google.common.collect.ImmutableList;
+import java.util.Collection;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
-import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
@Override
protected ContainerEffectiveStatement createEffective(final Current<QName, ContainerStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- final int flags = new FlagsBuilder()
- .setHistory(stmt.history())
- .setStatus(findFirstArgument(substatements, StatusEffectiveStatement.class, Status.CURRENT))
- .setConfiguration(stmt.effectiveConfig().asNullable())
- .setPresence(findFirstStatement(substatements, PresenceEffectiveStatement.class) != null)
- .toFlags();
-
EffectiveStmtUtils.checkUniqueGroupings(stmt, substatements);
EffectiveStmtUtils.checkUniqueTypedefs(stmt, substatements);
EffectiveStmtUtils.checkUniqueUses(stmt, substatements);
- final SchemaPath path = stmt.wrapSchemaPath();
try {
- return new ContainerEffectiveStatementImpl(stmt.declared(), substatements, flags, path,
- (ContainerSchemaNode) stmt.original());
+ return new ContainerEffectiveStatementImpl(stmt.declared(), substatements, createFlags(stmt, substatements),
+ stmt.wrapSchemaPath(), (ContainerSchemaNode) stmt.original());
} catch (SubstatementIndexingException e) {
throw new SourceException(e.getMessage(), stmt, e);
}
}
+
+ @Override
+ public ContainerEffectiveStatement copyEffective(final Current<QName, ContainerStatement> stmt,
+ final ContainerEffectiveStatement original) {
+ return new ContainerEffectiveStatementImpl((ContainerEffectiveStatementImpl) original,
+ (ContainerSchemaNode) stmt.original(), createFlags(stmt, original.effectiveSubstatements()),
+ stmt.wrapSchemaPath());
+ }
+
+ private static int createFlags(final Current<?, ?> stmt,
+ final Collection<? extends EffectiveStatement<?, ?>> substatements) {
+ return new FlagsBuilder()
+ .setHistory(stmt.history())
+ .setStatus(findFirstArgument(substatements, StatusEffectiveStatement.class, Status.CURRENT))
+ .setConfiguration(stmt.effectiveConfig().asNullable())
+ .setPresence(findFirstStatement(substatements, PresenceEffectiveStatement.class) != null)
+ .toFlags();
+ }
}
+
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.extension;
-import java.util.Collection;
import java.util.Optional;
import java.util.stream.Stream;
-import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement;
}
@Override
- public UnrecognizedEffectiveStatement createEffective(final Current<String, UnrecognizedStatement> stmt,
- final Collection<? extends EffectiveStatement<?, ?>> substatements) {
- return definition.createEffective(stmt, substatements);
+ public UnrecognizedEffectiveStatement copyEffective(final Current<String, UnrecognizedStatement> stmt,
+ final UnrecognizedEffectiveStatement original) {
+ return definition.copyEffective(stmt, original);
}
@Override
this.path = path;
}
+ DeclaredInputEffectiveStatement(final int flags, final DeclaredInputEffectiveStatement original,
+ final SchemaPath path) {
+ super(original);
+ this.flags = flags;
+ this.path = path;
+ }
+
@Override
@Deprecated
public SchemaPath getPath() {
}
}
+ @Override
+ protected InputEffectiveStatement copyDeclaredEffective(final int flags,
+ final Current<QName, InputStatement> stmt, final InputEffectiveStatement original) {
+ return new DeclaredInputEffectiveStatement(flags, (DeclaredInputEffectiveStatement) original,
+ stmt.wrapSchemaPath());
+ }
+
+ @Override
+ protected InputEffectiveStatement copyUndeclaredEffective(final int flags,
+ final Current<QName, InputStatement> stmt, final InputEffectiveStatement original) {
+ return new UndeclaredInputEffectiveStatement(flags, (UndeclaredInputEffectiveStatement) original,
+ stmt.wrapSchemaPath());
+ }
+
@Override
protected InputEffectiveStatement createDeclaredEffective(final int flags,
final Current<QName, InputStatement> stmt,
this.flags = flags;
}
+ UndeclaredInputEffectiveStatement(final int flags, final UndeclaredInputEffectiveStatement original,
+ final SchemaPath path) {
+ super(original);
+ this.path = path;
+ this.flags = flags;
+ }
+
@Override
@Deprecated
public SchemaPath getPath() {
throw new SourceException(e.getMessage(), stmt, e);
}
}
+
+ @Override
+ public final NotificationEffectiveStatement copyEffective(final Current<QName, NotificationStatement> stmt,
+ final NotificationEffectiveStatement original) {
+ return new NotificationEffectiveStatementImpl((NotificationEffectiveStatementImpl) original,
+ EffectiveStatementMixins.historyAndStatusFlags(stmt.history(), original.effectiveSubstatements()),
+ stmt.wrapSchemaPath());
+ }
}
\ No newline at end of file
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final int flags,
final SchemaPath path) {
super(declared, substatements);
+ this.flags = flags;
this.path = path;
+ }
+
+ NotificationEffectiveStatementImpl(final NotificationEffectiveStatementImpl original, final int flags,
+ final SchemaPath path) {
+ super(original);
this.flags = flags;
+ this.path = path;
}
@Override
this.path = path;
}
+ DeclaredOutputEffectiveStatement(final int flags, final DeclaredOutputEffectiveStatement original,
+ final SchemaPath path) {
+ super(original);
+ this.flags = flags;
+ this.path = path;
+ }
+
@Override
@Deprecated
public SchemaPath getPath() {
}
}
+ @Override
+ protected OutputEffectiveStatement copyDeclaredEffective(final int flags,
+ final Current<QName, OutputStatement> stmt, final OutputEffectiveStatement original) {
+ return new DeclaredOutputEffectiveStatement(flags, (DeclaredOutputEffectiveStatement) original,
+ stmt.wrapSchemaPath());
+ }
+
+ @Override
+ protected OutputEffectiveStatement copyUndeclaredEffective(final int flags,
+ final Current<QName, OutputStatement> stmt, final OutputEffectiveStatement original) {
+ return new UndeclaredOutputEffectiveStatement(flags, (UndeclaredOutputEffectiveStatement) original,
+ stmt.wrapSchemaPath());
+ }
+
@Override
protected OutputEffectiveStatement createDeclaredEffective(final int flags,
final Current<QName, OutputStatement> stmt,
UndeclaredOutputEffectiveStatement(final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final SchemaPath path) {
super(substatements);
+ this.flags = flags;
this.path = path;
+ }
+
+ UndeclaredOutputEffectiveStatement(final int flags, final UndeclaredOutputEffectiveStatement original,
+ final SchemaPath path) {
+ super(original);
this.flags = flags;
+ this.path = path;
}
@Override
return createEffective(stmt, substatements);
}
- @Override
- public final E createEffective(final Current<A, D> stmt,
- final Collection<? extends EffectiveStatement<?, ?>> substatements) {
- // This copy should be a no-op
- return createEffective(stmt, ImmutableList.copyOf(substatements));
- }
-
protected abstract @NonNull E createEffective(@NonNull Current<A, D> stmt,
@NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements);
+ @Override
+ public E copyEffective(final Current<A, D> stmt, final E original) {
+ // Most implementations are only interested in substatements. copyOf() here should be a no-op
+ return createEffective(stmt, ImmutableList.copyOf(original.effectiveSubstatements()));
+ }
+
/**
* Give statement support a hook to transform statement contexts before they are built. Default implementation
* does nothing, but note {@code augment} statement performs a real transformation.
// FIXME: add documentation
public static final <E extends EffectiveStatement<?, ?>> @Nullable E findFirstStatement(
- final ImmutableList<? extends EffectiveStatement<?, ?>> statements, final Class<E> type) {
+ final Collection<? extends EffectiveStatement<?, ?>> statements, final Class<E> type) {
for (EffectiveStatement<?, ?> stmt : statements) {
if (type.isInstance(stmt)) {
return type.cast(stmt);
// FIXME: add documentation
public static final <A, E extends EffectiveStatement<A, ?>> A findFirstArgument(
- final ImmutableList<? extends EffectiveStatement<?, ?>> statements, final Class<@NonNull E> type,
+ final Collection<? extends EffectiveStatement<?, ?>> statements, final Class<@NonNull E> type,
final A defValue) {
final @Nullable E stmt = findFirstStatement(statements, type);
return stmt != null ? stmt.argument() : defValue;
package org.opendaylight.yangtools.yang.parser.spi.meta;
import com.google.common.annotations.Beta;
-import java.util.Collection;
import java.util.stream.Stream;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
}
@Override
- public E createEffective(final Current<A, D> stmt,
- final Collection<? extends EffectiveStatement<?, ?>> substatements) {
- return delegate.createEffective(stmt, substatements);
+ public E copyEffective(final Current<A, D> stmt, final E original) {
+ return delegate.copyEffective(stmt, original);
}
@Override
* @param stmt Effective capture of this statement's significant state
* @return An effective statement instance
*/
- @NonNull E createEffective(
EffectiveStmtCtx.@NonNull Current<A, D> stmt,
+ @NonNull E createEffective(@NonNull Current<A, D> stmt,
Stream<? extends StmtContext<?, ?, ?>> declaredSubstatements,
Stream<? extends StmtContext<?, ?, ?>> effectiveSubstatements);
/**
- * Create a {@link EffectiveStatement} for specified context and substatements.
+ * Create a {@link EffectiveStatement} copy of provided original for specified context.
*
* @param stmt Effective capture of this statement's significant state
- * @param substatements Current effective substatements
+ * @param original Original effective statement
* @return An effective statement instance
* @throws NullPointerException if any argument is null
*/
- @NonNull E createEffective(EffectiveStmtCtx.@NonNull Current<A, D> stmt,
- @NonNull Collection<? extends EffectiveStatement<?, ?>> substatements);
+ @NonNull E copyEffective(@NonNull Current<A, D> stmt, @NonNull E original);
/**
* Determine reactor copy behaviour of a statement instance. Implementations classes are required to determine
Code Review / yangtools.git / commitdiff