// Creates EffectiveStatement through full materialization and assumes declared statement presence
private @NonNull E createEffective(final StatementFactory<A, D, E> factory,
final StatementContextBase<A, D, E> ctx, final Stream<? extends StmtContext<?, ?, ?>> declared,
- final Stream<? extends StmtContext<?, ?, ?>> effective) {
+ final Stream<? extends ReactorStmtCtx<?, ?, ?>> effective) {
// Statement reference count infrastructure makes an assumption that effective statement is only built after
// the declared statement is already done. Statements tracked by this class always have a declared view, and
// we need to ensure that is built before we touch effective substatements.
@Override
final E createInferredEffective(final StatementFactory<A, D, E> factory,
- final InferredStatementContext<A, D, E> ctx, final Stream<? extends StmtContext<?, ?, ?>> declared,
- final Stream<? extends StmtContext<?, ?, ?>> effective) {
+ final InferredStatementContext<A, D, E> ctx, final Stream<? extends ReactorStmtCtx<?, ?, ?>> declared,
+ final Stream<? extends ReactorStmtCtx<?, ?, ?>> effective) {
return createEffective(factory, ctx, declared, effective);
}
}
@Override
- final Stream<? extends @NonNull StmtContext<?, ?, ?>> streamDeclared() {
+ final Stream<? extends @NonNull ReactorStmtCtx<?, ?, ?>> streamDeclared() {
return substatements.stream().filter(StmtContext::isSupportedToBuildEffective);
}
@Override
E createInferredEffective(final StatementFactory<A, D, E> factory, final InferredStatementContext<A, D, E> ctx,
- final Stream<? extends StmtContext<?, ?, ?>> declared,
- final Stream<? extends StmtContext<?, ?, ?>> effective) {
+ final Stream<? extends ReactorStmtCtx<?, ?, ?>> declared,
+ final Stream<? extends ReactorStmtCtx<?, ?, ?>> effective) {
return originalCtx.createInferredEffective(factory, ctx, declared, effective);
}
// ... copy-sensitive check
final List<EffectiveCopy> declCopy = prototype.streamDeclared()
- .map(sub -> effectiveCopy((ReactorStmtCtx<?, ?, ?>) sub))
+ .map(this::effectiveCopy)
.filter(Objects::nonNull)
.collect(Collectors.toUnmodifiableList());
final List<EffectiveCopy> effCopy = prototype.streamEffective()
- .map(sub -> effectiveCopy((ReactorStmtCtx<?, ?, ?>) sub))
+ .map(this::effectiveCopy)
.filter(Objects::nonNull)
.collect(Collectors.toUnmodifiableList());
return reusePrototypeReplicas(Streams.concat(prototype.streamDeclared(), prototype.streamEffective()));
}
- private List<ReactorStmtCtx<?, ?, ?>> reusePrototypeReplicas(final Stream<StmtContext<?, ?, ?>> stream) {
+ private List<ReactorStmtCtx<?, ?, ?>> reusePrototypeReplicas(final Stream<ReactorStmtCtx<?, ?, ?>> stream) {
return stream
.map(stmt -> {
- final ReplicaStatementContext<?, ?, ?> ret = ((ReactorStmtCtx<?, ?, ?>) stmt).replicaAsChildOf(this);
+ final var ret = stmt.replicaAsChildOf(this);
ret.buildEffective();
return ret;
})
}
@Override
- Stream<? extends @NonNull StmtContext<?, ?, ?>> streamDeclared() {
+ Stream<? extends @NonNull ReactorStmtCtx<?, ?, ?>> streamDeclared() {
return Stream.empty();
}
@Override
- Stream<? extends @NonNull StmtContext<?, ?, ?>> streamEffective() {
+ Stream<? extends @NonNull ReactorStmtCtx<?, ?, ?>> streamEffective() {
return ensureEffectiveSubstatements().stream().filter(StmtContext::isSupportedToBuildEffective);
}
}
@Override
- final Stream<? extends @NonNull StmtContext<?, ?, ?>> streamEffective() {
+ final Stream<? extends @NonNull ReactorStmtCtx<?, ?, ?>> streamEffective() {
return effective.stream().filter(StmtContext::isSupportedToBuildEffective);
}
* @return Built effective stateue
*/
abstract @NonNull E createInferredEffective(@NonNull StatementFactory<A, D, E> factory,
- @NonNull InferredStatementContext<A, D, E> ctx, Stream<? extends StmtContext<?, ?, ?>> declared,
- Stream<? extends StmtContext<?, ?, ?>> effective);
+ @NonNull InferredStatementContext<A, D, E> ctx, Stream<? extends ReactorStmtCtx<?, ?, ?>> declared,
+ Stream<? extends ReactorStmtCtx<?, ?, ?>> effective);
/**
* Attach an effective copy of this statement. This essentially acts as a map, where we make a few assumptions:
@Override
E createInferredEffective(final StatementFactory<A, D, E> factory, final InferredStatementContext<A, D, E> ctx,
- final Stream<? extends StmtContext<?, ?, ?>> declared,
- final Stream<? extends StmtContext<?, ?, ?>> effective) {
+ final Stream<? extends ReactorStmtCtx<?, ?, ?>> declared,
+ final Stream<? extends ReactorStmtCtx<?, ?, ?>> effective) {
return source.createInferredEffective(factory, ctx, declared, effective);
}
* @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 @NonNull ReactorStmtCtx<?, ?, ?>> streamDeclared();
/**
* Return a stream of inferred statements which can be built into an {@link EffectiveStatement}, as per
* @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();
+ abstract Stream<? extends @NonNull ReactorStmtCtx<?, ?, ?>> streamEffective();
@Override
final boolean doTryToCompletePhase(final byte targetOrder) {
}
@Override
- Stream<? extends @NonNull StmtContext<?, ?, ?>> streamDeclared() {
+ Stream<? extends @NonNull ReactorStmtCtx<?, ?, ?>> streamDeclared() {
return Stream.empty();
}
@Override
E createInferredEffective(final StatementFactory<A, D, E> factory, final InferredStatementContext<A, D, E> ctx,
- final Stream<? extends StmtContext<?, ?, ?>> declared,
- final Stream<? extends StmtContext<?, ?, ?>> effective) {
+ final Stream<? extends ReactorStmtCtx<?, ?, ?>> declared,
+ final Stream<? extends ReactorStmtCtx<?, ?, ?>> effective) {
final long declaredCount = declared.count();
verify(declaredCount == 0, "Unexpected non-empty declared statements in %s", ctx);
return createEffective(factory, new ForwardingUndeclaredCurrent<>(ctx), effective);