@Override
final Stream<? extends StmtContext<?, ?, ?>> streamDeclared() {
- return declaredSubstatements().stream();
+ return declaredSubstatements().stream().filter(StmtContext::isSupportedToBuildEffective);
}
@Override
final Stream<? extends StmtContext<?, ?, ?>> streamEffective() {
- return effective.stream();
+ return effective.stream().filter(StmtContext::isSupportedToBuildEffective);
}
@Override
// We can reuse this statement let's see if all the statements agree
final List<EffectiveCopy> declCopy = prototype.streamDeclared()
- .filter(StmtContext::isSupportedByFeatures)
.map(sub -> effectiveCopy((ReactorStmtCtx<?, ?, ?>) sub))
.filter(Objects::nonNull)
.collect(Collectors.toUnmodifiableList());
private List<ReactorStmtCtx<?, ?, ?>> reusePrototypeReplicas() {
return reusePrototypeReplicas(Streams.concat(
- prototype.streamDeclared().filter(StmtContext::isSupportedByFeatures),
- prototype.streamEffective()));
+ prototype.streamDeclared(), prototype.streamEffective()));
}
private List<ReactorStmtCtx<?, ?, ?>> reusePrototypeReplicas(final Stream<StmtContext<?, ?, ?>> stream) {
@Override
Stream<? extends StmtContext<?, ?, ?>> streamEffective() {
accessSubstatements();
- return ensureEffectiveSubstatements().stream();
+ return ensureEffectiveSubstatements().stream().filter(StmtContext::isSupportedToBuildEffective);
}
private void accessSubstatements() {
return factory.createEffective(ctx, ctx.streamDeclared(), ctx.streamEffective());
}
- abstract Stream<? extends StmtContext<?, ?, ?>> streamDeclared();
+ /**
+ * Return a stream of declared statements which can be built into an {@link EffectiveStatement}, as per
+ * {@link StmtContext#buildEffective()} contract.
+ *
+ * @return Stream of supported declared statements.
+ */
+ // FIXME: we really want to unify this with streamEffective(), under its name
+ abstract Stream<? extends @NonNull StmtContext<?, ?, ?>> streamDeclared();
- abstract Stream<? extends StmtContext<?, ?, ?>> streamEffective();
+ /**
+ * Return a stream of inferred statements which can be built into an {@link EffectiveStatement}, as per
+ * {@link StmtContext#buildEffective()} contract.
+ *
+ * @return Stream of supported effective statements.
+ */
+ // FIXME: this method is currently a misnomer, but unifying with streamDeclared() would make this accurate again
+ abstract Stream<? extends @NonNull StmtContext<?, ?, ?>> streamEffective();
@Override
final boolean doTryToCompletePhase(final ModelProcessingPhase phase) {
@Override
public ExtensionEffectiveStatement createEffective(final Current<QName, ExtensionStatement> stmt,
final Stream<? extends StmtContext<?, ?, ?>> declaredSubstatements,
- final Stream<? extends StmtContext<?, ?, ?>> effectiveSubstatements) {
+ final Stream<? extends StmtContext<?, ?, ?>> inferredSubstatements) {
Map<Current<?, ?>, ExtensionEffectiveStatementImpl> tl = TL_BUILDERS.get();
if (tl == null) {
tl = new IdentityHashMap<>();
stmt.optionalPath());
verify(tl.put(stmt, created) == null);
try {
- return super.createEffective(stmt, declaredSubstatements, effectiveSubstatements);
+ return super.createEffective(stmt, declaredSubstatements, inferredSubstatements);
} finally {
verify(tl.remove(stmt) == created);
}
@Override
public E createEffective(final Current<A, D> stmt,
final Stream<? extends StmtContext<?, ?, ?>> declaredSubstatements,
- final Stream<? extends StmtContext<?, ?, ?>> effectiveSubstatements) {
+ final Stream<? extends StmtContext<?, ?, ?>> inferredSubstatements) {
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements =
buildEffectiveSubstatements(stmt, statementsToBuild(stmt,
- declaredSubstatements(declaredSubstatements, effectiveSubstatements)));
+ declaredSubstatements(declaredSubstatements, inferredSubstatements)));
return createEffective(stmt, substatements);
}
*/
protected @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> buildEffectiveSubstatements(
final Current<A, D> stmt, final List<? extends StmtContext<?, ?, ?>> substatements) {
- return defaultBuildEffectiveSubstatements(substatements);
- }
-
- private static @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> defaultBuildEffectiveSubstatements(
- final List<? extends StmtContext<?, ?, ?>> substatements) {
- return substatements.stream()
- .filter(StmtContext::isSupportedToBuildEffective)
- .map(StmtContext::buildEffective)
- .collect(ImmutableList.toImmutableList());
+ return substatements.stream().map(StmtContext::buildEffective).collect(ImmutableList.toImmutableList());
}
private static @NonNull List<StmtContext<?, ?, ?>> declaredSubstatements(
@Override
public E createEffective(final Current<A, D> stmt,
final Stream<? extends StmtContext<?, ?, ?>> declaredSubstatements,
- final Stream<? extends StmtContext<?, ?, ?>> effectiveSubstatements) {
- return delegate.createEffective(stmt, declaredSubstatements, effectiveSubstatements);
+ final Stream<? extends StmtContext<?, ?, ?>> inferredSubstatements) {
+ return delegate.createEffective(stmt, declaredSubstatements, inferredSubstatements);
}
@Override
* Create a {@link EffectiveStatement} for specified context.
*
* @param stmt Effective capture of this statement's significant state
+ * @param declaredSubstatements effectively-visible declared substatements
+ * @param inferredSubstatements effectively-visible inferred substatements
* @return An effective statement instance
*/
+ // FIXME: we really want a single coherent 'effectiveSubstatements' stream
@NonNull E createEffective(@NonNull Current<A, D> stmt,
Stream<? extends StmtContext<?, ?, ?>> declaredSubstatements,
- Stream<? extends StmtContext<?, ?, ?>> effectiveSubstatements);
+ Stream<? extends StmtContext<?, ?, ?>> inferredSubstatements);
/**
* Create a {@link EffectiveStatement} copy of provided original for specified context.