}
@Override
- public final D buildDeclared() {
+ public final D declared() {
final D existing;
return (existing = declaredInstance) != null ? existing : loadDeclared();
}
@Override
public D declared() {
- return delegate.buildDeclared();
+ return delegate.declared();
}
@Override
checkState(finishedPhase == ModelProcessingPhase.EFFECTIVE_MODEL);
final List<DeclaredStatement<?>> rootStatements = new ArrayList<>(sources.size());
for (final SourceSpecificContext source : sources) {
- rootStatements.add(source.getRoot().buildDeclared());
+ rootStatements.add(source.getRoot().declared());
}
return new ReactorDeclaredModel(rootStatements);
}
for (final SourceSpecificContext source : sources) {
final RootStatementContext<?, ?, ?> root = source.getRoot();
try {
- rootStatements.add(root.buildDeclared());
+ rootStatements.add(root.declared());
rootEffectiveStatements.add(root.buildEffective());
} catch (final RuntimeException ex) {
throw propagateException(source, ex);
}
@Override
- public D buildDeclared() {
+ public D declared() {
/*
* Share original instance of declared statement between all effective statements which have been copied or
* derived from this original declared statement.
*/
- return originalCtx.buildDeclared();
+ return originalCtx.declared();
}
@Override
@Override
public <D extends DeclaredStatement<?>> Prerequisite<D> requiresDeclared(
final StmtContext<?, ? extends D, ?> context) {
- return requiresCtxImpl(context, FULL_DECLARATION).transform(StmtContext::buildDeclared);
+ return requiresCtxImpl(context, FULL_DECLARATION).transform(StmtContext::declared);
}
@Override
requiresDeclared(final StmtContext<?, ?, ?> context, final Class<N> namespace, final K key) {
final AbstractPrerequisite<StmtContext<?, D, ?>> rawContext = requiresCtxImpl(context, namespace, key,
FULL_DECLARATION);
- return rawContext.transform(StmtContext::buildDeclared);
+ return rawContext.transform(StmtContext::declared);
}
@Override
/**
* Substatement refcount tracking. This mechanics deals with retaining substatements for the purposes of
* instantiating their lazy copies in InferredStatementContext. It works in concert with {@link #buildEffective()}
- * and {@link #buildDeclared()}: declared/effective statement views hold an implicit reference and refcount-based
+ * and {@link #declared()}: declared/effective statement views hold an implicit reference and refcount-based
* sweep is not activated until they are done (or this statement is not {@link #isSupportedToBuildEffective}).
*
* <p>
// 'input', which are implicitly defined.
// Our implementation design makes an invariant assumption that buildDeclared() has been called by the time
// we attempt to create effective statement:
- buildDeclared();
+ declared();
final E ret = effectiveInstance = createEffective();
// we have called createEffective(), substatements are no longer guarded by us. Let's see if we can clear up
}
@Override
- public D buildDeclared() {
- return source.buildDeclared();
+ public D declared() {
+ return source.declared();
}
@Override
@Override
public final D createDeclared(final StmtContext<A, D, ?> ctx) {
final ImmutableList<? extends DeclaredStatement<?>> substatements = ctx.declaredSubstatements().stream()
- .map(StmtContext::buildDeclared)
+ .map(StmtContext::declared)
.collect(ImmutableList.toImmutableList());
return substatements.isEmpty() ? createEmptyDeclared(ctx) : createDeclared(ctx, substatements);
}
* original collection, which may contains references to mutable context.
*/
substatements = ImmutableList.copyOf(Collections2.transform(context.declaredSubstatements(),
- StmtContext::buildDeclared));
+ StmtContext::declared));
}
@Override
--- /dev/null
+/*
+ * Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.yangtools.yang.parser.spi.meta;
+
+import com.google.common.annotations.Beta;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
+
+/**
+ * Intermediate compatibility interface between {@link StmtContext} and {@link EffectiveStmtCtx.Current}.
+ *
+ * @param <A> Argument type
+ * @param <D> Class representing declared version of this statement
+ */
+@Beta
+public interface BoundStmtCtxCompat<A, D extends DeclaredStatement<A>> extends BoundStmtCtx<A>, StmtContextCompat {
+ /**
+ * Returns the {@link DeclaredStatement} view of this statement.
+ */
+ @NonNull D declared();
+}
* @param <D> Class representing declared version of this statement
*/
@Beta
- interface Current<A, D extends DeclaredStatement<A>> extends Parent, BoundStmtCtx<A>, NamespaceStmtCtx {
+ interface Current<A, D extends DeclaredStatement<A>> extends Parent, NamespaceStmtCtx, BoundStmtCtxCompat<A, D> {
@NonNull CommonStmtCtx root();
- @NonNull D declared();
-
@Nullable EffectiveStatement<?, ?> original();
/**
* @param <E> Effective Statement representation
*/
public interface StmtContext<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>>
- extends BoundStmtCtx<A>, NamespaceStmtCtx, StmtContextCompat {
+ extends NamespaceStmtCtx, BoundStmtCtxCompat<A, D> {
@Deprecated(forRemoval = true)
default @NonNull StatementDefinition getPublicDefinition() {
return publicDefinition();
return Streams.concat(declaredSubstatements().stream(), effectiveSubstatements().stream());
}
- /**
- * Builds {@link DeclaredStatement} for statement context.
- */
- D buildDeclared();
-
/**
* Builds {@link EffectiveStatement} for statement context.
*/
Code Review / yangtools.git / commitdiff