import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
@VisibleForTesting
public final class AnyxmlSchemaLocationEffectiveStatementImpl
implements AnyxmlSchemaLocationEffectiveStatement {
private final @NonNull SchemaPath path;
- AnyxmlSchemaLocationEffectiveStatementImpl(final AnyxmlSchemaLocationStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final StmtContext<SchemaNodeIdentifier, AnyxmlSchemaLocationStatement, ?> ctx) {
- super(ctx.coerceStatementArgument(), declared, substatements, ctx);
- path = ctx.coerceParentContext().getSchemaPath().get().createChild(getNodeType());
+ AnyxmlSchemaLocationEffectiveStatementImpl(
+ final Current<SchemaNodeIdentifier, AnyxmlSchemaLocationStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(stmt, substatements);
+ path = stmt.getParent().getSchemaPath().createChild(getNodeType());
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ArgumentUtils;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
@Override
protected AnyxmlSchemaLocationEffectiveStatement createEffective(
- final StmtContext<SchemaNodeIdentifier, AnyxmlSchemaLocationStatement,
- AnyxmlSchemaLocationEffectiveStatement> ctx, final AnyxmlSchemaLocationStatement declared,
+ final Current<SchemaNodeIdentifier, AnyxmlSchemaLocationStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new AnyxmlSchemaLocationEffectiveStatementImpl(declared, substatements, ctx);
- }
-
- @Override
- protected AnyxmlSchemaLocationEffectiveStatement createEmptyEffective(
- final StmtContext<SchemaNodeIdentifier, AnyxmlSchemaLocationStatement,
- AnyxmlSchemaLocationEffectiveStatement> ctx, final AnyxmlSchemaLocationStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
+ return new AnyxmlSchemaLocationEffectiveStatementImpl(stmt, substatements);
}
}
\ No newline at end of file
import java.util.Map;
import java.util.Optional;
+import java.util.stream.Stream;
import org.opendaylight.yangtools.odlext.model.api.AnyxmlSchemaLocationEffectiveStatement;
import org.opendaylight.yangtools.odlext.model.api.AnyxmlSchemaLocationStatement;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.anyxml.AnyxmlStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.SchemaTreeNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.ForwardingStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
}
@Override
- public AnyxmlEffectiveStatement createEffective(
- final StmtContext<QName, AnyxmlStatement, AnyxmlEffectiveStatement> ctx) {
- final AnyxmlEffectiveStatement delegateStatement = delegate().createEffective(ctx);
+ public AnyxmlEffectiveStatement createEffective(final Current<QName, AnyxmlStatement> stmt,
+ final Stream<? extends StmtContext<?, ?, ?>> declaredSubstatements,
+ final Stream<? extends StmtContext<?, ?, ?>> effectiveSubstatements) {
+ final AnyxmlEffectiveStatement delegateStatement = super.createEffective(stmt, declaredSubstatements,
+ effectiveSubstatements);
+
final Map<StatementDefinition, Mutable<SchemaNodeIdentifier, AnyxmlSchemaLocationStatement,
- AnyxmlSchemaLocationEffectiveStatement>> schemaLocations =
- ctx.getAllFromCurrentStmtCtxNamespace(AnyxmlSchemaLocationNamespace.class);
+ AnyxmlSchemaLocationEffectiveStatement>> schemaLocations =
+ stmt.getAllFromCurrentStmtCtxNamespace(AnyxmlSchemaLocationNamespace.class);
if (schemaLocations != null && !schemaLocations.isEmpty()) {
final SchemaNodeIdentifier anyXmlSchemaNodeIdentifier = schemaLocations.values().iterator().next()
.getStatementArgument();
- final Optional<ContainerSchemaNode> anyXmlSchema = getAnyXmlSchema(ctx, anyXmlSchemaNodeIdentifier);
+ final Optional<ContainerSchemaNode> anyXmlSchema = getAnyXmlSchema(stmt, anyXmlSchemaNodeIdentifier);
if (anyXmlSchema.isPresent()) {
return new YangModeledAnyxmlEffectiveStatementImpl(delegateStatement, anyXmlSchema.get());
}
return delegateStatement;
}
- private static Optional<ContainerSchemaNode> getAnyXmlSchema(
- final StmtContext<QName, AnyxmlStatement, AnyxmlEffectiveStatement> ctx,
+ private static Optional<ContainerSchemaNode> getAnyXmlSchema(final Current<QName, AnyxmlStatement> stmt,
final SchemaNodeIdentifier contentSchemaPath) {
- return SchemaTreeNamespace.findNode(ctx.getRoot(), contentSchemaPath)
+ return SchemaTreeNamespace.findNode(stmt.caerbannog().getRoot(), contentSchemaPath)
.map(StmtContext::buildEffective)
.filter(ContainerSchemaNode.class::isInstance).map(ContainerSchemaNode.class::cast);
}
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithoutArgument.WithSubstatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseVoidStatementSupport;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
private final @NonNull StatementDefinition definition;
private final SchemaPath path;
- Effective(final OpenConfigHashedValueStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final StmtContext<Void, OpenConfigHashedValueStatement, ?> ctx) {
- super(declared.argument(), declared, substatements, ctx);
- definition = ctx.getPublicDefinition();
- path = ctx.coerceParentContext().getSchemaPath().get().createChild(
- ctx.getPublicDefinition().getStatementName());
+ Effective(final Current<Void, OpenConfigHashedValueStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(stmt, substatements);
+ definition = stmt.publicDefinition();
+ path = stmt.getParent().getSchemaPath().createChild(stmt.publicDefinition().getStatementName());
}
@Override
}
@Override
- protected final OpenConfigHashedValueEffectiveStatement createEffective(
- final StmtContext<Void, OpenConfigHashedValueStatement, OpenConfigHashedValueEffectiveStatement> ctx,
- final OpenConfigHashedValueStatement declared,
+ protected OpenConfigHashedValueEffectiveStatement createEffective(
+ final Current<Void, OpenConfigHashedValueStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new Effective(declared, substatements, ctx);
+ return new Effective(stmt, substatements);
}
- @Override
- protected final OpenConfigHashedValueEffectiveStatement createEmptyEffective(
- final StmtContext<Void, OpenConfigHashedValueStatement, OpenConfigHashedValueEffectiveStatement> ctx,
- final OpenConfigHashedValueStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
- }
}
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithoutArgument.WithSubstatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseVoidStatementSupport;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
implements GetFilterElementAttributesEffectiveStatement, GetFilterElementAttributesSchemaNode {
private final @NonNull SchemaPath path;
- Effective(final GetFilterElementAttributesStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final StmtContext<Void, GetFilterElementAttributesStatement, ?> ctx) {
- super(declared.argument(), declared, substatements, ctx);
- path = ctx.coerceParentContext().getSchemaPath().get().createChild(
- ctx.getPublicDefinition().getStatementName());
+ Effective(final Current<Void, GetFilterElementAttributesStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(stmt, substatements);
+ path = stmt.getParent().getSchemaPath().createChild(stmt.publicDefinition().getStatementName());
}
@Override
@Override
protected GetFilterElementAttributesEffectiveStatement createEffective(
- final StmtContext<Void, GetFilterElementAttributesStatement,
- GetFilterElementAttributesEffectiveStatement> ctx,
- final GetFilterElementAttributesStatement declared,
+ final Current<Void, GetFilterElementAttributesStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new Effective(declared, substatements, ctx);
- }
-
- @Override
- protected GetFilterElementAttributesEffectiveStatement createEmptyEffective(
- final StmtContext<Void, GetFilterElementAttributesStatement,
- GetFilterElementAttributesEffectiveStatement> ctx,
- final GetFilterElementAttributesStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
+ return new Effective(stmt, substatements);
}
private static boolean computeSupported(final StmtContext<?, ?, ?> stmt) {
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithoutArgument.WithSubstatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseVoidStatementSupport;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
implements DefaultDenyAllEffectiveStatement, DefaultDenyAllSchemaNode {
private final @NonNull SchemaPath path;
- Effective(final DefaultDenyAllStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final StmtContext<Void, DefaultDenyAllStatement, ?> ctx) {
- super(declared.argument(), declared, substatements, ctx);
- path = ctx.coerceParentContext().getSchemaPath().get().createChild(
- ctx.getPublicDefinition().getStatementName());
+ Effective(final Current<Void, DefaultDenyAllStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(stmt, substatements);
+ path = stmt.getParent().getSchemaPath().createChild(stmt.publicDefinition().getStatementName());
}
@Override
}
@Override
- protected DefaultDenyAllEffectiveStatement createEffective(
- final StmtContext<Void, DefaultDenyAllStatement, DefaultDenyAllEffectiveStatement> ctx,
- final DefaultDenyAllStatement declared,
+ protected DefaultDenyAllEffectiveStatement createEffective(final Current<Void, DefaultDenyAllStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new Effective(declared, substatements, ctx);
- }
-
- @Override
- protected DefaultDenyAllEffectiveStatement createEmptyEffective(
- final StmtContext<Void, DefaultDenyAllStatement, DefaultDenyAllEffectiveStatement> ctx,
- final DefaultDenyAllStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
+ return new Effective(stmt, substatements);
}
}
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithoutArgument.WithSubstatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseVoidStatementSupport;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
implements DefaultDenyWriteEffectiveStatement, DefaultDenyWriteSchemaNode {
private final @NonNull SchemaPath path;
- Effective(final DefaultDenyWriteStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final StmtContext<Void, DefaultDenyWriteStatement, ?> ctx) {
- super(declared.argument(), declared, substatements, ctx);
- path = ctx.coerceParentContext().getSchemaPath().get().createChild(
- ctx.getPublicDefinition().getStatementName());
+ Effective(final Current<Void, DefaultDenyWriteStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(stmt, substatements);
+ path = stmt.getParent().getSchemaPath().createChild(stmt.publicDefinition().getStatementName());
}
@Override
}
@Override
- protected DefaultDenyWriteEffectiveStatement createEffective(
- final StmtContext<Void, DefaultDenyWriteStatement, DefaultDenyWriteEffectiveStatement> ctx,
- final DefaultDenyWriteStatement declared,
+ protected DefaultDenyWriteEffectiveStatement createEffective(final Current<Void, DefaultDenyWriteStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new Effective(declared, substatements, ctx);
- }
-
- @Override
- protected DefaultDenyWriteEffectiveStatement createEmptyEffective(
- final StmtContext<Void, DefaultDenyWriteStatement, DefaultDenyWriteEffectiveStatement> ctx,
- final DefaultDenyWriteStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
+ return new Effective(stmt, substatements);
}
}
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
final class AliasEffectiveStatementImpl extends UnknownEffectiveStatementBase<String, AliasStatement>
implements AliasEffectiveStatement, AliasSchemaNode {
private final SchemaPath path;
- AliasEffectiveStatementImpl(final AliasStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final StmtContext<String, AliasStatement, ?> ctx) {
- super(ctx.coerceStatementArgument(), declared, substatements, ctx);
- path = ctx.coerceParentContext().getSchemaPath().get().createChild(getNodeType());
+ AliasEffectiveStatementImpl(final Current<String, AliasStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(stmt, substatements);
+ path = stmt.getParent().getSchemaPath().createChild(getNodeType());
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStringStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected AliasEffectiveStatement createEffective(
- final StmtContext<String, AliasStatement, AliasEffectiveStatement> ctx, final AliasStatement declared,
+ protected AliasEffectiveStatement createEffective(final Current<String, AliasStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new AliasEffectiveStatementImpl(declared, substatements, ctx);
- }
-
- @Override
- protected AliasEffectiveStatement createEmptyEffective(
- final StmtContext<String, AliasStatement, AliasEffectiveStatement> ctx, final AliasStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
+ return new AliasEffectiveStatementImpl(stmt, substatements);
}
}
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
final class DefValEffectiveStatementImpl extends UnknownEffectiveStatementBase<String, DefValStatement>
implements DefValEffectiveStatement, DefValSchemaNode {
private final SchemaPath path;
- DefValEffectiveStatementImpl(final DefValStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final StmtContext<String, DefValStatement, ?> ctx) {
- super(ctx.coerceStatementArgument(), declared, substatements, ctx);
- path = ctx.coerceParentContext().getSchemaPath().get().createChild(getNodeType());
+ DefValEffectiveStatementImpl(final Current<String, DefValStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(stmt, substatements);
+ path = stmt.getParent().getSchemaPath().createChild(getNodeType());
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStringStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected DefValEffectiveStatement createEffective(
- final StmtContext<String, DefValStatement, DefValEffectiveStatement> ctx, final DefValStatement declared,
+ protected DefValEffectiveStatement createEffective(final Current<String, DefValStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new DefValEffectiveStatementImpl(declared, substatements, ctx);
- }
-
- @Override
- protected DefValEffectiveStatement createEmptyEffective(
- final StmtContext<String, DefValStatement, DefValEffectiveStatement> ctx, final DefValStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
+ return new DefValEffectiveStatementImpl(stmt, substatements);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
final class DisplayHintEffectiveStatementImpl extends UnknownEffectiveStatementBase<String, DisplayHintStatement>
implements DisplayHintEffectiveStatement, DisplayHintSchemaNode {
private final SchemaPath path;
- DisplayHintEffectiveStatementImpl(final DisplayHintStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final StmtContext<String, DisplayHintStatement, ?> ctx) {
- super(ctx.getStatementArgument(), declared, substatements, ctx);
- path = ctx.coerceParentContext().getSchemaPath().get().createChild(getNodeType());
+ DisplayHintEffectiveStatementImpl(final Current<String, DisplayHintStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(stmt, substatements);
+ path = stmt.getParent().getSchemaPath().createChild(getNodeType());
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStringStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected DisplayHintEffectiveStatement createEffective(
- final StmtContext<String, DisplayHintStatement, DisplayHintEffectiveStatement> ctx,
- final DisplayHintStatement declared,
+ protected DisplayHintEffectiveStatement createEffective(final Current<String, DisplayHintStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new DisplayHintEffectiveStatementImpl(declared, substatements, ctx);
- }
-
- @Override
- protected DisplayHintEffectiveStatement createEmptyEffective(
- final StmtContext<String, DisplayHintStatement, DisplayHintEffectiveStatement> ctx,
- final DisplayHintStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
+ return new DisplayHintEffectiveStatementImpl(stmt, substatements);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
final class ImpliedEffectiveStatementImpl extends UnknownEffectiveStatementBase<String, ImpliedStatement>
implements ImpliedEffectiveStatement, ImpliedSchemaNode {
private final SchemaPath path;
- ImpliedEffectiveStatementImpl(final ImpliedStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final StmtContext<String, ImpliedStatement, ?> ctx) {
- super(ctx.getStatementArgument(), declared, substatements, ctx);
- path = ctx.coerceParentContext().getSchemaPath().get().createChild(getNodeType());
+ ImpliedEffectiveStatementImpl(final Current<String, ImpliedStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(stmt, substatements);
+ path = stmt.getParent().getSchemaPath().createChild(getNodeType());
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStringStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected ImpliedEffectiveStatement createEffective(
- final StmtContext<String, ImpliedStatement, ImpliedEffectiveStatement> ctx,
- final ImpliedStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new ImpliedEffectiveStatementImpl(declared, substatements, ctx);
- }
-
- @Override
- protected ImpliedEffectiveStatement createEmptyEffective(
- final StmtContext<String, ImpliedStatement, ImpliedEffectiveStatement> ctx,
- final ImpliedStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
+ protected ImpliedEffectiveStatement createEffective(final Current<String, ImpliedStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return new ImpliedEffectiveStatementImpl(stmt, substatements);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
final class MaxAccessEffectiveStatementImpl extends UnknownEffectiveStatementBase<MaxAccess, MaxAccessStatement>
implements MaxAccessEffectiveStatement, MaxAccessSchemaNode {
private final SchemaPath path;
- MaxAccessEffectiveStatementImpl(final MaxAccessStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final StmtContext<MaxAccess, MaxAccessStatement, ?> ctx) {
- super(declared.argument(), declared, substatements, ctx);
- path = ctx.coerceParentContext().getSchemaPath().get().createChild(getNodeType());
+ MaxAccessEffectiveStatementImpl(final Current<MaxAccess, MaxAccessStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(stmt, substatements);
+ path = stmt.getParent().getSchemaPath().createChild(getNodeType());
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
}
@Override
- protected MaxAccessEffectiveStatement createEffective(
- final StmtContext<MaxAccess, MaxAccessStatement, MaxAccessEffectiveStatement> ctx,
- final MaxAccessStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new MaxAccessEffectiveStatementImpl(declared, substatements, ctx);
- }
-
- @Override
- protected MaxAccessEffectiveStatement createEmptyEffective(
- final StmtContext<MaxAccess, MaxAccessStatement, MaxAccessEffectiveStatement> ctx,
- final MaxAccessStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
+ protected MaxAccessEffectiveStatement createEffective(final Current<MaxAccess, MaxAccessStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return new MaxAccessEffectiveStatementImpl(stmt, substatements);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
final class OidEffectiveStatementImpl extends UnknownEffectiveStatementBase<ObjectIdentifier, OidStatement>
implements OidEffectiveStatement, OidSchemaNode {
private final SchemaPath path;
- OidEffectiveStatementImpl(final OidStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final StmtContext<ObjectIdentifier, OidStatement, ?> ctx) {
- super(declared.argument(), declared, substatements, ctx);
- path = ctx.coerceParentContext().getSchemaPath().get().createChild(getNodeType());
+ OidEffectiveStatementImpl(final Current<ObjectIdentifier, OidStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(stmt, substatements);
+ path = stmt.getParent().getSchemaPath().createChild(getNodeType());
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
}
@Override
- protected OidEffectiveStatement createEffective(
- final StmtContext<ObjectIdentifier, OidStatement, OidEffectiveStatement> ctx,
- final OidStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new OidEffectiveStatementImpl(declared, substatements, ctx);
- }
-
- @Override
- protected OidEffectiveStatement createEmptyEffective(
- final StmtContext<ObjectIdentifier, OidStatement, OidEffectiveStatement> ctx, final OidStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
+ protected OidEffectiveStatement createEffective(final Current<ObjectIdentifier, OidStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return new OidEffectiveStatementImpl(stmt, substatements);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
final class SubIdEffectiveStatementImpl extends UnknownEffectiveStatementBase<Uint32, SubIdStatement>
implements SubIdEffectiveStatement, SubIdSchemaNode {
private final SchemaPath path;
- SubIdEffectiveStatementImpl(final SubIdStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final StmtContext<Uint32, SubIdStatement, ?> ctx) {
- super(declared.argument(), declared, substatements, ctx);
- path = ctx.coerceParentContext().getSchemaPath().get().createChild(getNodeType());
+ SubIdEffectiveStatementImpl(final Current<Uint32, SubIdStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(stmt, substatements);
+ path = stmt.getParent().getSchemaPath().createChild(getNodeType());
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected SubIdEffectiveStatement createEffective(
- final StmtContext<Uint32, SubIdStatement, SubIdEffectiveStatement> ctx,
- final SubIdStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new SubIdEffectiveStatementImpl(declared, substatements, ctx);
- }
-
- @Override
- protected SubIdEffectiveStatement createEmptyEffective(
- final StmtContext<Uint32, SubIdStatement, SubIdEffectiveStatement> ctx, final SubIdStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
+ protected SubIdEffectiveStatement createEffective(final Current<Uint32, SubIdStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return new SubIdEffectiveStatementImpl(stmt, substatements);
}
}
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithQNameArgument.WithSubstatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
private final @NonNull TypeDefinition<?> type;
private final @NonNull SchemaPath path;
- Effective(final AnnotationStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final StmtContext<QName, AnnotationStatement, ?> ctx) {
- super(ctx.coerceStatementArgument(), declared, substatements, ctx);
- path = ctx.coerceParentContext().getSchemaPath().get().createChild(argument());
+ Effective(final Current<QName, AnnotationStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(stmt, substatements);
+ path = stmt.getParent().getSchemaPath().createChild(argument());
final TypeEffectiveStatement<?> typeStmt = SourceException.throwIfNull(
- firstSubstatementOfType(TypeEffectiveStatement.class), ctx.getStatementSourceReference(),
+ firstSubstatementOfType(TypeEffectiveStatement.class), stmt.sourceReference(),
"AnnotationStatementSupport %s is missing a 'type' statement", argument());
final ConcreteTypeBuilder<?> builder = ConcreteTypes.concreteTypeBuilder(typeStmt.getTypeDefinition(),
path);
- final StmtContext<String, ?, ?> unitsStmt = StmtContextUtils.findFirstEffectiveSubstatement(ctx,
- UnitsStatement.class);
+ final StmtContext<String, ?, ?> unitsStmt = StmtContextUtils.findFirstEffectiveSubstatement(
+ stmt.caerbannog(), UnitsStatement.class);
if (unitsStmt != null) {
builder.setUnits(unitsStmt.getStatementArgument());
}
}
@Override
- protected AnnotationEffectiveStatement createEffective(
- final StmtContext<QName, AnnotationStatement, AnnotationEffectiveStatement> ctx,
- final AnnotationStatement declared,
+ protected AnnotationEffectiveStatement createEffective(final Current<QName, AnnotationStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new Effective(declared, substatements, ctx);
- }
-
- @Override
- protected AnnotationEffectiveStatement createEmptyEffective(
- final StmtContext<QName, AnnotationStatement, AnnotationEffectiveStatement> ctx,
- final AnnotationStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
+ return new Effective(stmt, substatements);
}
}
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ContainerEffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
@Beta
private final @NonNull QName maybeQNameArgument;
private final @NonNull ContainerEffectiveStatement container;
- YangDataEffectiveStatementImpl(final YangDataStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final StmtContext<String, YangDataStatement, ?> ctx) {
- super(ctx.getStatementArgument(), declared, substatements, ctx);
+ YangDataEffectiveStatementImpl(final Current<String, YangDataStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(stmt, substatements);
QName maybeQNameArgumentInit;
try {
- maybeQNameArgumentInit = StmtContextUtils.parseIdentifier(ctx, argument());
+ maybeQNameArgumentInit = StmtContextUtils.parseIdentifier(stmt.caerbannog(), argument());
} catch (IllegalArgumentException e) {
maybeQNameArgumentInit = getNodeType();
}
this.maybeQNameArgument = maybeQNameArgumentInit;
- path = ctx.coerceParentContext().getSchemaPath().get().createChild(maybeQNameArgument);
+ path = stmt.getParent().getSchemaPath().createChild(maybeQNameArgument);
container = findFirstEffectiveSubstatement(ContainerEffectiveStatement.class).get();
// TODO: this is strong binding of two API contracts. Unfortunately ContainerEffectiveStatement design is
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithRawStringArgument.WithSubstatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStringStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected YangDataEffectiveStatement createEffective(
- final StmtContext<String, YangDataStatement, YangDataEffectiveStatement> ctx,
- final YangDataStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ protected YangDataEffectiveStatement createEffective(final Current<String, YangDataStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
// in case of yang-data node we need to perform substatement validation at the point when we have
// effective substatement contexts already available - if the node has only a uses statement declared in it,
// one top-level container node may very well be added to the yang-data as an effective statement
- validator.validate(ctx);
- return new YangDataEffectiveStatementImpl(declared, substatements, ctx);
- }
-
- @Override
- protected YangDataEffectiveStatement createEmptyEffective(
- final StmtContext<String, YangDataStatement, YangDataEffectiveStatement> ctx,
- final YangDataStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
+ validator.validate(stmt.caerbannog());
+ return new YangDataEffectiveStatementImpl(stmt, substatements);
}
}
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredStatement.WithQNameArgument.WithSubstatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseQNameStatementSupport;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
private final @NonNull SchemaPath path;
- Effective(final MountPointStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final StmtContext<QName, MountPointStatement, ?> ctx) {
- super(ctx.coerceStatementArgument(), declared, substatements, ctx);
- path = ctx.coerceParentContext().getSchemaPath().get().createChild(argument());
+ Effective(final Current<QName, MountPointStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(stmt, substatements);
+ path = stmt.getParent().getSchemaPath().createChild(argument());
}
@Override
}
@Override
- protected MountPointEffectiveStatement createEffective(
- final StmtContext<QName, MountPointStatement, MountPointEffectiveStatement> ctx,
- final MountPointStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new Effective(declared, substatements, ctx);
- }
-
- @Override
- protected MountPointEffectiveStatement createEmptyEffective(
- final StmtContext<QName, MountPointStatement, MountPointEffectiveStatement> ctx,
- final MountPointStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
+ protected MountPointEffectiveStatement createEffective(final Current<QName, MountPointStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return new Effective(stmt, substatements);
}
}
import java.util.Collection;
import java.util.List;
import java.util.Optional;
+import java.util.stream.Stream;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
return effective;
}
+ @Override
+ final Stream<? extends StmtContext<?, ?, ?>> streamDeclared() {
+ return declaredSubstatements().stream();
+ }
+
+ @Override
+ final Stream<? extends StmtContext<?, ?, ?>> streamEffective() {
+ return effective.stream();
+ }
+
/**
* Lookup substatement by its offset in this statement.
*
--- /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.stmt.reactor;
+
+import static java.util.Objects.requireNonNull;
+
+import java.util.Map;
+import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.yangtools.yang.common.YangVersion;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
+import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.parser.spi.meta.CopyHistory;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx;
+import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
+
+// FIXME: YANGTOOLS-1185: integrate this into StatementContextBase
+final class BaseCurrentEffectiveStmtCtx<A, D extends DeclaredStatement<A>> implements EffectiveStmtCtx.Current<A, D> {
+ static final Object NULL_OBJ = new Object();
+
+ private final @NonNull StmtContext<A, D, ?> delegate;
+
+ private @Nullable Object parent;
+
+ BaseCurrentEffectiveStmtCtx(final StmtContext<A, D, ?> delegate) {
+ this.delegate = requireNonNull(delegate);
+ this.parent = null;
+ }
+
+ BaseCurrentEffectiveStmtCtx(final StmtContext<A, D, ?> delegate, final Parent parent) {
+ this.delegate = requireNonNull(delegate);
+ this.parent = requireNonNull(parent);
+ }
+
+ @Override
+ public StatementSourceReference sourceReference() {
+ return delegate.getStatementSourceReference();
+ }
+
+ @Override
+ public CopyHistory history() {
+ return delegate.getCopyHistory();
+ }
+
+ @Override
+ public D declared() {
+ return delegate.buildDeclared();
+ }
+
+ @Override
+ public <K, V, T extends K, N extends IdentifierNamespace<K, V>> V getFromNamespace(
+ final Class<@NonNull N> type, final T key) {
+ return delegate.getFromNamespace(type, key);
+ }
+
+ @Override
+ public boolean effectiveConfig() {
+ return delegate.isConfiguration();
+ }
+
+ @Override
+ @Deprecated
+ public Optional<SchemaPath> schemaPath() {
+ return delegate.getSchemaPath();
+ }
+
+ @Override
+ public StatementDefinition publicDefinition() {
+ return delegate.getPublicDefinition();
+ }
+
+ @Override
+ public Parent parent() {
+ final Object local = parent;
+ if (local instanceof Parent) {
+ return (Parent) local;
+ } else if (NULL_OBJ.equals(local)) {
+ return null;
+ } else {
+ return loadParent();
+ }
+ }
+
+ // FIXME: YANGTOOLS-1185: this should be rendered unnecessary
+ private Parent loadParent() {
+ final StmtContext<?, ?, ?> parentDelegate = delegate.getParentContext();
+ if (parentDelegate == null) {
+ parent = NULL_OBJ;
+ return null;
+ }
+
+ final Parent ret = new BaseCurrentEffectiveStmtCtx<>(parentDelegate);
+ parent = ret;
+ return ret;
+ }
+
+ @Override
+ public <K, V, N extends IdentifierNamespace<K, V>> Map<K, V>
+ getAllFromCurrentStmtCtxNamespace(final Class<N> type) {
+ return delegate.getAllFromCurrentStmtCtxNamespace(type);
+ }
+
+ @Override
+ public A argument() {
+ return delegate.getStatementArgument();
+ }
+
+ @Override
+ public String rawArgument() {
+ return delegate.rawStatementArgument();
+ }
+
+ @Override
+ public EffectiveStatement<?, ?> original() {
+ return delegate.getOriginalCtx().map(StmtContext::buildEffective).orElse(null);
+ }
+
+ @Override
+ public YangVersion yangVersion() {
+ return delegate.getRootVersion();
+ }
+
+ @Override
+ @Deprecated
+ @SuppressWarnings("unchecked")
+ public <Z extends EffectiveStatement<A, D>> StmtContext<A, D, Z> caerbannog() {
+ return (StmtContext<A, D, Z>) delegate;
+ }
+}
\ No newline at end of file
}
}
+ @Override
+ Stream<? extends StmtContext<?, ?, ?>> streamDeclared() {
+ return Stream.empty();
+ }
+
+ @Override
+ Stream<? extends StmtContext<?, ?, ?>> streamEffective() {
+ // FIXME: YANGTOOLS-1184: do not force initialization
+ return ensureEffectiveSubstatements().stream();
+ }
+
private List<StatementContextBase<?, ?, ?>> initializeSubstatements(
final Map<StmtContext<?, ?, ?>, StatementContextBase<?, ?, ?>> materializedSchemaTree) {
final Collection<? extends StatementContextBase<?, ?, ?>> declared = prototype.mutableDeclaredSubstatements();
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;
+import java.util.stream.Stream;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
}
private E loadEffective() {
- return effectiveInstance = definition.getFactory().createEffective(this);
+ return effectiveInstance = definition.getFactory().createEffective(new BaseCurrentEffectiveStmtCtx<>(this),
+ streamDeclared(), streamEffective());
}
+ abstract Stream<? extends StmtContext<?, ?, ?>> streamDeclared();
+
+ abstract Stream<? extends StmtContext<?, ?, ?>> streamEffective();
+
/**
* Try to execute current {@link ModelProcessingPhase} of source parsing. If the phase has already been executed,
* this method does nothing.
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
final class OpenConfigVersionEffectiveStatementImpl
extends UnknownEffectiveStatementBase<SemVer, OpenConfigVersionStatement>
private final @NonNull SchemaPath path;
- OpenConfigVersionEffectiveStatementImpl(final OpenConfigVersionStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final StmtContext<SemVer, OpenConfigVersionStatement, ?> ctx) {
- super(ctx.coerceStatementArgument(), declared, substatements, ctx);
- path = ctx.coerceParentContext().getSchemaPath().get().createChild(getNodeType());
+ OpenConfigVersionEffectiveStatementImpl(final Current<SemVer, OpenConfigVersionStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(stmt, substatements);
+ path = stmt.getParent().getSchemaPath().createChild(getNodeType());
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.SemanticVersionNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
@Override
protected OpenConfigVersionEffectiveStatement createEffective(
- final StmtContext<SemVer, OpenConfigVersionStatement, OpenConfigVersionEffectiveStatement> ctx,
- final OpenConfigVersionStatement declared,
+ final Current<SemVer, OpenConfigVersionStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new OpenConfigVersionEffectiveStatementImpl(declared, substatements, ctx);
- }
-
- @Override
- protected OpenConfigVersionEffectiveStatement createEmptyEffective(
- final StmtContext<SemVer, OpenConfigVersionStatement, OpenConfigVersionEffectiveStatement> ctx,
- final OpenConfigVersionStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
+ return new OpenConfigVersionEffectiveStatementImpl(stmt, substatements);
}
}
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeAwareEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.DataNodeContainerMixin;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
E extends SchemaTreeAwareEffectiveStatement<A, D>> extends DefaultWithSchemaTree<A, D, E> {
private final @NonNull Object substatements;
- protected WithSubstatements(final D declared, final StmtContext<?, ?, ?> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- super(declared, ctx, substatements);
+ protected WithSubstatements(final D declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
+ final StatementSourceReference ref) {
+ super(declared, substatements, ref);
this.substatements = maskList(substatements);
}
private final @NonNull ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
private final @NonNull D declared;
- protected DefaultWithSchemaTree(final D declared, final StmtContext<?, ?, ?> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ protected DefaultWithSchemaTree(final D declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
+ final StatementSourceReference ref) {
this.declared = requireNonNull(declared);
- this.schemaTree = ImmutableMap.copyOf(createSchemaTreeNamespace(
- ctx.getStatementSourceReference(), substatements));
+ this.schemaTree = ImmutableMap.copyOf(createSchemaTreeNamespace(ref, substatements));
}
@Override
E extends DataTreeAwareEffectiveStatement<A, D>> extends DefaultWithDataTree<A, D, E> {
private final @NonNull Object substatements;
- protected WithSubstatements(final D declared, final StmtContext<?, ?, ?> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- super(declared, ctx, substatements);
+ protected WithSubstatements(final D declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
+ final StatementSourceReference ref) {
+ super(declared, substatements, ref);
this.substatements = maskList(substatements);
}
private final @NonNull ImmutableMap<QName, DataTreeEffectiveStatement<?>> dataTree;
private final @NonNull D declared;
- protected DefaultWithDataTree(final D declared, final StmtContext<?, ?, ?> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ protected DefaultWithDataTree(final D declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
+ final StatementSourceReference ref) {
this.declared = requireNonNull(declared);
- final StatementSourceReference ref = ctx.getStatementSourceReference();
final Map<QName, SchemaTreeEffectiveStatement<?>> schema = createSchemaTreeNamespace(ref, substatements);
this.schemaTree = ImmutableMap.copyOf(schema);
this.dataTree = createDataTreeNamespace(ref, schema.values(), schemaTree);
import org.opendaylight.yangtools.yang.model.api.stmt.compat.NotificationNodeContainerCompat;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.DefaultWithDataTree.WithSubstatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.DocumentedNodeMixin;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
import org.opendaylight.yangtools.yang.parser.spi.source.ImportPrefixToModuleCtx;
private final ImmutableSet<TypeDefinition<?>> typeDefinitions;
private final ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTreeNamespace;
- protected AbstractEffectiveModule(final D declared,
- final StmtContext<UnqualifiedQName, D, ? extends EffectiveStatement<UnqualifiedQName, ?>> ctx,
+ protected AbstractEffectiveModule(final Current<UnqualifiedQName, D> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final String prefix) {
- super(declared, ctx, substatements);
+ super(stmt.declared(), substatements, stmt.sourceReference());
// This check is rather weird, but comes from our desire to lower memory footprint while providing both
// EffectiveStatements and SchemaNode interfaces -- which do not overlap completely where child lookups are
// concerned. This ensures that we have SchemaTree index available for use with child lookups.
final Map<QName, SchemaTreeEffectiveStatement<?>> schemaTree =
- createSchemaTreeNamespace(ctx.getStatementSourceReference(), effectiveSubstatements());
+ createSchemaTreeNamespace(stmt.sourceReference(), effectiveSubstatements());
schemaTreeNamespace = ImmutableMap.copyOf(schemaTree);
// Data tree check, not currently used
- createDataTreeNamespace(ctx.getStatementSourceReference(), schemaTree.values(), schemaTreeNamespace);
+ createDataTreeNamespace(stmt.sourceReference(), schemaTree.values(), schemaTreeNamespace);
this.prefix = requireNonNull(prefix);
final Set<UsesNode> mutableUses = new LinkedHashSet<>();
final Set<TypeDefinition<?>> mutableTypeDefinitions = new LinkedHashSet<>();
+ final var rabbit = stmt.caerbannog();
for (final EffectiveStatement<?, ?> effectiveStatement : effectiveSubstatements()) {
if (effectiveStatement instanceof UsesNode && !mutableUses.add((UsesNode) effectiveStatement)) {
- throw EffectiveStmtUtils.createNameCollisionSourceException(ctx, effectiveStatement);
+ throw EffectiveStmtUtils.createNameCollisionSourceException(rabbit, stmt.sourceReference(),
+ effectiveStatement);
}
if (effectiveStatement instanceof TypedefEffectiveStatement) {
final TypeDefinition<?> type = ((TypedefEffectiveStatement) effectiveStatement).getTypeDefinition();
if (!mutableTypeDefinitions.add(type)) {
- throw EffectiveStmtUtils.createNameCollisionSourceException(ctx, effectiveStatement);
+ throw EffectiveStmtUtils.createNameCollisionSourceException(rabbit, stmt.sourceReference(),
+ effectiveStatement);
}
}
if (effectiveStatement instanceof GroupingDefinition
&& !mutableGroupings.add((GroupingDefinition) effectiveStatement)) {
- throw EffectiveStmtUtils.createNameCollisionSourceException(ctx, effectiveStatement);
+ throw EffectiveStmtUtils.createNameCollisionSourceException(rabbit, stmt.sourceReference(),
+ effectiveStatement);
}
}
.toString();
}
- protected static final @NonNull String findPrefix(final @NonNull StmtContext<?, ?, ?> ctx,
- final String type, final String name) {
+ protected static final @NonNull String findPrefix1(final Current<?, ?> stmt, final String type, final String name) {
+ return findPrefix(stmt.caerbannog(), type, name);
+ }
+
+ protected static final @NonNull String findPrefix(final StmtContext<?, ?, ?> stmt, final String type,
+ final String name) {
return SourceException.throwIfNull(
- StmtContextUtils.firstAttributeOf(ctx.declaredSubstatements(), PrefixStatement.class),
- ctx.getStatementSourceReference(), "Unable to resolve prefix for %s %s.", type, name);
+ StmtContextUtils.firstAttributeOf(stmt.declaredSubstatements(), PrefixStatement.class),
+ stmt.getStatementSourceReference(), "Unable to resolve prefix for %s %s.", type, name);
}
// Alright. this is quite ugly
- protected final void appendPrefixes(final StmtContext<?, ?, ?> ctx,
+ protected final void appendPrefixes(final Current<?, ?> stmt,
final Builder<String, ModuleEffectiveStatement> builder) {
streamEffectiveSubstatements(ImportEffectiveStatement.class)
.map(imp -> imp.findFirstEffectiveSubstatementArgument(PrefixEffectiveStatement.class).get())
.forEach(pfx -> {
final StmtContext<?, ?, ?> importedCtx =
- verifyNotNull(ctx.getFromNamespace(ImportPrefixToModuleCtx.class, pfx),
+ verifyNotNull(stmt.getFromNamespace(ImportPrefixToModuleCtx.class, pfx),
"Failed to resolve prefix %s", pfx);
builder.put(pfx, (ModuleEffectiveStatement) importedCtx.buildEffective());
});
import org.opendaylight.yangtools.yang.model.api.stmt.DataTreeEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeAwareEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
@Beta
E extends SchemaTreeAwareEffectiveStatement<A, D>> extends DefaultWithSchemaTree<A, D, E> {
private final @NonNull Object substatements;
- protected WithSubstatements(final StmtContext<?, ?, ?> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- super(ctx, substatements);
+ protected WithSubstatements(final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
+ final StatementSourceReference ref) {
+ super(substatements, ref);
this.substatements = maskList(substatements);
}
private final @NonNull ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
- protected DefaultWithSchemaTree(final StmtContext<?, ?, ?> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- this.schemaTree = ImmutableMap.copyOf(createSchemaTreeNamespace(
- ctx.getStatementSourceReference(), substatements));
+ protected DefaultWithSchemaTree(final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
+ final StatementSourceReference ref) {
+ this.schemaTree = ImmutableMap.copyOf(createSchemaTreeNamespace(ref, substatements));
}
@Override
E extends DataTreeAwareEffectiveStatement<A, D>> extends DefaultWithDataTree<A, D, E> {
private final @NonNull Object substatements;
- protected WithSubstatements(final StmtContext<?, ?, ?> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- super(ctx, substatements);
+ protected WithSubstatements(final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
+ final StatementSourceReference ref) {
+ super(substatements, ref);
this.substatements = maskList(substatements);
}
private final @NonNull ImmutableMap<QName, SchemaTreeEffectiveStatement<?>> schemaTree;
private final @NonNull ImmutableMap<QName, DataTreeEffectiveStatement<?>> dataTree;
- protected DefaultWithDataTree(final StmtContext<?, ?, ?> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- final StatementSourceReference ref = ctx.getStatementSourceReference();
+ protected DefaultWithDataTree(final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
+ final StatementSourceReference ref) {
final Map<QName, SchemaTreeEffectiveStatement<?>> schema = createSchemaTreeNamespace(ref, substatements);
this.schemaTree = ImmutableMap.copyOf(schema);
this.dataTree = createDataTreeNamespace(ref, schema.values(), schemaTree);
import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
+import com.google.common.collect.ImmutableList;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
/**
}
@Override
- protected final E createEmptyEffective(final StmtContext<Boolean, D, E> ctx, final D declared) {
+ protected final E createEffective(final Current<Boolean, D> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return substatements.isEmpty() ? createEmptyEffective(stmt) : createEffective(stmt.declared(), substatements);
+ }
+
+ protected abstract @NonNull E createEffective(@NonNull D declared,
+ ImmutableList<? extends EffectiveStatement<?, ?>> substatements);
+
+ protected abstract @NonNull E createEmptyEffective(@NonNull D declared);
+
+ private @NonNull E createEmptyEffective(final Current<Boolean, D> stmt) {
+ final D declared = stmt.declared();
if (emptyDeclaredTrue.equals(declared)) {
return emptyEffectiveTrue;
} else if (emptyDeclaredFalse.equals(declared)) {
return createEmptyEffective(declared);
}
}
-
- protected abstract @NonNull E createEmptyEffective(@NonNull D declared);
}
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaTreeEffectiveStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
/**
* A massively-misnamed superclass for statements which are both schema tree participants and can be created as implicit
}
@Override
- protected final E createEffective(
- final StmtContext<QName, D, E> ctx,
- final D declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- final StatementSource source = ctx.getStatementSource();
- switch (ctx.getStatementSource()) {
+ protected E createEffective(final Current<QName, D> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ final StatementSource source = stmt.source();
+ switch (source) {
case CONTEXT:
- return createUndeclaredEffective(ctx, substatements);
+ return createUndeclaredEffective(stmt, substatements);
case DECLARATION:
- return createDeclaredEffective(ctx, substatements, declared);
+ return createDeclaredEffective(stmt, substatements);
default:
throw new IllegalStateException("Unhandled statement source " + source);
}
}
- @Override
- protected final E createEmptyEffective(final StmtContext<QName, D, E> ctx, final D declared) {
- return createEffective(ctx, declared, ImmutableList.of());
- }
-
- protected abstract @NonNull E createDeclaredEffective(@NonNull StmtContext<QName, D, E> ctx,
- @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements, @NonNull D declared);
-
- protected abstract @NonNull E createUndeclaredEffective(@NonNull StmtContext<QName, D, E> ctx,
+ protected abstract @NonNull E createDeclaredEffective(@NonNull Current<QName, D> stmt,
@NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements);
+ protected abstract @NonNull E createUndeclaredEffective(@NonNull Current<QName, D> stmt,
+ @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements);
}
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
/**
protected abstract @NonNull D createEmptyDeclared(@NonNull A argument);
@Override
- protected final E createEmptyEffective(final StmtContext<A, D, E> ctx, final D declared) {
- return effectiveCache.getUnchecked(declared);
+ protected final E createEffective(final Current<A, D> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return substatements.isEmpty() ? effectiveCache.getUnchecked(stmt.declared())
+ : createEffective(stmt.declared(), substatements);
}
+ protected abstract @NonNull E createEffective(@NonNull D declared,
+ @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements);
+
protected abstract @NonNull E createEmptyEffective(@NonNull D declared);
@Override
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.SchemaTreeEffectiveStatement;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
}
@Override
- protected final @NonNull E createDeclaredEffective(final StmtContext<QName, D, E> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final D declared) {
- return createDeclaredEffective(historyAndStatusFlags(ctx, substatements), ctx, substatements, declared);
+ protected final @NonNull E createDeclaredEffective(final Current<QName, D> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return createDeclaredEffective(historyAndStatusFlags(stmt.history(), substatements), stmt, substatements);
}
- protected abstract @NonNull E createDeclaredEffective(int flags, @NonNull StmtContext<QName, D, E> ctx,
- @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements, @NonNull D declared);
+ protected abstract @NonNull E createDeclaredEffective(int flags, @NonNull Current<QName, D> stmt,
+ @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements);
@Override
- protected final E createUndeclaredEffective(final StmtContext<QName, D, E> ctx,
+ protected final E createUndeclaredEffective(final Current<QName, D> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return createUndeclaredEffective(historyAndStatusFlags(ctx, substatements), ctx, substatements);
+ return createUndeclaredEffective(historyAndStatusFlags(stmt.history(), substatements), stmt, substatements);
}
- protected abstract @NonNull E createUndeclaredEffective(int flags, @NonNull StmtContext<QName, D, E> ctx,
+ protected abstract @NonNull E createUndeclaredEffective(int flags, @NonNull Current<QName, D> stmt,
@NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements);
}
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
+import org.opendaylight.yangtools.yang.parser.spi.meta.CopyHistory;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
/**
return ctx.coerceStatementArgument().bindTo(targetModule).intern();
}
- protected static final int historyAndStatusFlags(final StmtContext<?, ?, ?> ctx,
+ protected static final int historyAndStatusFlags(final CopyHistory history,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return new FlagsBuilder()
- .setHistory(ctx.getCopyHistory())
+ .setHistory(history)
.setStatus(findFirstArgument(substatements, StatusEffectiveStatement.class, Status.CURRENT))
.toFlags();
}
import java.util.HashSet;
import java.util.List;
import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
/**
* @param <D> Declared Statement representation
* @param <E> Effective Statement representation
*/
+// FIXME: YANGTOOLS-1161: move this into yang-parser-spi, as the substatement handling has natural place there. Also
+// we rely on getEffectOfStatement() -- which is something reactor mechanics need to make work better.
@Beta
public abstract class BaseStatementSupport<A, D extends DeclaredStatement<A>,
E extends EffectiveStatement<A, D>> extends AbstractStatementSupport<A, D, E> {
protected abstract @NonNull D createEmptyDeclared(@NonNull StmtContext<A, D, ?> ctx);
@Override
- public E createEffective(final StmtContext<A, D, E> ctx) {
- final D declared = ctx.buildDeclared();
+ public E createEffective(final Current<A, D> stmt,
+ final Stream<? extends StmtContext<?, ?, ?>> declaredSubstatements,
+ final Stream<? extends StmtContext<?, ?, ?>> effectiveSubstatements) {
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements =
- buildEffectiveSubstatements(ctx, statementsToBuild(ctx, declaredSubstatements(ctx)));
- return substatements.isEmpty() ? createEmptyEffective(ctx, declared)
- : createEffective(ctx, declared, substatements);
+ buildEffectiveSubstatements(stmt, statementsToBuild(stmt,
+ declaredSubstatements(declaredSubstatements, effectiveSubstatements)));
+ return createEffective(stmt, substatements);
}
- protected abstract @NonNull E createEffective(@NonNull StmtContext<A, D, E> ctx, @NonNull D declared,
+ protected abstract @NonNull E createEffective(@NonNull Current<A, D> stmt,
@NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements);
- protected abstract @NonNull E createEmptyEffective(@NonNull StmtContext<A, D, E> ctx, @NonNull D declared);
-
/**
* 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.
*
- * @param ctx Parent statement context
+ * @param ctx Effective capture of this statement's significant state
* @param substatements Substatement contexts which have been determined to be built
* @return Substatement context which are to be actually built
*/
- protected List<? extends StmtContext<?, ?, ?>> statementsToBuild(final StmtContext<A, D, E> ctx,
+ protected List<? extends StmtContext<?, ?, ?>> statementsToBuild(final Current<A, D> ctx,
final List<? extends StmtContext<?, ?, ?>> substatements) {
return substatements;
}
* Create a set of substatements. This method is split out so it can be overridden in subclasses adjust the
* resulting statements.
*
- * @param ctx Parent statement context
+ * @param stmt Current statement context
* @param substatements proposed substatements
* @return Built effective substatements
*/
- protected ImmutableList<? extends EffectiveStatement<?, ?>> buildEffectiveSubstatements(
- final StmtContext<A, D, E> ctx, final List<? extends StmtContext<?, ?, ?>> substatements) {
+ protected @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> buildEffectiveSubstatements(
+ final Current<A, D> stmt, final List<? extends StmtContext<?, ?, ?>> substatements) {
return defaultBuildEffectiveSubstatements(substatements);
}
- private static ImmutableList<? extends EffectiveStatement<?, ?>> defaultBuildEffectiveSubstatements(
+ private static @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> defaultBuildEffectiveSubstatements(
final List<? extends StmtContext<?, ?, ?>> substatements) {
return substatements.stream()
.filter(StmtContext::isSupportedToBuildEffective)
.collect(ImmutableList.toImmutableList());
}
- private static @NonNull List<StmtContext<?, ?, ?>> declaredSubstatements(final StmtContext<?, ?, ?> ctx) {
+ private static @NonNull List<StmtContext<?, ?, ?>> declaredSubstatements(
+ final Stream<? extends StmtContext<?, ?, ?>> declaredSubstatements,
+ final Stream<? extends StmtContext<?, ?, ?>> effectiveSubstatements) {
/*
* This dance is required to ensure that effects of 'uses' nodes are applied in the same order as
* the statements were defined -- i.e. if we have something like this:
* FIXME: 7.0.0: this really should be handled by UsesStatementSupport such that 'uses baz' would have a
* prerequisite of a resolved 'uses bar'.
*/
+ final List<StmtContext<?, ?, ?>> declaredInit = declaredSubstatements
+ .filter(StmtContext::isSupportedByFeatures)
+ .collect(Collectors.toList());
+
final List<StmtContext<?, ?, ?>> substatementsInit = new ArrayList<>();
Set<StmtContext<?, ?, ?>> filteredStatements = null;
- for (final StmtContext<?, ?, ?> declaredSubstatement : ctx.declaredSubstatements()) {
- if (declaredSubstatement.isSupportedByFeatures()) {
- substatementsInit.add(declaredSubstatement);
-
- final Collection<? extends StmtContext<?, ?, ?>> effect = declaredSubstatement.getEffectOfStatement();
- if (!effect.isEmpty()) {
- if (filteredStatements == null) {
- filteredStatements = new HashSet<>();
- }
- filteredStatements.addAll(effect);
- substatementsInit.addAll(effect);
+ for (final StmtContext<?, ?, ?> declaredSubstatement : declaredInit) {
+ substatementsInit.add(declaredSubstatement);
+
+ final Collection<? extends StmtContext<?, ?, ?>> effect = declaredSubstatement.getEffectOfStatement();
+ if (!effect.isEmpty()) {
+ if (filteredStatements == null) {
+ filteredStatements = new HashSet<>();
}
+ filteredStatements.addAll(effect);
+ substatementsInit.addAll(effect);
}
}
+ final Stream<? extends StmtContext<?, ?, ?>> effective;
if (filteredStatements != null) {
- for (StmtContext<?, ?, ?> stmt : ctx.effectiveSubstatements()) {
- if (!filteredStatements.contains(stmt)) {
- substatementsInit.add(stmt);
- }
- }
+ final Set<StmtContext<?, ?, ?>> filtered = filteredStatements;
+ effective = effectiveSubstatements.filter(stmt -> !filtered.contains(stmt));
} else {
- substatementsInit.addAll(ctx.effectiveSubstatements());
+ effective = effectiveSubstatements;
}
+ substatementsInit.addAll(effective.collect(Collectors.toList()));
return substatementsInit;
}
}
import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
@Beta
public final class EffectiveStmtUtils {
}
public static SourceException createNameCollisionSourceException(final StmtContext<?, ?, ?> ctx,
- final EffectiveStatement<?, ?> effectiveStatement) {
- return new SourceException(ctx.getStatementSourceReference(),
+ final StatementSourceReference ref, final EffectiveStatement<?, ?> effectiveStatement) {
+ return new SourceException(ref,
"Error in module '%s': cannot add '%s'. Node name collision: '%s' already declared.",
ctx.getRoot().rawStatementArgument(), effectiveStatement.argument(), effectiveStatement.argument());
}
}
public static void checkUniqueGroupings(final StmtContext<?, ?, ?> ctx,
- final Collection<? extends EffectiveStatement<?, ?>> statements) {
- checkUniqueNodes(ctx, statements, GroupingDefinition.class);
+ final Collection<? extends EffectiveStatement<?, ?>> statements, final StatementSourceReference ref) {
+ checkUniqueNodes(ctx, statements, GroupingDefinition.class, ref);
}
public static void checkUniqueTypedefs(final StmtContext<?, ?, ?> ctx,
- final Collection<? extends EffectiveStatement<?, ?>> statements) {
+ final Collection<? extends EffectiveStatement<?, ?>> statements, final StatementSourceReference ref) {
final Set<Object> typedefs = new HashSet<>();
for (EffectiveStatement<?, ?> stmt : statements) {
if (stmt instanceof TypedefEffectiveStatement
&& !typedefs.add(((TypedefEffectiveStatement) stmt).getTypeDefinition())) {
- throw EffectiveStmtUtils.createNameCollisionSourceException(ctx, stmt);
+ throw EffectiveStmtUtils.createNameCollisionSourceException(ctx, ref, stmt);
}
}
}
public static void checkUniqueUses(final StmtContext<?, ?, ?> ctx,
- final Collection<? extends EffectiveStatement<?, ?>> statements) {
- checkUniqueNodes(ctx, statements, UsesNode.class);
+ final Collection<? extends EffectiveStatement<?, ?>> statements, final StatementSourceReference ref) {
+ checkUniqueNodes(ctx, statements, UsesNode.class, ref);
}
private static void checkUniqueNodes(final StmtContext<?, ?, ?> ctx,
- final Collection<? extends EffectiveStatement<?, ?>> statements, final Class<?> type) {
+ final Collection<? extends EffectiveStatement<?, ?>> statements, final Class<?> type,
+ final StatementSourceReference ref) {
final Set<Object> nodes = new HashSet<>();
for (EffectiveStatement<?, ?> stmt : statements) {
if (type.isInstance(stmt) && !nodes.add(stmt)) {
- throw EffectiveStmtUtils.createNameCollisionSourceException(ctx, stmt);
+ throw EffectiveStmtUtils.createNameCollisionSourceException(ctx, ref, stmt);
}
}
}
import org.opendaylight.yangtools.yang.parser.spi.ExtensionNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.CopyHistory;
import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
public abstract class UnknownEffectiveStatementBase<A, D extends UnknownStatement<A>>
private final QName nodeType;
private final String nodeParameter;
- protected UnknownEffectiveStatementBase(final A argument, final @NonNull D declared,
- final @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- // FIXME: 7.0.0: we should not be needing this
- final StmtContext<A, D, ?> ctx) {
- super(argument, declared, substatements);
+ protected UnknownEffectiveStatementBase(final Current<A, D> stmt,
+ final @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(stmt.argument(), stmt.declared(), substatements);
final StmtContext<?, ExtensionStatement, ExtensionEffectiveStatement> extensionInit =
- ctx.getFromNamespace(ExtensionNamespace.class, ctx.getPublicDefinition().getStatementName());
+ stmt.getFromNamespace(ExtensionNamespace.class, stmt.publicDefinition().getStatementName());
if (extensionInit == null) {
extension = null;
- nodeType = ctx.getPublicDefinition().getStatementName();
+ nodeType = stmt.publicDefinition().getStatementName();
} else {
final EffectiveStatement<QName, ExtensionStatement> effective = extensionInit.buildEffective();
Preconditions.checkState(effective instanceof ExtensionDefinition,
}
// initCopyType
- final CopyHistory copyTypesFromOriginal = ctx.getCopyHistory();
+ final CopyHistory copyTypesFromOriginal = stmt.history();
if (copyTypesFromOriginal.contains(CopyType.ADDED_BY_USES_AUGMENTATION)) {
this.augmenting = true;
this.addedByUses = true;
this.addedByUses = copyTypesFromOriginal.contains(CopyType.ADDED_BY_USES);
}
- nodeParameter = ctx.rawStatementArgument() == null ? "" : ctx.rawStatementArgument();
+ nodeParameter = stmt.rawArgument() == null ? "" : stmt.rawArgument();
}
@Deprecated
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.DefaultWithDataTree.WithSubstatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.CopyableMixin;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.OperationDefinitionMixin;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
final class ActionEffectiveStatementImpl extends WithSubstatements<QName, ActionStatement, ActionEffectiveStatement>
implements ActionDefinition, ActionEffectiveStatement, OperationDefinitionMixin<ActionStatement>,
private final int flags;
ActionEffectiveStatementImpl(final ActionStatement declared, final SchemaPath path, final int flags,
- final StmtContext<QName, ActionStatement, ActionEffectiveStatement> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- super(declared, ctx, substatements);
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final StatementSourceReference ref) {
+ super(declared, substatements, ref);
this.path = requireNonNull(path);
this.flags = flags;
}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.action;
+import static com.google.common.base.Preconditions.checkState;
+
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseSchemaTreeStatementSupport;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.input.InputStatementRFC7950Support;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.output.OutputStatementRFC7950Support;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
}
@Override
- protected ActionEffectiveStatement createEffective(
- final StmtContext<QName, ActionStatement, ActionEffectiveStatement> ctx, final ActionStatement declared,
+ protected ActionEffectiveStatement createEffective(final Current<QName, ActionStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- final QName argument = ctx.coerceStatementArgument();
- final StatementSourceReference ref = ctx.getStatementSourceReference();
- SourceException.throwIf(StmtContextUtils.hasAncestorOfType(ctx, ILLEGAL_PARENTS), ref,
+ final StatementSourceReference ref = stmt.sourceReference();
+ checkState(!substatements.isEmpty(), "Missing implicit input/output statements at %s", ref);
+ final QName argument = stmt.coerceArgument();
+ final var rabbit = stmt.caerbannog();
+ SourceException.throwIf(StmtContextUtils.hasAncestorOfType(rabbit, ILLEGAL_PARENTS), ref,
"Action %s is defined within a notification, rpc or another action", argument);
SourceException.throwIf(
- !StmtContextUtils.hasAncestorOfTypeWithChildOfType(ctx, YangStmtMapping.LIST, YangStmtMapping.KEY), ref,
+ !StmtContextUtils.hasAncestorOfTypeWithChildOfType(rabbit, YangStmtMapping.LIST, YangStmtMapping.KEY), ref,
"Action %s is defined within a list that has no key statement", argument);
- SourceException.throwIf(StmtContextUtils.hasParentOfType(ctx, YangStmtMapping.CASE), ref,
+ SourceException.throwIf(StmtContextUtils.hasParentOfType(rabbit, YangStmtMapping.CASE), ref,
"Action %s is defined within a case statement", argument);
- SourceException.throwIf(StmtContextUtils.hasParentOfType(ctx, YangStmtMapping.MODULE), ref,
+ SourceException.throwIf(StmtContextUtils.hasParentOfType(rabbit, YangStmtMapping.MODULE), ref,
"Action %s is defined at the top level of a module", argument);
- return new ActionEffectiveStatementImpl(declared, ctx.getSchemaPath().get(),
- historyAndStatusFlags(ctx, substatements), ctx, substatements);
- }
-
- @Override
- protected ActionEffectiveStatement createEmptyEffective(
- final StmtContext<QName, ActionStatement, ActionEffectiveStatement> ctx, final ActionStatement declared) {
- throw new IllegalStateException("Missing implicit input/output statements at "
- + ctx.getStatementSourceReference());
+ return new ActionEffectiveStatementImpl(stmt.declared(), stmt.getSchemaPath(),
+ historyAndStatusFlags(stmt.history(), substatements), substatements, stmt.sourceReference());
}
}
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AnydataSchemaNode;
+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;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseSchemaTreeStatementSupport;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
+import org.opendaylight.yangtools.yang.parser.spi.meta.CopyHistory;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected AnydataEffectiveStatement createEffective(
- final StmtContext<QName, AnydataStatement, AnydataEffectiveStatement> ctx,
- final AnydataStatement declared,
+ protected AnydataEffectiveStatement createEffective(final Current<QName, AnydataStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularAnydataEffectiveStatement(declared, ctx.getSchemaPath().get(),
- computeFlags(ctx, substatements), findOriginal(ctx), substatements);
- }
+ final int flags = computeFlags(stmt.history(), stmt.effectiveConfig(), substatements);
+ final SchemaPath path = stmt.getSchemaPath();
- @Override
- protected AnydataEffectiveStatement createEmptyEffective(
- final StmtContext<QName, AnydataStatement, AnydataEffectiveStatement> ctx,
- final AnydataStatement declared) {
- return new EmptyAnydataEffectiveStatement(declared, ctx.getSchemaPath().get(),
- computeFlags(ctx, ImmutableList.of()), findOriginal(ctx));
+ return substatements.isEmpty()
+ ? new EmptyAnydataEffectiveStatement(stmt.declared(), path, flags, findOriginal(stmt))
+ : new RegularAnydataEffectiveStatement(stmt.declared(), path, flags, findOriginal(stmt), substatements);
}
- private static int computeFlags(final StmtContext<?, ?, ?> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ private static int computeFlags(final CopyHistory history, final boolean isConfig,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return new FlagsBuilder()
- .setHistory(ctx.getCopyHistory())
+ .setHistory(history)
.setStatus(findFirstArgument(substatements, StatusEffectiveStatement.class, Status.CURRENT))
- .setConfiguration(ctx.isConfiguration())
+ .setConfiguration(isConfig)
.setMandatory(findFirstArgument(substatements, MandatoryEffectiveStatement.class, Boolean.FALSE))
.toFlags();
}
- private static @Nullable AnydataSchemaNode findOriginal(final StmtContext<?, ?, ?> ctx) {
- return (AnydataSchemaNode) ctx.getOriginalCtx().map(StmtContext::buildEffective).orElse(null);
+ private static @Nullable AnydataSchemaNode findOriginal(final Current<?, ?> stmt) {
+ return (AnydataSchemaNode) stmt.original();
}
}
\ No newline at end of file
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.AnyxmlSchemaNode;
+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;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseSchemaTreeStatementSupport;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
+import org.opendaylight.yangtools.yang.parser.spi.meta.CopyHistory;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected AnyxmlEffectiveStatement createEffective(
- final StmtContext<QName, AnyxmlStatement, AnyxmlEffectiveStatement> ctx,
- final AnyxmlStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularAnyxmlEffectiveStatement(declared, ctx.getSchemaPath().get(),
- computeFlags(ctx, substatements), findOriginal(ctx),substatements);
- }
+ protected AnyxmlEffectiveStatement createEffective(final Current<QName, AnyxmlStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ final int flags = computeFlags(stmt.history(), stmt.effectiveConfig(), substatements);
+ final SchemaPath path = stmt.getSchemaPath();
- @Override
- protected AnyxmlEffectiveStatement createEmptyEffective(
- final StmtContext<QName, AnyxmlStatement, AnyxmlEffectiveStatement> ctx, final AnyxmlStatement declared) {
- return new EmptyAnyxmlEffectiveStatement(declared, ctx.getSchemaPath().get(),
- computeFlags(ctx, ImmutableList.of()), findOriginal(ctx));
+ return substatements.isEmpty()
+ ? new EmptyAnyxmlEffectiveStatement(stmt.declared(), path, flags, findOriginal(stmt))
+ : new RegularAnyxmlEffectiveStatement(stmt.declared(), path, flags, findOriginal(stmt),substatements);
}
- private static int computeFlags(final StmtContext<?, ?, ?> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ private static int computeFlags(final CopyHistory history, final boolean isConfig,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return new FlagsBuilder()
- .setHistory(ctx.getCopyHistory())
+ .setHistory(history)
.setStatus(findFirstArgument(substatements, StatusEffectiveStatement.class, Status.CURRENT))
- .setConfiguration(ctx.isConfiguration())
+ .setConfiguration(isConfig)
.setMandatory(findFirstArgument(substatements, MandatoryEffectiveStatement.class, Boolean.FALSE))
.toFlags();
}
- private static @Nullable AnyxmlSchemaNode findOriginal(final StmtContext<?, ?, ?> ctx) {
- return (AnyxmlSchemaNode) ctx.getOriginalCtx().map(StmtContext::buildEffective).orElse(null);
+ private static @Nullable AnyxmlSchemaNode findOriginal(final Current<?, ?> stmt) {
+ return (AnyxmlSchemaNode) stmt.original();
}
}
import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ArgumentStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseQNameStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected ArgumentEffectiveStatement createEffective(
- final StmtContext<QName, ArgumentStatement, ArgumentEffectiveStatement> ctx,
- final ArgumentStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularArgumentEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected ArgumentEffectiveStatement createEmptyEffective(
- final StmtContext<QName, ArgumentStatement, ArgumentEffectiveStatement> ctx,
- final ArgumentStatement declared) {
- return new EmptyArgumentEffectiveStatement(declared);
+ protected ArgumentEffectiveStatement createEffective(final Current<QName, ArgumentStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return substatements.isEmpty() ? new EmptyArgumentEffectiveStatement(stmt.declared())
+ : new RegularArgumentEffectiveStatement(stmt.declared(), substatements);
}
}
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
import org.opendaylight.yangtools.yang.parser.spi.SchemaTreeNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
@Override
protected final List<? extends StmtContext<?, ?, ?>> statementsToBuild(
- final StmtContext<SchemaNodeIdentifier, AugmentStatement, AugmentEffectiveStatement> ctx,
+ final Current<SchemaNodeIdentifier, AugmentStatement> stmt,
final List<? extends StmtContext<?, ?, ?>> substatements) {
- final StatementContextBase<?, ?, ?> implicitDef = ctx.getFromNamespace(AugmentImplicitHandlingNamespace.class,
- ctx);
+ // Pick up the marker left by onFullDefinitionDeclared() inference action. If it is present we need to pass our
+ // children through target's implicit wrapping.
+ final StatementContextBase<?, ?, ?> implicitDef = stmt.getFromNamespace(AugmentImplicitHandlingNamespace.class,
+ stmt.caerbannog());
return implicitDef == null ? substatements : Lists.transform(substatements, subCtx -> {
verify(subCtx instanceof StatementContextBase);
return implicitDef.wrapWithImplicit((StatementContextBase<?, ?, ?>) subCtx);
@Override
protected final AugmentEffectiveStatement createEffective(
- final StmtContext<SchemaNodeIdentifier, AugmentStatement, AugmentEffectiveStatement> ctx,
- final AugmentStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ final Current<SchemaNodeIdentifier, AugmentStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
final int flags = new FlagsBuilder()
.setStatus(findFirstArgument(substatements, StatusEffectiveStatement.class, Status.CURRENT))
.toFlags();
- return new AugmentEffectiveStatementImpl(declared, ctx.coerceStatementArgument(), flags,
- StmtContextUtils.getRootModuleQName(ctx), substatements, ctx.getStatementSourceReference(),
- (AugmentationSchemaNode) ctx.getOriginalCtx().map(StmtContext::buildEffective).orElse(null));
- }
-
- @Override
- protected final AugmentEffectiveStatement createEmptyEffective(
- final StmtContext<SchemaNodeIdentifier, AugmentStatement, AugmentEffectiveStatement> ctx,
- final AugmentStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
+ return new AugmentEffectiveStatementImpl(stmt.declared(), stmt.coerceArgument(), flags,
+ StmtContextUtils.getRootModuleQName(stmt.caerbannog()), substatements, stmt.sourceReference(),
+ (AugmentationSchemaNode) stmt.original());
}
private static StmtContext<?, ?, ?> getSearchRoot(final StmtContext<?, ?, ?> augmentContext) {
import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseQNameStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.IdentityNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
}
@Override
- protected BaseEffectiveStatement createEffective(
- final StmtContext<QName, BaseStatement, BaseEffectiveStatement> ctx, final BaseStatement declared,
+ protected BaseEffectiveStatement createEffective(final Current<QName, BaseStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularBaseEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected BaseEffectiveStatement createEmptyEffective(
- final StmtContext<QName, BaseStatement, BaseEffectiveStatement> ctx, final BaseStatement declared) {
- return new EmptyBaseEffectiveStatement(declared);
+ return substatements.isEmpty() ? new EmptyBaseEffectiveStatement(stmt.declared())
+ : new RegularBaseEffectiveStatement(stmt.declared(), substatements);
}
}
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStringStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
}
@Override
- protected BelongsToEffectiveStatement createEffective(
- final StmtContext<String, BelongsToStatement, BelongsToEffectiveStatement> ctx,
- final BelongsToStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularBelongsToEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected BelongsToEffectiveStatement createEmptyEffective(
- final StmtContext<String, BelongsToStatement, BelongsToEffectiveStatement> ctx,
- final BelongsToStatement declared) {
- return new EmptyBelongsToEffectiveStatement(declared);
+ protected BelongsToEffectiveStatement createEffective(final Current<String, BelongsToStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return substatements.isEmpty() ? new EmptyBelongsToEffectiveStatement(stmt.declared())
+ : new RegularBelongsToEffectiveStatement(stmt.declared(), substatements);
}
private static SourceIdentifier getSourceIdentifier(final StmtContext<String, BelongsToStatement,
import org.opendaylight.yangtools.yang.model.api.stmt.BitEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.BitStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
}
@Override
- protected final BitEffectiveStatement createEffective(
- final StmtContext<String, BitStatement, BitEffectiveStatement> ctx, final BitStatement declared,
+ protected final BitEffectiveStatement createEffective(final Current<String, BitStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularBitEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected final BitEffectiveStatement createEmptyEffective(
- final StmtContext<String, BitStatement, BitEffectiveStatement> ctx, final BitStatement declared) {
- return new EmptyBitEffectiveStatement(declared);
+ return substatements.isEmpty() ? new EmptyBitEffectiveStatement(stmt.declared())
+ : new RegularBitEffectiveStatement(stmt.declared(), substatements);
}
}
import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseImplicitStatementSupport;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
abstract class AbstractCaseStatementSupport
}
@Override
- protected final CaseEffectiveStatement createDeclaredEffective(
- final StmtContext<QName, CaseStatement, CaseEffectiveStatement> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final CaseStatement declared) {
- return new DeclaredCaseEffectiveStatement(declared, ctx, substatements, computeFlags(ctx, substatements),
- findOriginal(ctx));
+ protected final CaseEffectiveStatement createDeclaredEffective(final Current<QName, CaseStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return new DeclaredCaseEffectiveStatement(stmt.declared(), substatements, stmt.sourceReference(),
+ computeFlags(stmt, substatements), stmt.getSchemaPath(), findOriginal(stmt));
}
@Override
- protected final CaseEffectiveStatement createUndeclaredEffective(
- final StmtContext<QName, CaseStatement, CaseEffectiveStatement> ctx,
+ protected final CaseEffectiveStatement createUndeclaredEffective(final Current<QName, CaseStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new UndeclaredCaseEffectiveStatement(ctx, substatements, computeFlags(ctx, substatements),
- findOriginal(ctx));
+ return new UndeclaredCaseEffectiveStatement(substatements, stmt.sourceReference(),
+ computeFlags(stmt, substatements), stmt.getSchemaPath(), findOriginal(stmt));
}
- private static @Nullable CaseSchemaNode findOriginal(final StmtContext<?, ?, ?> ctx) {
- return (CaseSchemaNode) ctx.getOriginalCtx().map(StmtContext::buildEffective).orElse(null);
+ private static @Nullable CaseSchemaNode findOriginal(final Current<?, ?> stmt) {
+ return (CaseSchemaNode) stmt.original();
}
- private static int computeFlags(final StmtContext<?, ?, ?> ctx,
+ private static int computeFlags(final Current<?, ?> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return new FlagsBuilder()
- .setHistory(ctx.getCopyHistory())
+ .setHistory(stmt.history())
.setStatus(findFirstArgument(substatements, StatusEffectiveStatement.class, Status.CURRENT))
- .setConfiguration(ctx.isConfiguration()
- && ctx.allSubstatementsStream().anyMatch(StmtContext::isConfiguration))
+ .setConfiguration(stmt.effectiveConfig()
+ && stmt.caerbannog().allSubstatementsStream().anyMatch(StmtContext::isConfiguration))
.toFlags();
}
}
\ No newline at end of file
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.case_;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.stmt.CaseEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.CaseStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.DefaultWithSchemaTree.WithSubstatements;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
final class DeclaredCaseEffectiveStatement extends WithSubstatements<QName, CaseStatement, CaseEffectiveStatement>
implements CaseEffectiveStatementMixin {
private final int flags;
DeclaredCaseEffectiveStatement(final CaseStatement declared,
- final StmtContext<QName, CaseStatement, CaseEffectiveStatement> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final int flags,
- final @Nullable CaseSchemaNode original) {
- super(declared, ctx, substatements);
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final StatementSourceReference ref,
+ final int flags, final SchemaPath path, final @Nullable CaseSchemaNode original) {
+ super(declared, substatements, ref);
this.flags = flags;
- this.path = ctx.getSchemaPath().get();
+ this.path = requireNonNull(path);
this.original = original;
}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.case_;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.stmt.CaseEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.CaseStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractUndeclaredEffectiveStatement.DefaultWithSchemaTree.WithSubstatements;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
final class UndeclaredCaseEffectiveStatement extends WithSubstatements<QName, CaseStatement, CaseEffectiveStatement>
implements CaseEffectiveStatementMixin {
private final @NonNull SchemaPath path;
private final int flags;
- UndeclaredCaseEffectiveStatement(final StmtContext<QName, CaseStatement, CaseEffectiveStatement> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final int flags,
+ UndeclaredCaseEffectiveStatement(final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
+ final StatementSourceReference ref, final int flags, final SchemaPath path,
final @Nullable CaseSchemaNode original) {
- super(ctx, substatements);
+ super(substatements, ref);
+ this.path = requireNonNull(path);
this.flags = flags;
- this.path = ctx.getSchemaPath().get();
this.original = original;
}
import org.opendaylight.yangtools.yang.parser.rfc7950.reactor.YangValidationBundles;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseSchemaTreeStatementSupport;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.ImplicitParentAwareStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
}
@Override
- protected final ChoiceEffectiveStatement createEffective(
- final StmtContext<QName, ChoiceStatement, ChoiceEffectiveStatement> ctx,
- final ChoiceStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ protected ChoiceEffectiveStatement createEffective(final Current<QName, ChoiceStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
final String defaultArg = findFirstArgument(substatements, DefaultEffectiveStatement.class, null);
final CaseSchemaNode defaultCase;
if (defaultArg != null) {
final QName qname;
try {
- qname = QName.create(ctx.coerceStatementArgument(), defaultArg);
+ qname = QName.create(stmt.coerceArgument(), defaultArg);
} catch (IllegalArgumentException e) {
- throw new SourceException(ctx.getStatementSourceReference(), "Default statement has invalid name '%s'",
- defaultArg, e);
+ throw new SourceException(stmt.sourceReference(), "Default statement has invalid name '%s'",
+ defaultArg, e);
}
// FIXME: this does not work with submodules, as they are
defaultCase = InferenceException.throwIfNull(findCase(qname, substatements),
- ctx.getStatementSourceReference(), "Default statement refers to missing case %s", qname);
+ stmt.sourceReference(), "Default statement refers to missing case %s", qname);
} else {
defaultCase = null;
}
final int flags = new FlagsBuilder()
- .setHistory(ctx.getCopyHistory())
+ .setHistory(stmt.history())
.setStatus(findFirstArgument(substatements, StatusEffectiveStatement.class, Status.CURRENT))
- .setConfiguration(ctx.isConfiguration())
+ .setConfiguration(stmt.effectiveConfig())
.setMandatory(findFirstArgument(substatements, MandatoryEffectiveStatement.class, Boolean.FALSE))
.toFlags();
- return new ChoiceEffectiveStatementImpl(declared, ctx, substatements, flags, defaultCase,
- (ChoiceSchemaNode) ctx.getOriginalCtx().map(StmtContext::buildEffective).orElse(null));
- }
-
- @Override
- protected final ChoiceEffectiveStatement createEmptyEffective(
- final StmtContext<QName, ChoiceStatement, ChoiceEffectiveStatement> ctx, final ChoiceStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
+ return new ChoiceEffectiveStatementImpl(stmt.declared(), substatements, stmt.sourceReference(), flags,
+ stmt.getSchemaPath(), defaultCase, (ChoiceSchemaNode) stmt.original());
}
abstract StatementSupport<?, ?, ?> implictCase();
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.AugmentationTargetMixin;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.DataSchemaNodeMixin;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.MandatoryMixin;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
final class ChoiceEffectiveStatementImpl extends WithSubstatements<QName, ChoiceStatement, ChoiceEffectiveStatement>
implements ChoiceEffectiveStatement, ChoiceSchemaNode, DerivableSchemaNode,
private final int flags;
ChoiceEffectiveStatementImpl(final ChoiceStatement declared,
- final StmtContext<QName, ChoiceStatement, ChoiceEffectiveStatement> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final int flags,
- final @Nullable CaseSchemaNode defaultCase, final @Nullable ChoiceSchemaNode original) {
- super(declared, ctx, substatements);
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final StatementSourceReference ref,
+ final int flags, final SchemaPath path, final @Nullable CaseSchemaNode defaultCase,
+ final @Nullable ChoiceSchemaNode original) {
+ super(declared, substatements, ref);
+ this.path = requireNonNull(path);
this.flags = flags;
- this.path = ctx.getSchemaPath().get();
this.defaultCase = defaultCase;
this.original = original;
}
}
@Override
- protected ConfigEffectiveStatement createEffective(
- final StmtContext<Boolean, ConfigStatement, ConfigEffectiveStatement> ctx,
- final ConfigStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ protected ConfigEffectiveStatement createEffective(final ConfigStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return new RegularConfigEffectiveStatement(declared, substatements);
}
import org.opendaylight.yangtools.yang.model.api.stmt.ContactEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ContactStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStringStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected ContactEffectiveStatement createEffective(
- final StmtContext<String, ContactStatement, ContactEffectiveStatement> ctx,
- final ContactStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularContactEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected ContactEffectiveStatement createEmptyEffective(
- final StmtContext<String, ContactStatement, ContactEffectiveStatement> ctx,
- final ContactStatement declared) {
- return new EmptyContactEffectiveStatement(declared);
+ protected ContactEffectiveStatement createEffective(final Current<String, ContactStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return substatements.isEmpty() ? new EmptyContactEffectiveStatement(stmt.declared())
+ : new RegularContactEffectiveStatement(stmt.declared(), substatements);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseSchemaTreeStatementSupport;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
+import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStmtUtils;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
abstract class AbstractContainerStatementSupport
}
@Override
- protected final ContainerEffectiveStatement createEffective(
- final StmtContext<QName, ContainerStatement, ContainerEffectiveStatement> ctx,
- final ContainerStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
-
- final SchemaPath path = ctx.getSchemaPath().get();
- final ContainerSchemaNode original = (ContainerSchemaNode) ctx.getOriginalCtx().map(StmtContext::buildEffective)
- .orElse(null);
+ protected ContainerEffectiveStatement createEffective(final Current<QName, ContainerStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ final SchemaPath path = stmt.getSchemaPath();
+ final ContainerSchemaNode original = (ContainerSchemaNode) stmt.original();
final int flags = new FlagsBuilder()
- .setHistory(ctx.getCopyHistory())
+ .setHistory(stmt.history())
.setStatus(findFirstArgument(substatements, StatusEffectiveStatement.class, Status.CURRENT))
- .setConfiguration(ctx.isConfiguration())
+ .setConfiguration(stmt.effectiveConfig())
.setPresence(findFirstStatement(substatements, PresenceEffectiveStatement.class) != null)
.toFlags();
- return new ContainerEffectiveStatementImpl(declared, path, flags, ctx, substatements, original);
- }
- @Override
- protected final ContainerEffectiveStatement createEmptyEffective(
- final StmtContext<QName, ContainerStatement, ContainerEffectiveStatement> ctx,
- final ContainerStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
+ final var ref = stmt.sourceReference();
+ final var rabbit = stmt.caerbannog();
+ EffectiveStmtUtils.checkUniqueGroupings(rabbit, substatements, ref);
+ EffectiveStmtUtils.checkUniqueTypedefs(rabbit, substatements, ref);
+ EffectiveStmtUtils.checkUniqueUses(rabbit, substatements, ref);
+
+ return new ContainerEffectiveStatementImpl(stmt.declared(), substatements, stmt.sourceReference(), flags, path,
+ original);
}
}
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.MustConstraintMixin;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.NotificationNodeContainerMixin;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.PresenceMixin;
-import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStmtUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
final class ContainerEffectiveStatementImpl
extends WithSubstatements<QName, ContainerStatement, ContainerEffectiveStatement>
private final @NonNull SchemaPath path;
private final @Nullable ContainerSchemaNode original;
- ContainerEffectiveStatementImpl(final ContainerStatement declared, final SchemaPath path, final int flags,
- final StmtContext<?, ?, ?> ctx, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final ContainerSchemaNode original) {
- super(declared, ctx, substatements);
-
- EffectiveStmtUtils.checkUniqueGroupings(ctx, substatements);
- EffectiveStmtUtils.checkUniqueTypedefs(ctx, substatements);
- EffectiveStmtUtils.checkUniqueUses(ctx, substatements);
-
+ ContainerEffectiveStatementImpl(final ContainerStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final StatementSourceReference ref,
+ final int flags, final SchemaPath path, final ContainerSchemaNode original) {
+ super(declared, substatements, ref);
this.path = requireNonNull(path);
this.original = original;
this.flags = flags;
import org.opendaylight.yangtools.yang.model.api.stmt.DefaultEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DefaultStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStringStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected DefaultEffectiveStatement createEffective(
- final StmtContext<String, DefaultStatement, DefaultEffectiveStatement> ctx,
- final DefaultStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularDefaultEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected DefaultEffectiveStatement createEmptyEffective(
- final StmtContext<String, DefaultStatement, DefaultEffectiveStatement> ctx,
- final DefaultStatement declared) {
- return new EmptyDefaultEffectiveStatement(declared);
+ protected DefaultEffectiveStatement createEffective(final Current<String, DefaultStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return substatements.isEmpty() ? new EmptyDefaultEffectiveStatement(stmt.declared())
+ : new RegularDefaultEffectiveStatement(stmt.declared(), substatements);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DescriptionStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStringStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected DescriptionEffectiveStatement createEffective(
- final StmtContext<String, DescriptionStatement, DescriptionEffectiveStatement> ctx,
- final DescriptionStatement declared,
+ protected DescriptionEffectiveStatement createEffective(final Current<String, DescriptionStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularDescriptionEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected DescriptionEffectiveStatement createEmptyEffective(
- final StmtContext<String, DescriptionStatement, DescriptionEffectiveStatement> ctx,
- final DescriptionStatement declared) {
- return new EmptyDescriptionEffectiveStatement(declared);
+ return substatements.isEmpty() ? new EmptyDescriptionEffectiveStatement(stmt.declared())
+ : new RegularDescriptionEffectiveStatement(stmt.declared(), substatements);
}
}
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.SchemaTreeNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
}
@Override
- protected final DeviateEffectiveStatement createEffective(
- final StmtContext<DeviateKind, DeviateStatement, DeviateEffectiveStatement> ctx,
- final DeviateStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new DeviateEffectiveStatementImpl(declared, substatements);
- }
-
- @Override
- protected final DeviateEffectiveStatement createEmptyEffective(
- final StmtContext<DeviateKind, DeviateStatement, DeviateEffectiveStatement> ctx,
- final DeviateStatement declared) {
- // This is exceedingly unlikely, just reuse the implementation
- return createEffective(ctx, declared, ImmutableList.of());
+ protected DeviateEffectiveStatement createEffective(final Current<DeviateKind, DeviateStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return new DeviateEffectiveStatementImpl(stmt.declared(), substatements);
}
protected SubstatementValidator getSubstatementValidatorForDeviate(final DeviateKind deviateKind) {
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Absolute;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ArgumentUtils;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
}
@Override
- protected DeviationEffectiveStatement createEffective(
- final StmtContext<Absolute, DeviationStatement, DeviationEffectiveStatement> ctx,
- final DeviationStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new DeviationEffectiveStatementImpl(declared, substatements);
- }
-
- @Override
- protected DeviationEffectiveStatement createEmptyEffective(
- final StmtContext<Absolute, DeviationStatement, DeviationEffectiveStatement> ctx,
- final DeviationStatement declared) {
- return new DeviationEffectiveStatementImpl(declared, ImmutableList.of());
+ protected DeviationEffectiveStatement createEffective(final Current<Absolute, DeviationStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return new DeviationEffectiveStatementImpl(stmt.declared(), substatements);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.stmt.EnumEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.EnumStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
abstract class AbstractEnumStatementSupport
}
@Override
- protected final EnumEffectiveStatement createEffective(
- final StmtContext<String, EnumStatement, EnumEffectiveStatement> ctx, final EnumStatement declared,
+ protected EnumEffectiveStatement createEffective(final Current<String, EnumStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularEnumEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected final EnumEffectiveStatement createEmptyEffective(
- final StmtContext<String, EnumStatement, EnumEffectiveStatement> ctx, final EnumStatement declared) {
- return new EmptyEnumEffectiveStatement(declared);
+ return substatements.isEmpty() ? new EmptyEnumEffectiveStatement(stmt.declared())
+ : new RegularEnumEffectiveStatement(stmt.declared(), substatements);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ErrorAppTagStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStringStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected ErrorAppTagEffectiveStatement createEffective(
- final StmtContext<String, ErrorAppTagStatement, ErrorAppTagEffectiveStatement> ctx,
- final ErrorAppTagStatement declared,
+ protected ErrorAppTagEffectiveStatement createEffective(final Current<String, ErrorAppTagStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularErrorAppTagEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected ErrorAppTagEffectiveStatement createEmptyEffective(
- final StmtContext<String, ErrorAppTagStatement, ErrorAppTagEffectiveStatement> ctx,
- final ErrorAppTagStatement declared) {
- return new EmptyErrorAppTagEffectiveStatement(declared);
+ return substatements.isEmpty() ? new EmptyErrorAppTagEffectiveStatement(stmt.declared())
+ : new RegularErrorAppTagEffectiveStatement(stmt.declared(), substatements);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ErrorMessageStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStringStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected ErrorMessageEffectiveStatement createEffective(
- final StmtContext<String, ErrorMessageStatement, ErrorMessageEffectiveStatement> ctx,
- final ErrorMessageStatement declared,
+ protected ErrorMessageEffectiveStatement createEffective(final Current<String, ErrorMessageStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularErrorMessageEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected ErrorMessageEffectiveStatement createEmptyEffective(
- final StmtContext<String, ErrorMessageStatement, ErrorMessageEffectiveStatement> ctx,
- final ErrorMessageStatement declared) {
- return new EmptyErrorMessageEffectiveStatement(declared);
+ return substatements.isEmpty() ? new EmptyErrorMessageEffectiveStatement(stmt.declared())
+ : new RegularErrorMessageEffectiveStatement(stmt.declared(), substatements);
}
}
import com.google.common.collect.ImmutableList;
import java.util.IdentityHashMap;
import java.util.Map;
-import org.eclipse.jdt.annotation.NonNull;
+import java.util.stream.Stream;
import org.opendaylight.yangtools.openconfig.model.api.OpenConfigStatements;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.stmt.YinElementStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseQNameStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.ExtensionNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StatementDefinitionNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
.addOptional(YangStmtMapping.STATUS)
.build();
private static final ExtensionStatementSupport INSTANCE = new ExtensionStatementSupport();
+ // FIXME: YANGTOOLS-1185: use EffectiveStmtCtx.Current as key
private static final ThreadLocal<Map<StmtContext<?, ?, ?>, ExtensionEffectiveStatementImpl>> TL_BUILDERS =
new ThreadLocal<>();
}
@Override
- public ExtensionEffectiveStatement createEffective(
- final StmtContext<QName, ExtensionStatement, ExtensionEffectiveStatement> ctx) {
+ public ExtensionEffectiveStatement createEffective(final Current<QName, ExtensionStatement> stmt,
+ final Stream<? extends StmtContext<?, ?, ?>> declaredSubstatements,
+ final Stream<? extends StmtContext<?, ?, ?>> effectiveSubstatements) {
Map<StmtContext<?, ?, ?>, ExtensionEffectiveStatementImpl> tl = TL_BUILDERS.get();
if (tl == null) {
tl = new IdentityHashMap<>();
TL_BUILDERS.set(tl);
}
+ final StmtContext<?, ?, ?> ctx = stmt.caerbannog();
final ExtensionEffectiveStatementImpl existing = tl.get(ctx);
if (existing != null) {
// Implies non-empty map, no cleanup necessary
}
try {
- final ExtensionEffectiveStatementImpl created = new ExtensionEffectiveStatementImpl(ctx.buildDeclared(),
- ctx.getSchemaPath().get());
+ final ExtensionEffectiveStatementImpl created = new ExtensionEffectiveStatementImpl(stmt.declared(),
+ stmt.getSchemaPath());
verify(tl.put(ctx, created) == null);
try {
- return super.createEffective(ctx);
+ return super.createEffective(stmt, declaredSubstatements, effectiveSubstatements);
} finally {
verify(tl.remove(ctx) == created);
-
}
} finally {
if (tl.isEmpty()) {
}
@Override
- protected ExtensionEffectiveStatement createEffective(
- final StmtContext<QName, ExtensionStatement, ExtensionEffectiveStatement> ctx,
- final ExtensionStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return finishCreate(ctx, substatements);
- }
-
- @Override
- protected ExtensionEffectiveStatement createEmptyEffective(
- final StmtContext<QName, ExtensionStatement, ExtensionEffectiveStatement> ctx,
- final ExtensionStatement declared) {
- return finishCreate(ctx, ImmutableList.of());
- }
-
- private static @NonNull ExtensionEffectiveStatement finishCreate(final StmtContext<?, ?, ?> ctx,
+ protected ExtensionEffectiveStatement createEffective(final Current<QName, ExtensionStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
final ExtensionEffectiveStatementImpl ret = verifyNotNull(verifyNotNull(TL_BUILDERS.get(),
- "Statement build state not initialized").get(ctx), "No build state found for %s", ctx);
+ "Statement build state not initialized").get(stmt.caerbannog()), "No build state found for %s", stmt);
ret.setSubstatements(substatements);
return ret;
}
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.extension;
import java.util.Optional;
+import java.util.stream.Stream;
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;
import org.opendaylight.yangtools.yang.parser.spi.meta.AbstractStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- public UnrecognizedEffectiveStatement createEffective(
- final StmtContext<String, UnrecognizedStatement, UnrecognizedEffectiveStatement> ctx) {
- return definition.createEffective(ctx);
+ public UnrecognizedEffectiveStatement createEffective(final Current<String, UnrecognizedStatement> stmt,
+ final Stream<? extends StmtContext<?, ?, ?>> declaredSubstatements,
+ final Stream<? extends StmtContext<?, ?, ?>> effectiveSubstatements) {
+ return definition.createEffective(stmt, declaredSubstatements, effectiveSubstatements);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
import org.slf4j.Logger;
private final QName maybeQNameArgument;
private final @NonNull SchemaPath path;
- UnrecognizedEffectiveStatementImpl(final @NonNull UnrecognizedStatement declared,
- final @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final StmtContext<String, UnrecognizedStatement, ?> ctx) {
- super(ctx.getStatementArgument(), declared, substatements, ctx);
+ UnrecognizedEffectiveStatementImpl(final Current<String, UnrecognizedStatement> stmt,
+ final @NonNull ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(stmt, substatements);
// FIXME: Remove following section after fixing 4380
- final UnknownSchemaNode original = (UnknownSchemaNode) ctx.getOriginalCtx().map(StmtContext::buildEffective)
- .orElse(null);
+ final UnknownSchemaNode original = (UnknownSchemaNode) stmt.original();
if (original != null) {
this.maybeQNameArgument = original.getQName();
} else {
QName maybeQNameArgumentInit = null;
try {
- maybeQNameArgumentInit = StmtContextUtils.qnameFromArgument(ctx, argument());
+ maybeQNameArgumentInit = StmtContextUtils.qnameFromArgument(stmt.caerbannog(), argument());
} catch (SourceException e) {
LOG.debug("Not constructing QName from {}", argument(), e);
maybeQNameArgumentInit = getNodeType();
SchemaPath maybePath;
try {
- maybePath = ctx.coerceParentContext().getSchemaPath()
+ maybePath = stmt.getParent().schemaPath()
.map(parentPath -> parentPath.createChild(maybeQNameArgument)).orElse(null);
} catch (IllegalArgumentException | SourceException e) {
- LOG.debug("Cannot construct path for {}, attempting to recover", ctx, e);
+ LOG.debug("Cannot construct path for {}, attempting to recover", stmt, e);
maybePath = null;
}
path = maybePath;
import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnrecognizedStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected UnrecognizedEffectiveStatement createEffective(
- final StmtContext<String, UnrecognizedStatement, UnrecognizedEffectiveStatement> ctx,
- final UnrecognizedStatement declared,
+ protected UnrecognizedEffectiveStatement createEffective(final Current<String, UnrecognizedStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new UnrecognizedEffectiveStatementImpl(declared, substatements, ctx);
+ return new UnrecognizedEffectiveStatementImpl(stmt, substatements);
}
-
- @Override
- protected UnrecognizedEffectiveStatement createEmptyEffective(
- final StmtContext<String, UnrecognizedStatement, UnrecognizedEffectiveStatement> ctx,
- final UnrecognizedStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
- }
-
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseQNameStatementSupport;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
import org.opendaylight.yangtools.yang.parser.spi.FeatureNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
}
@Override
- protected FeatureEffectiveStatement createEffective(
- final StmtContext<QName, FeatureStatement, FeatureEffectiveStatement> ctx, final FeatureStatement declared,
+ protected FeatureEffectiveStatement createEffective(final Current<QName, FeatureStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularFeatureEffectiveStatement(declared, ctx.getSchemaPath().get(), computeFlags(substatements),
- substatements);
- }
-
- @Override
- protected FeatureEffectiveStatement createEmptyEffective(
- final StmtContext<QName, FeatureStatement, FeatureEffectiveStatement> ctx,
- final FeatureStatement declared) {
- return new EmptyFeatureEffectiveStatement(declared, ctx.getSchemaPath().get(), EMPTY_EFFECTIVE_FLAGS);
+ return substatements.isEmpty()
+ ? new EmptyFeatureEffectiveStatement(stmt.declared(), stmt.getSchemaPath(), EMPTY_EFFECTIVE_FLAGS)
+ : new RegularFeatureEffectiveStatement(stmt.declared(), stmt.getSchemaPath(),
+ computeFlags(substatements), substatements);
}
private static int computeFlags(final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableMap.Builder;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.FractionDigitsStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
}
@Override
- protected FractionDigitsEffectiveStatement createEffective(
- final StmtContext<Integer, FractionDigitsStatement, FractionDigitsEffectiveStatement> ctx,
- final FractionDigitsStatement declared,
+ protected FractionDigitsEffectiveStatement createEffective(final Current<Integer, FractionDigitsStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularFractionDigitsEffectiveStatement(declared, substatements);
+ return substatements.isEmpty() ? createEmptyEffective(stmt.declared())
+ : new RegularFractionDigitsEffectiveStatement(stmt.declared(), substatements);
}
- @Override
- protected FractionDigitsEffectiveStatement createEmptyEffective(
- final StmtContext<Integer, FractionDigitsStatement, FractionDigitsEffectiveStatement> ctx,
+ private static @NonNull FractionDigitsEffectiveStatement createEmptyEffective(
final FractionDigitsStatement declared) {
final EmptyFractionDigitsEffectiveStatement shared = EMPTY_EFF.get(declared);
return shared != null ? shared : new EmptyFractionDigitsEffectiveStatement(declared);
}
-}
\ No newline at end of file
+}
import org.opendaylight.yangtools.yang.model.api.stmt.GroupingStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseQNameStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.GroupingNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
}
@Override
- protected final GroupingEffectiveStatement createEffective(
- final StmtContext<QName, GroupingStatement, GroupingEffectiveStatement> ctx,
- final GroupingStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new GroupingEffectiveStatementImpl(declared, ctx, substatements,
- historyAndStatusFlags(ctx, substatements));
- }
-
- @Override
- protected GroupingEffectiveStatement createEmptyEffective(
- final StmtContext<QName, GroupingStatement, GroupingEffectiveStatement> ctx,
- final GroupingStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
+ protected GroupingEffectiveStatement createEffective(final Current<QName, GroupingStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return new GroupingEffectiveStatementImpl(stmt.declared(), substatements, stmt.sourceReference(),
+ historyAndStatusFlags(stmt.history(), substatements), stmt.getSchemaPath());
}
private static void checkDeclaredConflict(final StmtContext<QName, ?, ?> ctx) {
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.grouping;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.DataNodeContainerMixin;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.NotificationNodeContainerMixin;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.SchemaNodeMixin;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
final class GroupingEffectiveStatementImpl
extends WithSubstatements<QName, GroupingStatement, GroupingEffectiveStatement>
private final @NonNull SchemaPath path;
private final int flags;
- GroupingEffectiveStatementImpl(final GroupingStatement declared, final StmtContext<?, ?, ?> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final int flags) {
- super(declared, ctx, substatements);
- this.path = ctx.getSchemaPath().get();
+ GroupingEffectiveStatementImpl(final GroupingStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final StatementSourceReference ref,
+ final int flags, final SchemaPath path) {
+ super(declared, substatements, ref);
+ this.path = requireNonNull(path);
this.flags = flags;
}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.identity;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.DefaultArgument;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.SchemaNodeMixin;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
abstract class AbstractIdentityEffectiveStatement extends DefaultArgument<QName, IdentityStatement>
implements IdentityEffectiveStatement, IdentitySchemaNode, SchemaNodeMixin<QName, IdentityStatement> {
private final @NonNull SchemaPath path;
- AbstractIdentityEffectiveStatement(final IdentityStatement declared,
- final StmtContext<QName, IdentityStatement, IdentityEffectiveStatement> ctx) {
+ AbstractIdentityEffectiveStatement(final IdentityStatement declared, final SchemaPath path) {
super(declared);
- this.path = ctx.getSchemaPath().get();
+ this.path = requireNonNull(path);
}
@Override
@Override
public final String toString() {
- return MoreObjects.toStringHelper(this).add("qname", getQName()).add("path", getPath()).toString();
+ return MoreObjects.toStringHelper(this).add("qname", getQName()).add("path", path).toString();
}
}
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseQNameStatementSupport;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
import org.opendaylight.yangtools.yang.parser.spi.IdentityNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
}
@Override
- protected final IdentityEffectiveStatement createEffective(
- final StmtContext<QName, IdentityStatement, IdentityEffectiveStatement> ctx,
- final IdentityStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ protected final IdentityEffectiveStatement createEffective(final Current<QName, IdentityStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ if (substatements.isEmpty()) {
+ return new EmptyIdentityEffectiveStatement(stmt.declared(), stmt.getSchemaPath());
+ }
final List<IdentitySchemaNode> identities = new ArrayList<>();
- for (EffectiveStatement<?, ?> stmt : substatements) {
- if (stmt instanceof BaseEffectiveStatement) {
- final QName qname = ((BaseEffectiveStatement) stmt).argument();
+ for (EffectiveStatement<?, ?> substatement : substatements) {
+ if (substatement instanceof BaseEffectiveStatement) {
+ final QName qname = ((BaseEffectiveStatement) substatement).argument();
final IdentityEffectiveStatement identity =
- verifyNotNull(ctx.getFromNamespace(IdentityNamespace.class, qname),
+ verifyNotNull(stmt.getFromNamespace(IdentityNamespace.class, qname),
"Failed to find identity %s", qname)
.buildEffective();
verify(identity instanceof IdentitySchemaNode, "%s is not a IdentitySchemaNode", identity);
}
}
- return new RegularIdentityEffectiveStatement(declared, ctx, new FlagsBuilder()
+ return new RegularIdentityEffectiveStatement(stmt.declared(), stmt.getSchemaPath(), new FlagsBuilder()
.setStatus(findFirstArgument(substatements, StatusEffectiveStatement.class, Status.CURRENT))
.toFlags(), substatements, ImmutableSet.copyOf(identities));
}
-
- @Override
- protected final IdentityEffectiveStatement createEmptyEffective(
- final StmtContext<QName, IdentityStatement, IdentityEffectiveStatement> ctx,
- final IdentityStatement declared) {
- return new EmptyIdentityEffectiveStatement(declared, ctx);
- }
}
import com.google.common.collect.ImmutableSet;
import java.util.Collection;
-import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.Status;
-import org.opendaylight.yangtools.yang.model.api.stmt.IdentityEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
final class EmptyIdentityEffectiveStatement extends AbstractIdentityEffectiveStatement {
private static final int CURRENT_FLAGS = new FlagsBuilder().setStatus(Status.CURRENT).toFlags();
- EmptyIdentityEffectiveStatement(final IdentityStatement declared,
- final StmtContext<QName, IdentityStatement, IdentityEffectiveStatement> ctx) {
- super(declared, ctx);
+ EmptyIdentityEffectiveStatement(final IdentityStatement declared, final SchemaPath path) {
+ super(declared, path);
}
@Override
import com.google.common.collect.ImmutableSet;
import java.util.Collection;
import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.IdentitySchemaNode;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
-import org.opendaylight.yangtools.yang.model.api.stmt.IdentityEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.IdentityStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
final class RegularIdentityEffectiveStatement extends AbstractIdentityEffectiveStatement {
private final @NonNull Object baseIdentities;
private final @NonNull Object substatements;
private final int flags;
- RegularIdentityEffectiveStatement(final IdentityStatement declared,
- final StmtContext<QName, IdentityStatement, IdentityEffectiveStatement> ctx, final int flags,
+ RegularIdentityEffectiveStatement(final IdentityStatement declared, final SchemaPath path, final int flags,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
final ImmutableSet<? extends IdentitySchemaNode> baseIdentities) {
- super(declared, ctx);
+ super(declared, path);
this.flags = flags;
this.substatements = maskList(substatements);
this.baseIdentities = maskSet(baseIdentities);
import org.opendaylight.yangtools.yang.model.api.stmt.IfFeatureStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.FeatureNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
}
@Override
- protected IfFeatureEffectiveStatement createEffective(
- final StmtContext<IfFeatureExpr, IfFeatureStatement, IfFeatureEffectiveStatement> ctx,
- final IfFeatureStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularIfFeatureEffectiveStatement(declared, substatements);
+ protected IfFeatureEffectiveStatement createEffective(final Current<IfFeatureExpr, IfFeatureStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return substatements.isEmpty() ? new EmptyIfFeatureEffectiveStatement(stmt.declared())
+ : new RegularIfFeatureEffectiveStatement(stmt.declared(), substatements);
}
-
- @Override
- protected IfFeatureEffectiveStatement createEmptyEffective(
- final StmtContext<IfFeatureExpr, IfFeatureStatement, IfFeatureEffectiveStatement> ctx,
- final IfFeatureStatement declared) {
- return new EmptyIfFeatureEffectiveStatement(declared);
- }
-}
\ No newline at end of file
+}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.import_;
+import static com.google.common.base.Preconditions.checkState;
import static org.opendaylight.yangtools.yang.parser.spi.meta.ModelProcessingPhase.SOURCE_PRE_LINKAGE;
import static org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils.firstAttributeOf;
import org.opendaylight.yangtools.yang.model.repo.api.SemVerSourceIdentifier;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStringStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.PreLinkageModuleNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
}
@Override
- protected final ImportEffectiveStatement createEffective(
- final StmtContext<String, ImportStatement, ImportEffectiveStatement> ctx, final ImportStatement declared,
+ protected final ImportEffectiveStatement createEffective(final Current<String, ImportStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ checkState(!substatements.isEmpty(), "Unexpected empty effective import statement");
+ final ImportStatement declared = stmt.declared();
final String prefix = declared.getPrefix().getValue();
final SemVer semVer;
final Revision revision;
- if (!ctx.isEnabledSemanticVersioning()) {
+ final var rabbit = stmt.caerbannog();
+ if (!rabbit.isEnabledSemanticVersioning()) {
final Optional<Revision> optRev = substatements.stream()
.filter(RevisionDateEffectiveStatement.class::isInstance)
.findFirst()
- .map(stmt -> ((RevisionDateEffectiveStatement) stmt).argument());
- revision = optRev.isPresent() ? optRev.get() : getImportedRevision(ctx, declared.getModule(), prefix);
+ .map(subStmt -> ((RevisionDateEffectiveStatement) subStmt).argument());
+ revision = optRev.isPresent() ? optRev.get() : getImportedRevision(rabbit, declared.getModule(), prefix);
semVer = null;
} else {
- final SemVerSourceIdentifier importedModuleIdentifier = ctx.getFromNamespace(
- ImportPrefixToSemVerSourceIdentifier.class, prefix);
+ final SemVerSourceIdentifier importedModuleIdentifier = stmt.getFromNamespace(
+ ImportPrefixToSemVerSourceIdentifier.class, prefix);
revision = importedModuleIdentifier.getRevision().orElse(null);
semVer = importedModuleIdentifier.getSemanticVersion().orElse(null);
}
return new ImportEffectiveStatementImpl(declared, substatements, revision, semVer);
}
- @Override
- protected final ImportEffectiveStatement createEmptyEffective(
- final StmtContext<String, ImportStatement, ImportEffectiveStatement> ctx, final ImportStatement declared) {
- throw new IllegalStateException("Unexpected empty effective import statement");
- }
-
private static Revision getImportedRevision(final StmtContext<String, ImportStatement, ?> ctx,
final String moduleName, final String prefix) {
// When 'revision-date' of an import is not specified in yang source, we need to find revision of imported
import org.opendaylight.yangtools.yang.model.repo.api.RevisionSourceIdentifier;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStringStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.SubmoduleNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
}
@Override
- protected final IncludeEffectiveStatement createEffective(
- final StmtContext<String, IncludeStatement, IncludeEffectiveStatement> ctx,
- final IncludeStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularIncludeEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected final IncludeEffectiveStatement createEmptyEffective(
- final StmtContext<String, IncludeStatement, IncludeEffectiveStatement> ctx,
- final IncludeStatement declared) {
- return new EmptyIncludeEffectiveStatement(declared);
+ protected final IncludeEffectiveStatement createEffective(final Current<String, IncludeStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return substatements.isEmpty() ? new EmptyIncludeEffectiveStatement(stmt.declared())
+ : new RegularIncludeEffectiveStatement(stmt.declared(), substatements);
}
}
import org.opendaylight.yangtools.yang.model.api.stmt.InputEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseOperationContainerStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
abstract class AbstractInputStatementSupport
@Override
protected final InputEffectiveStatement createDeclaredEffective(final int flags,
- final StmtContext<QName, InputStatement, InputEffectiveStatement> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final InputStatement declared) {
- return new DeclaredInputEffectiveStatement(declared, flags, ctx, substatements);
+ final Current<QName, InputStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return new DeclaredInputEffectiveStatement(flags, stmt.declared(), substatements, stmt.sourceReference(),
+ stmt.getSchemaPath());
}
@Override
protected final InputEffectiveStatement createUndeclaredEffective(final int flags,
- final StmtContext<QName, InputStatement, InputEffectiveStatement> ctx,
+ final Current<QName, InputStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new UndeclaredInputEffectiveStatement(flags, ctx, substatements);
+ return new UndeclaredInputEffectiveStatement(flags, substatements, stmt.sourceReference(),
+ stmt.getSchemaPath());
}
}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.input;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.DefaultWithDataTree.WithSubstatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.OperationContainerMixin;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
final class DeclaredInputEffectiveStatement extends WithSubstatements<QName, InputStatement, InputEffectiveStatement>
implements InputEffectiveStatement, InputSchemaNode, OperationContainerMixin<InputStatement> {
private final @NonNull SchemaPath path;
private final int flags;
- DeclaredInputEffectiveStatement(final InputStatement declared, final int flags,
- final StmtContext<QName, InputStatement, InputEffectiveStatement> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- super(declared, ctx, substatements);
+ DeclaredInputEffectiveStatement(final int flags, final InputStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final StatementSourceReference ref,
+ final SchemaPath path) {
+ super(declared, substatements, ref);
this.flags = flags;
- this.path = ctx.getSchemaPath().get();
+ this.path = requireNonNull(path);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.input;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.stmt.InputStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractUndeclaredEffectiveStatement.DefaultWithDataTree.WithSubstatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.OperationContainerMixin;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
final class UndeclaredInputEffectiveStatement
extends WithSubstatements<QName, InputStatement, InputEffectiveStatement>
private final int flags;
UndeclaredInputEffectiveStatement(final int flags,
- final StmtContext<QName, InputStatement, InputEffectiveStatement> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- super(ctx, substatements);
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
+ final StatementSourceReference ref, final SchemaPath path) {
+ super(substatements, ref);
+ this.path = requireNonNull(path);
this.flags = flags;
- this.path = ctx.getSchemaPath().get();
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.KeyEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.KeyStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected KeyEffectiveStatement createEffective(
- final StmtContext<Set<QName>, KeyStatement, KeyEffectiveStatement> ctx, final KeyStatement declared,
+ protected KeyEffectiveStatement createEffective(final Current<Set<QName>, KeyStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- final Set<QName> arg = ctx.coerceStatementArgument();
+ final Set<QName> arg = stmt.coerceArgument();
+ final KeyStatement declared = stmt.declared();
+ if (substatements.isEmpty()) {
+ return arg.equals(declared.argument()) ? new EmptyLocalKeyEffectiveStatement(declared)
+ : new EmptyForeignKeyEffectiveStatement(declared, arg);
+ }
+
return arg.equals(declared.argument()) ? new RegularLocalKeyEffectiveStatement(declared, substatements)
: new RegularForeignKeyEffectiveStatement(declared, arg, substatements);
}
- @Override
- protected KeyEffectiveStatement createEmptyEffective(
- final StmtContext<Set<QName>, KeyStatement, KeyEffectiveStatement> ctx, final KeyStatement declared) {
- final Set<QName> arg = ctx.coerceStatementArgument();
- return arg.equals(declared.argument()) ? new EmptyLocalKeyEffectiveStatement(declared)
- : new EmptyForeignKeyEffectiveStatement(declared, arg);
- }
-
static @NonNull Object maskSet(final @NonNull Set<QName> set) {
return set.size() == 1 ? set.iterator().next() : set;
}
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseSchemaTreeStatementSupport;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStmtUtils;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
}
@Override
- protected LeafEffectiveStatement createEffective(
- final StmtContext<QName, LeafStatement, LeafEffectiveStatement> ctx, final LeafStatement declared,
+ protected LeafEffectiveStatement createEffective(final Current<QName, LeafStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
final TypeEffectiveStatement<?> typeStmt = SourceException.throwIfNull(
- findFirstStatement(substatements, TypeEffectiveStatement.class), ctx.getStatementSourceReference(),
+ findFirstStatement(substatements, TypeEffectiveStatement.class), stmt.sourceReference(),
"Leaf is missing a 'type' statement");
final String dflt = findFirstArgument(substatements, DefaultEffectiveStatement.class, null);
SourceException.throwIf(
- EffectiveStmtUtils.hasDefaultValueMarkedWithIfFeature(ctx.getRootVersion(), typeStmt, dflt),
- ctx.getStatementSourceReference(),
- "Leaf '%s' has default value '%s' marked with an if-feature statement.", ctx.getStatementArgument(), dflt);
+ EffectiveStmtUtils.hasDefaultValueMarkedWithIfFeature(stmt.yangVersion(), typeStmt, dflt),
+ stmt.sourceReference(),
+ "Leaf '%s' has default value '%s' marked with an if-feature statement.", stmt.argument(), dflt);
- final SchemaPath path = ctx.getSchemaPath().get();
- final LeafSchemaNode original = (LeafSchemaNode) ctx.getOriginalCtx().map(StmtContext::buildEffective)
- .orElse(null);
+ final SchemaPath path = stmt.getSchemaPath();
+ final LeafSchemaNode original = (LeafSchemaNode) stmt.original();
final int flags = new FlagsBuilder()
- .setHistory(ctx.getCopyHistory())
+ .setHistory(stmt.history())
.setStatus(findFirstArgument(substatements, StatusEffectiveStatement.class, Status.CURRENT))
- .setConfiguration(ctx.isConfiguration())
+ .setConfiguration(stmt.effectiveConfig())
.setMandatory(findFirstArgument(substatements, MandatoryEffectiveStatement.class, Boolean.FALSE))
.toFlags();
+ final LeafStatement declared = stmt.declared();
return original == null ? new EmptyLeafEffectiveStatement(declared, path, flags, substatements)
: new RegularLeafEffectiveStatement(declared, path, flags, substatements, original);
}
-
- @Override
- protected LeafEffectiveStatement createEmptyEffective(
- final StmtContext<QName, LeafStatement, LeafEffectiveStatement> ctx, final LeafStatement declared) {
- throw new UnsupportedOperationException("Leaf statements must have at least one substatement");
- }
}
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseSchemaTreeStatementSupport;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStmtUtils;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
}
@Override
- protected final LeafListEffectiveStatement createEffective(
- final StmtContext<QName, LeafListStatement, LeafListEffectiveStatement> ctx,
- final LeafListStatement declared,
+ protected LeafListEffectiveStatement createEffective(final Current<QName, LeafListStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
final TypeEffectiveStatement<?> typeStmt = SourceException.throwIfNull(
- findFirstStatement(substatements, TypeEffectiveStatement.class), ctx.getStatementSourceReference(),
+ findFirstStatement(substatements, TypeEffectiveStatement.class), stmt.sourceReference(),
"Leaf-list is missing a 'type' statement");
- final SchemaPath path = ctx.getSchemaPath().get();
- final LeafListSchemaNode original = (LeafListSchemaNode) ctx.getOriginalCtx()
- .map(StmtContext::buildEffective).orElse(null);
+ final SchemaPath path = stmt.getSchemaPath();
+ final LeafListSchemaNode original = (LeafListSchemaNode) stmt.original();
final int flags = new FlagsBuilder()
- .setHistory(ctx.getCopyHistory())
+ .setHistory(stmt.history())
.setStatus(findFirstArgument(substatements, StatusEffectiveStatement.class, Status.CURRENT))
- .setConfiguration(ctx.isConfiguration())
+ .setConfiguration(stmt.effectiveConfig())
.setUserOrdered(findFirstArgument(substatements, OrderedByEffectiveStatement.class, Ordering.SYSTEM)
.equals(Ordering.USER))
.toFlags();
// FIXME: We need to interpret the default value in terms of supplied element type
SourceException.throwIf(
- EffectiveStmtUtils.hasDefaultValueMarkedWithIfFeature(ctx.getRootVersion(), typeStmt, defaultValues),
- ctx.getStatementSourceReference(),
- "Leaf-list '%s' has one of its default values '%s' marked with an if-feature statement.",
- ctx.getStatementArgument(), defaultValues);
+ EffectiveStmtUtils.hasDefaultValueMarkedWithIfFeature(stmt.yangVersion(), typeStmt, defaultValues),
+ stmt.sourceReference(),
+ "Leaf-list '%s' has one of its default values '%s' marked with an if-feature statement.",
+ stmt.argument(), defaultValues);
// FIXME: RFC7950 section 7.7.4: we need to check for min-elements and defaultValues conflict
final Optional<ElementCountConstraint> elementCountConstraint =
EffectiveStmtUtils.createElementCountConstraint(substatements);
+ final LeafListStatement declared = stmt.declared();
if (defaultValues.isEmpty()) {
return original == null && !elementCountConstraint.isPresent()
- ? new EmptyLeafListEffectiveStatement(declared, path, flags, substatements)
- : new SlimLeafListEffectiveStatement(declared, path, flags, substatements, original,
- elementCountConstraint.orElse(null));
+ ? new EmptyLeafListEffectiveStatement(declared, path, flags, substatements)
+ : new SlimLeafListEffectiveStatement(declared, path, flags, substatements, original,
+ elementCountConstraint.orElse(null));
}
return new RegularLeafListEffectiveStatement(declared, path, flags, substatements, original, defaultValues,
elementCountConstraint.orElse(null));
}
-
- @Override
- protected final LeafListEffectiveStatement createEmptyEffective(
- final StmtContext<QName, LeafListStatement, LeafListEffectiveStatement> ctx,
- final LeafListStatement declared) {
- throw new UnsupportedOperationException("Leaf statements must have at least one substatement");
- }
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.stmt.ValueRange;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ArgumentUtils;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected LengthEffectiveStatement createEffective(
- final StmtContext<List<ValueRange>, LengthStatement, LengthEffectiveStatement> ctx,
- final LengthStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularLengthEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected LengthEffectiveStatement createEmptyEffective(
- final StmtContext<List<ValueRange>, LengthStatement, LengthEffectiveStatement> ctx,
- final LengthStatement declared) {
- return new EmptyLengthEffectiveStatement(declared);
+ protected LengthEffectiveStatement createEffective(final Current<List<ValueRange>, LengthStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return substatements.isEmpty() ? new EmptyLengthEffectiveStatement(stmt.declared())
+ : new RegularLengthEffectiveStatement(stmt.declared(), substatements);
}
private static Number parseIntegerConstraintValue(final StmtContext<?, ?, ?> ctx, final String value) {
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.UserOrderedMixin;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.WhenConditionMixin;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStmtUtils;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
abstract class AbstractListEffectiveStatement
extends DefaultWithDataTree<QName, ListStatement, ListEffectiveStatement>
private final @NonNull SchemaPath path;
private final @NonNull Object keyDefinition;
- AbstractListEffectiveStatement(final ListStatement declared, final SchemaPath path, final int flags,
- final StmtContext<?, ?, ?> ctx, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
+ AbstractListEffectiveStatement(final Current<QName, ListStatement> stmt, final SchemaPath path,
+ final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
final ImmutableList<QName> keyDefinition) {
- super(declared, ctx, substatements);
+ super(stmt.declared(), substatements, stmt.sourceReference());
- EffectiveStmtUtils.checkUniqueGroupings(ctx, substatements);
- EffectiveStmtUtils.checkUniqueTypedefs(ctx, substatements);
- EffectiveStmtUtils.checkUniqueUses(ctx, substatements);
+ final var rabbit = stmt.caerbannog();
+ EffectiveStmtUtils.checkUniqueGroupings(rabbit, substatements, stmt.sourceReference());
+ EffectiveStmtUtils.checkUniqueTypedefs(rabbit, substatements, stmt.sourceReference());
+ EffectiveStmtUtils.checkUniqueUses(rabbit, substatements, stmt.sourceReference());
this.substatements = maskList(substatements);
this.path = requireNonNull(path);
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseSchemaTreeStatementSupport;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStmtUtils;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Parent;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
}
@Override
- protected final ListEffectiveStatement createEffective(
- final StmtContext<QName, ListStatement, ListEffectiveStatement> ctx,
- final ListStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- final SchemaPath path = ctx.getSchemaPath().get();
- final ListSchemaNode original = (ListSchemaNode) ctx.getOriginalCtx().map(StmtContext::buildEffective)
- .orElse(null);
+ protected ListEffectiveStatement createEffective(final Current<QName, ListStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ final SchemaPath path = stmt.getSchemaPath();
+ final ListSchemaNode original = (ListSchemaNode) stmt.original();
final ImmutableList<QName> keyDefinition;
final KeyEffectiveStatement keyStmt = findFirstStatement(substatements, KeyEffectiveStatement.class);
}
for (final QName keyQName : keyStmt.argument()) {
if (!possibleLeafQNamesForKey.contains(keyQName)) {
- throw new InferenceException(ctx.getStatementSourceReference(),
+ throw new InferenceException(stmt.sourceReference(),
"Key '%s' misses node '%s' in list '%s'", keyStmt.getDeclared().rawArgument(),
- keyQName.getLocalName(), ctx.getStatementArgument());
+ keyQName.getLocalName(), stmt.argument());
}
keyDefinitionInit.add(keyQName);
}
keyDefinition = ImmutableList.of();
}
- final boolean configuration = ctx.isConfiguration();
+ final boolean configuration = stmt.effectiveConfig();
final int flags = new FlagsBuilder()
- .setHistory(ctx.getCopyHistory())
+ .setHistory(stmt.history())
.setStatus(findFirstArgument(substatements, StatusEffectiveStatement.class, Status.CURRENT))
.setConfiguration(configuration)
.setUserOrdered(findFirstArgument(substatements, OrderedByEffectiveStatement.class, Ordering.SYSTEM)
.equals(Ordering.USER))
.toFlags();
- if (configuration && keyDefinition.isEmpty() && isInstantied(ctx)) {
- warnConfigList(ctx);
+ if (configuration && keyDefinition.isEmpty() && isInstantied(stmt)) {
+ warnConfigList(stmt);
}
final Optional<ElementCountConstraint> elementCountConstraint =
EffectiveStmtUtils.createElementCountConstraint(substatements);
return original == null && !elementCountConstraint.isPresent()
- ? new EmptyListEffectiveStatement(declared, path, flags, ctx, substatements, keyDefinition)
- : new RegularListEffectiveStatement(declared, path, flags, ctx, substatements, keyDefinition,
- elementCountConstraint.orElse(null), original);
+ ? new EmptyListEffectiveStatement(stmt, path, flags, substatements, keyDefinition)
+ : new RegularListEffectiveStatement(stmt, path, flags, substatements, keyDefinition,
+ elementCountConstraint.orElse(null), original);
}
- private static void warnConfigList(final @NonNull StmtContext<QName, ListStatement, ListEffectiveStatement> ctx) {
+ private static void warnConfigList(final @NonNull Current<QName, ListStatement> stmt) {
+ final StmtContext<QName, ListStatement, ListEffectiveStatement> ctx = stmt.caerbannog();
final StmtContext<QName, ListStatement, ListEffectiveStatement> warnCtx = ctx.getOriginalCtx().orElse(ctx);
final Boolean warned = warnCtx.getFromNamespace(ConfigListWarningNamespace.class, Boolean.TRUE);
// Hacky check if we have issued a warning for the original statement
}
}
- private static boolean isInstantied(final StmtContext<?, ?, ?> ctx) {
- StmtContext<?, ?, ?> parent = ctx.getParentContext();
+ private static boolean isInstantied(final EffectiveStmtCtx ctx) {
+ Parent parent = ctx.parent();
while (parent != null) {
- final StatementDefinition parentDef = parent.getPublicDefinition();
+ final StatementDefinition parentDef = parent.publicDefinition();
if (UNINSTANTIATED_DATATREE_STATEMENTS.contains(parentDef)) {
return false;
}
- final StmtContext<?, ?, ?> grandParent = parent.getParentContext();
+ final Parent grandParent = parent.parent();
if (YangStmtMapping.AUGMENT == parentDef && grandParent != null) {
// If this is an augment statement and its parent is either a 'module' or 'submodule' statement, we are
// dealing with an uninstantiated context.
- final StatementDefinition grandParentDef = grandParent.getPublicDefinition();
+ final StatementDefinition grandParentDef = grandParent.publicDefinition();
if (YangStmtMapping.MODULE == grandParentDef || YangStmtMapping.SUBMODULE == grandParentDef) {
return false;
}
}
return true;
}
-
- @Override
- protected final ListEffectiveStatement createEmptyEffective(
- final StmtContext<QName, ListStatement, ListEffectiveStatement> ctx, final ListStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
- }
}
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ListStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
final class EmptyListEffectiveStatement extends AbstractListEffectiveStatement {
- EmptyListEffectiveStatement(final ListStatement declared, final SchemaPath path, final int flags,
- final StmtContext<?, ?, ?> ctx, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
+ EmptyListEffectiveStatement(final Current<QName, ListStatement> stmt, final SchemaPath path,
+ final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
final ImmutableList<QName> keyDefinition) {
- super(declared, path, flags, ctx, substatements, keyDefinition);
+ super(stmt, path, flags, substatements, keyDefinition);
}
@Override
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ListStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
final class RegularListEffectiveStatement extends AbstractListEffectiveStatement {
private final ElementCountConstraint elementCountConstraint;
private final ListSchemaNode original;
- RegularListEffectiveStatement(final ListStatement declared, final SchemaPath path, final int flags,
- final StmtContext<?, ?, ?> ctx, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
+ RegularListEffectiveStatement(final Current<QName, ListStatement> stmt, final SchemaPath path,
+ final int flags, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
final ImmutableList<QName> keyDefinition, final ElementCountConstraint elementCountConstraint,
final ListSchemaNode original) {
- super(declared, path, flags, ctx, substatements, keyDefinition);
+ super(stmt, path, flags, substatements, keyDefinition);
this.elementCountConstraint = elementCountConstraint;
this.original = original;
}
}
@Override
- protected MandatoryEffectiveStatement createEffective(
- final StmtContext<Boolean, MandatoryStatement, MandatoryEffectiveStatement> ctx,
- final MandatoryStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ protected MandatoryEffectiveStatement createEffective(final MandatoryStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return new RegularMandatoryEffectiveStatement(declared, substatements);
}
import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.MaxElementsStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStringStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected MaxElementsEffectiveStatement createEffective(
- final StmtContext<String, MaxElementsStatement, MaxElementsEffectiveStatement> ctx,
- final MaxElementsStatement declared,
+ protected MaxElementsEffectiveStatement createEffective(final Current<String, MaxElementsStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularMaxElementsEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected MaxElementsEffectiveStatement createEmptyEffective(
- final StmtContext<String, MaxElementsStatement, MaxElementsEffectiveStatement> ctx,
- final MaxElementsStatement declared) {
- return new EmptyMaxElementsEffectiveStatement(declared);
+ return substatements.isEmpty() ? new EmptyMaxElementsEffectiveStatement(stmt.declared())
+ : new RegularMaxElementsEffectiveStatement(stmt.declared(), substatements);
}
}
}
@Override
- protected MinElementsEffectiveStatement createEffective(
- final StmtContext<Integer, MinElementsStatement, MinElementsEffectiveStatement> ctx,
- final MinElementsStatement declared,
+ protected MinElementsEffectiveStatement createEffective(final MinElementsStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return new RegularMinElementsEffectiveStatement(declared, substatements);
}
import org.opendaylight.yangtools.yang.model.api.stmt.ModifierStatement;
import org.opendaylight.yangtools.yang.model.api.type.ModifierKind;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
}
@Override
- protected ModifierEffectiveStatement createEffective(
- final StmtContext<ModifierKind, ModifierStatement, ModifierEffectiveStatement> ctx,
- final ModifierStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularModifierEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected ModifierEffectiveStatement createEmptyEffective(
- final StmtContext<ModifierKind, ModifierStatement, ModifierEffectiveStatement> ctx,
- final ModifierStatement declared) {
- return new EmptyModifierEffectiveStatement(declared);
+ protected ModifierEffectiveStatement createEffective(final Current<ModifierKind, ModifierStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return substatements.isEmpty() ? new EmptyModifierEffectiveStatement(stmt.declared())
+ : new RegularModifierEffectiveStatement(stmt.declared(), substatements);
}
}
import java.util.List;
import java.util.Map;
import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.common.Revision;
import org.opendaylight.yangtools.yang.common.UnqualifiedQName;
import org.opendaylight.yangtools.yang.parser.spi.ModuleNamespace;
import org.opendaylight.yangtools.yang.parser.spi.NamespaceToModule;
import org.opendaylight.yangtools.yang.parser.spi.PreLinkageModuleNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.SemanticVersionModuleNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.SemanticVersionNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.ModuleQNameToModuleName;
import org.opendaylight.yangtools.yang.parser.spi.source.PrefixToModule;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
abstract class AbstractModuleStatementSupport
extends BaseStatementSupport<UnqualifiedQName, ModuleStatement, ModuleEffectiveStatement> {
@Override
protected final ImmutableList<? extends EffectiveStatement<?, ?>> buildEffectiveSubstatements(
- final StmtContext<UnqualifiedQName, ModuleStatement, ModuleEffectiveStatement> ctx,
+ final Current<UnqualifiedQName, ModuleStatement> stmt,
final List<? extends StmtContext<?, ?, ?>> substatements) {
final ImmutableList<? extends EffectiveStatement<?, ?>> local =
- super.buildEffectiveSubstatements(ctx, substatements);
- final Collection<StmtContext<?, ?, ?>> submodules = submoduleContexts(ctx);
+ super.buildEffectiveSubstatements(stmt, substatements);
+ final Collection<StmtContext<?, ?, ?>> submodules = submoduleContexts(stmt);
if (submodules.isEmpty()) {
return local;
}
@Override
protected final ModuleStatement createEmptyDeclared(final StmtContext<UnqualifiedQName, ModuleStatement, ?> ctx) {
- throw noNamespace(ctx);
+ throw noNamespace(ctx.getStatementSourceReference());
}
@Override
- protected final ModuleEffectiveStatement createEffective(
- final StmtContext<UnqualifiedQName, ModuleStatement, ModuleEffectiveStatement> ctx,
- final ModuleStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ protected final ModuleEffectiveStatement createEffective(final Current<UnqualifiedQName, ModuleStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ if (substatements.isEmpty()) {
+ throw noNamespace(stmt.sourceReference());
+ }
+
final List<Submodule> submodules = new ArrayList<>();
- for (StmtContext<?, ?, ?> submoduleCtx : submoduleContexts(ctx)) {
+ for (StmtContext<?, ?, ?> submoduleCtx : submoduleContexts(stmt)) {
final EffectiveStatement<?, ?> submodule = submoduleCtx.buildEffective();
verify(submodule instanceof Submodule, "Submodule statement %s is not a Submodule", submodule);
submodules.add((Submodule) submodule);
}
- return new ModuleEffectiveStatementImpl(ctx, declared, substatements, submodules);
- }
-
- @Override
- protected final ModuleEffectiveStatement createEmptyEffective(
- final StmtContext<UnqualifiedQName, ModuleStatement, ModuleEffectiveStatement> ctx,
- final ModuleStatement declared) {
- throw noNamespace(ctx);
+ return new ModuleEffectiveStatementImpl(stmt, substatements, submodules);
}
- private static Collection<StmtContext<?, ?, ?>> submoduleContexts(final StmtContext<?, ?, ?> ctx) {
- final Map<String, StmtContext<?, ?, ?>> submodules = ctx.getAllFromCurrentStmtCtxNamespace(
+ private static Collection<StmtContext<?, ?, ?>> submoduleContexts(final Current<?, ?> stmt) {
+ final Map<String, StmtContext<?, ?, ?>> submodules = stmt.getAllFromCurrentStmtCtxNamespace(
IncludedSubmoduleNameToModuleCtx.class);
return submodules == null ? List.of() : submodules.values();
}
- private static SourceException noNamespace(final StmtContext<?, ?, ?> ctx) {
- return new SourceException("No namespace declared in module", ctx.getStatementSourceReference());
+ private static SourceException noNamespace(final @NonNull StatementSourceReference ref) {
+ return new SourceException("No namespace declared in module", ref);
}
private static void addToSemVerModuleNamespace(
import org.opendaylight.yangtools.yang.parser.spi.ExtensionNamespace;
import org.opendaylight.yangtools.yang.parser.spi.FeatureNamespace;
import org.opendaylight.yangtools.yang.parser.spi.IdentityNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.IncludedSubmoduleNameToModuleCtx;
import org.opendaylight.yangtools.yang.parser.spi.source.ModuleCtxToModuleQName;
private final @NonNull QNameModule qnameModule;
private final ImmutableList<Submodule> submodules;
- ModuleEffectiveStatementImpl(final StmtContext<UnqualifiedQName, ModuleStatement, ModuleEffectiveStatement> ctx,
- final ModuleStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
+ ModuleEffectiveStatementImpl(final Current<UnqualifiedQName, ModuleStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
final Collection<? extends Submodule> submodules) {
- super(declared, ctx, substatements, findPrefix(ctx, "module", ctx.coerceRawStatementArgument()));
+ super(stmt, substatements, findPrefix(stmt.caerbannog(), "module",
+ stmt.caerbannog().coerceRawStatementArgument()));
- qnameModule = verifyNotNull(ctx.getFromNamespace(ModuleCtxToModuleQName.class, ctx));
+ qnameModule = verifyNotNull(stmt.getFromNamespace(ModuleCtxToModuleQName.class, stmt.caerbannog()));
this.submodules = ImmutableList.copyOf(submodules);
final String localPrefix = findFirstEffectiveSubstatementArgument(PrefixEffectiveStatement.class).get();
final Builder<String, ModuleEffectiveStatement> prefixToModuleBuilder = ImmutableMap.builder();
prefixToModuleBuilder.put(localPrefix, this);
- appendPrefixes(ctx, prefixToModuleBuilder);
+ appendPrefixes(stmt, prefixToModuleBuilder);
prefixToModule = prefixToModuleBuilder.build();
final Map<QNameModule, String> tmp = Maps.newLinkedHashMapWithExpectedSize(prefixToModule.size() + 1);
namespaceToPrefix = ImmutableMap.copyOf(tmp);
final Map<String, StmtContext<?, ?, ?>> includedSubmodules =
- ctx.getAllFromCurrentStmtCtxNamespace(IncludedSubmoduleNameToModuleCtx.class);
+ stmt.getAllFromCurrentStmtCtxNamespace(IncludedSubmoduleNameToModuleCtx.class);
nameToSubmodule = includedSubmodules == null ? ImmutableMap.of()
: ImmutableMap.copyOf(Maps.transformValues(includedSubmodules,
submodule -> (SubmoduleEffectiveStatement) submodule.buildEffective()));
final Map<QName, StmtContext<?, ExtensionStatement, ExtensionEffectiveStatement>> extensions =
- ctx.getAllFromCurrentStmtCtxNamespace(ExtensionNamespace.class);
+ stmt.getAllFromCurrentStmtCtxNamespace(ExtensionNamespace.class);
qnameToExtension = extensions == null ? ImmutableMap.of()
: ImmutableMap.copyOf(Maps.transformValues(extensions, StmtContext::buildEffective));
final Map<QName, StmtContext<?, FeatureStatement, FeatureEffectiveStatement>> features =
- ctx.getAllFromCurrentStmtCtxNamespace(FeatureNamespace.class);
+ stmt.getAllFromCurrentStmtCtxNamespace(FeatureNamespace.class);
qnameToFeature = features == null ? ImmutableMap.of()
: ImmutableMap.copyOf(Maps.transformValues(features, StmtContext::buildEffective));
final Map<QName, StmtContext<?, IdentityStatement, IdentityEffectiveStatement>> identities =
- ctx.getAllFromCurrentStmtCtxNamespace(IdentityNamespace.class);
+ stmt.getAllFromCurrentStmtCtxNamespace(IdentityNamespace.class);
qnameToIdentity = identities == null ? ImmutableMap.of()
: ImmutableMap.copyOf(Maps.transformValues(identities, StmtContext::buildEffective));
}
import org.opendaylight.yangtools.yang.model.api.stmt.MustStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.XPathSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.xpath.api.YangXPathExpression.QualifiedBound;
}
@Override
- protected MustEffectiveStatement createEffective(
- final StmtContext<QualifiedBound, MustStatement, MustEffectiveStatement> ctx,
- final MustStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularMustEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected MustEffectiveStatement createEmptyEffective(
- final StmtContext<QualifiedBound, MustStatement, MustEffectiveStatement> ctx,
- final MustStatement declared) {
- return new EmptyMustEffectiveStatement(declared);
+ protected MustEffectiveStatement createEffective(final Current<QualifiedBound, MustStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return substatements.isEmpty() ? new EmptyMustEffectiveStatement(stmt.declared())
+ : new RegularMustEffectiveStatement(stmt.declared(), substatements);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NamespaceStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
}
@Override
- protected NamespaceEffectiveStatement createEffective(
- final StmtContext<URI, NamespaceStatement, NamespaceEffectiveStatement> ctx,
- final NamespaceStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularNamespaceEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected NamespaceEffectiveStatement createEmptyEffective(
- final StmtContext<URI, NamespaceStatement, NamespaceEffectiveStatement> ctx,
- final NamespaceStatement declared) {
- return new EmptyNamespaceEffectiveStatement(declared);
+ protected NamespaceEffectiveStatement createEffective(final Current<URI, NamespaceStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return substatements.isEmpty() ? new EmptyNamespaceEffectiveStatement(stmt.declared())
+ : new RegularNamespaceEffectiveStatement(stmt.declared(), substatements);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.stmt.NotificationEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NotificationStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseSchemaTreeStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
abstract class AbstractNotificationStatementSupport
}
@Override
- protected final NotificationEffectiveStatement createEffective(
- final StmtContext<QName, NotificationStatement, NotificationEffectiveStatement> ctx,
- final NotificationStatement declared,
+ protected final NotificationEffectiveStatement createEffective(final Current<QName, NotificationStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- checkEffective(ctx);
+ checkEffective(stmt);
- return new NotificationEffectiveStatementImpl(declared, historyAndStatusFlags(ctx, substatements), ctx,
- substatements);
+ return new NotificationEffectiveStatementImpl(stmt.declared(), substatements, stmt.sourceReference(),
+ historyAndStatusFlags(stmt.history(), substatements), stmt.getSchemaPath());
}
- @Override
- protected final NotificationEffectiveStatement createEmptyEffective(
- final StmtContext<QName, NotificationStatement, NotificationEffectiveStatement> ctx,
- final NotificationStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
- }
-
- abstract void checkEffective(StmtContext<QName, NotificationStatement, NotificationEffectiveStatement> ctx);
+ abstract void checkEffective(Current<QName, NotificationStatement> stmt);
}
\ No newline at end of file
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.notification;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.DataNodeContainerMixin;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.MustConstraintMixin;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.SchemaNodeMixin;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
final class NotificationEffectiveStatementImpl
extends WithSubstatements<QName, NotificationStatement, NotificationEffectiveStatement>
private final @NonNull SchemaPath path;
private final int flags;
- NotificationEffectiveStatementImpl(final NotificationStatement declared, final int flags,
- final StmtContext<QName, NotificationStatement, NotificationEffectiveStatement> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- super(declared, ctx, substatements);
- this.path = ctx.getSchemaPath().get();
+ NotificationEffectiveStatementImpl(final NotificationStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final StatementSourceReference ref,
+ final int flags, final SchemaPath path) {
+ super(declared, substatements, ref);
+ this.path = requireNonNull(path);
this.flags = flags;
}
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
-import org.opendaylight.yangtools.yang.model.api.stmt.NotificationEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NotificationStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
public final class NotificationStatementRFC6020Support extends AbstractNotificationStatementSupport {
}
@Override
- void checkEffective(final StmtContext<QName, NotificationStatement, NotificationEffectiveStatement> ctx) {
+ void checkEffective(final Current<QName, NotificationStatement> stmt) {
// No-op
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
-import org.opendaylight.yangtools.yang.model.api.stmt.NotificationEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.NotificationStatement;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
@Override
- void checkEffective(final StmtContext<QName, NotificationStatement, NotificationEffectiveStatement> ctx) {
- final StatementSourceReference ref = ctx.getStatementSourceReference();
- final QName argument = ctx.getStatementArgument();
- SourceException.throwIf(StmtContextUtils.hasAncestorOfType(ctx, ILLEGAL_PARENTS), ref,
+ void checkEffective(final Current<QName, NotificationStatement> stmt) {
+ final QName argument = stmt.argument();
+ final StatementSourceReference ref = stmt.sourceReference();
+ final var rabbit = stmt.caerbannog();
+ SourceException.throwIf(StmtContextUtils.hasAncestorOfType(rabbit, ILLEGAL_PARENTS), ref,
"Notification %s is defined within an rpc, action, or another notification", argument);
SourceException.throwIf(
- !StmtContextUtils.hasAncestorOfTypeWithChildOfType(ctx, YangStmtMapping.LIST, YangStmtMapping.KEY), ref,
+ !StmtContextUtils.hasAncestorOfTypeWithChildOfType(rabbit, YangStmtMapping.LIST, YangStmtMapping.KEY), ref,
"Notification %s is defined within a list that has no key statement", argument);
- SourceException.throwIf(StmtContextUtils.hasParentOfType(ctx, YangStmtMapping.CASE), ref,
+ SourceException.throwIf(StmtContextUtils.hasParentOfType(rabbit, YangStmtMapping.CASE), ref,
"Notification %s is defined within a case statement", argument);
}
}
import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.OrderedByStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
}
@Override
- protected OrderedByEffectiveStatement createEffective(
- final StmtContext<Ordering, OrderedByStatement, OrderedByEffectiveStatement> ctx,
- final OrderedByStatement declared,
+ protected OrderedByEffectiveStatement createEffective(final Current<Ordering, OrderedByStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularOrderedByEffectiveStatement(declared, substatements);
+ return substatements.isEmpty() ? createEmptyEffective(stmt.declared())
+ : new RegularOrderedByEffectiveStatement(stmt.declared(), substatements);
}
- @Override
- protected OrderedByEffectiveStatement createEmptyEffective(
- final StmtContext<Ordering, OrderedByStatement, OrderedByEffectiveStatement> ctx,
- final OrderedByStatement declared) {
+ private static @NonNull OrderedByEffectiveStatement createEmptyEffective(final OrderedByStatement declared) {
// Aggressively reuse effective instances which are backed by the corresponding empty declared instance, as this
// is the case unless there is a weird extension in use.
if (EMPTY_USER_DECL.equals(declared)) {
import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.OrganizationStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStringStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected OrganizationEffectiveStatement createEffective(
- final StmtContext<String, OrganizationStatement, OrganizationEffectiveStatement> ctx,
- final OrganizationStatement declared,
+ protected OrganizationEffectiveStatement createEffective(final Current<String, OrganizationStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularOrganizationEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected OrganizationEffectiveStatement createEmptyEffective(
- final StmtContext<String, OrganizationStatement, OrganizationEffectiveStatement> ctx,
- final OrganizationStatement declared) {
- return new EmptyOrganizationEffectiveStatement(declared);
+ return substatements.isEmpty() ? new EmptyOrganizationEffectiveStatement(stmt.declared())
+ : new RegularOrganizationEffectiveStatement(stmt.declared(), substatements);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.stmt.OutputEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseOperationContainerStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
abstract class AbstractOutputStatementSupport
@Override
protected final OutputEffectiveStatement createDeclaredEffective(final int flags,
- final StmtContext<QName, OutputStatement, OutputEffectiveStatement> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final OutputStatement declared) {
- return new DeclaredOutputEffectiveStatement(declared, flags, ctx, substatements);
+ final Current<QName, OutputStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return new DeclaredOutputEffectiveStatement(flags, stmt.declared(), substatements, stmt.sourceReference(),
+ stmt.getSchemaPath());
}
@Override
protected final OutputEffectiveStatement createUndeclaredEffective(final int flags,
- final StmtContext<QName, OutputStatement, OutputEffectiveStatement> ctx,
+ final Current<QName, OutputStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new UndeclaredOutputEffectiveStatement(flags, ctx, substatements);
+ return new UndeclaredOutputEffectiveStatement(flags, substatements, stmt.sourceReference(),
+ stmt.getSchemaPath());
}
}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.output;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.DefaultWithDataTree.WithSubstatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.OperationContainerMixin;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
final class DeclaredOutputEffectiveStatement extends WithSubstatements<QName, OutputStatement, OutputEffectiveStatement>
implements OutputEffectiveStatement, OutputSchemaNode, OperationContainerMixin<OutputStatement> {
private final @NonNull SchemaPath path;
private final int flags;
- DeclaredOutputEffectiveStatement(final OutputStatement declared, final int flags,
- final StmtContext<QName, OutputStatement, OutputEffectiveStatement> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- super(declared, ctx, substatements);
+ DeclaredOutputEffectiveStatement(final int flags, final OutputStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final StatementSourceReference ref,
+ final SchemaPath path) {
+ super(declared, substatements, ref);
this.flags = flags;
- this.path = ctx.getSchemaPath().get();
+ this.path = requireNonNull(path);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.output;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.collect.ImmutableList;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.stmt.OutputStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractUndeclaredEffectiveStatement.DefaultWithDataTree.WithSubstatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.OperationContainerMixin;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
final class UndeclaredOutputEffectiveStatement
extends WithSubstatements<QName, OutputStatement, OutputEffectiveStatement>
private final int flags;
UndeclaredOutputEffectiveStatement(final int flags,
- final StmtContext<QName, OutputStatement, OutputEffectiveStatement> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- super(ctx, substatements);
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
+ final StatementSourceReference ref, final SchemaPath path) {
+ super(substatements, ref);
+ this.path = requireNonNull(path);
this.flags = flags;
- this.path = ctx.getSchemaPath().get();
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.PathEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PathStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected PathEffectiveStatement createEffective(
- final StmtContext<PathExpression, PathStatement, PathEffectiveStatement> ctx,
- final PathStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularPathEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected PathEffectiveStatement createEmptyEffective(
- final StmtContext<PathExpression, PathStatement, PathEffectiveStatement> ctx,
- final PathStatement declared) {
- return new EmptyPathEffectiveStatement(declared);
+ protected PathEffectiveStatement createEffective(final Current<PathExpression, PathStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return substatements.isEmpty() ? new EmptyPathEffectiveStatement(stmt.declared())
+ : new RegularPathEffectiveStatement(stmt.declared(), substatements);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.stmt.PatternStatement;
import org.opendaylight.yangtools.yang.model.util.RegexUtils;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
}
@Override
- protected final PatternEffectiveStatement createEffective(
- final StmtContext<PatternExpression, PatternStatement, PatternEffectiveStatement> ctx,
- final PatternStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularPatternEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected final PatternEffectiveStatement createEmptyEffective(
- final StmtContext<PatternExpression, PatternStatement, PatternEffectiveStatement> ctx,
- final PatternStatement declared) {
- return new EmptyPatternEffectiveStatement(declared);
+ protected final PatternEffectiveStatement createEffective(final Current<PatternExpression, PatternStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return substatements.isEmpty() ? new EmptyPatternEffectiveStatement(stmt.declared())
+ : new RegularPatternEffectiveStatement(stmt.declared(), substatements);
}
}
}
@Override
- protected PositionEffectiveStatement createEmptyEffective(final PositionStatement declared) {
- return new EmptyPositionEffectiveStatement(declared);
+ protected PositionEffectiveStatement createEffective(final PositionStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return new RegularPositionEffectiveStatement(declared, substatements);
}
@Override
- protected PositionEffectiveStatement createEffective(
- final StmtContext<Uint32, PositionStatement, PositionEffectiveStatement> ctx,
- final PositionStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularPositionEffectiveStatement(declared, substatements);
+ protected PositionEffectiveStatement createEmptyEffective(final PositionStatement declared) {
+ return new EmptyPositionEffectiveStatement(declared);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.stmt.PrefixEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PrefixStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStringStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected PrefixEffectiveStatement createEffective(
- final StmtContext<String, PrefixStatement, PrefixEffectiveStatement> ctx, final PrefixStatement declared,
+ protected PrefixEffectiveStatement createEffective(final Current<String, PrefixStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularPrefixEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected PrefixEffectiveStatement createEmptyEffective(
- final StmtContext<String, PrefixStatement, PrefixEffectiveStatement> ctx, final PrefixStatement declared) {
- return new EmptyPrefixEffectiveStatement(declared);
+ return substatements.isEmpty() ? new EmptyPrefixEffectiveStatement(stmt.declared())
+ : new RegularPrefixEffectiveStatement(stmt.declared(), substatements);
}
}
import org.opendaylight.yangtools.yang.model.api.stmt.PresenceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.PresenceStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStringStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected PresenceEffectiveStatement createEffective(
- final StmtContext<String, PresenceStatement, PresenceEffectiveStatement> ctx,
- final PresenceStatement declared,
+ protected PresenceEffectiveStatement createEffective(final Current<String, PresenceStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularPresenceEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected PresenceEffectiveStatement createEmptyEffective(
- final StmtContext<String, PresenceStatement, PresenceEffectiveStatement> ctx,
- final PresenceStatement declared) {
- return new EmptyPresenceEffectiveStatement(declared);
+ return substatements.isEmpty() ? new EmptyPresenceEffectiveStatement(stmt.declared())
+ : new RegularPresenceEffectiveStatement(stmt.declared(), substatements);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.stmt.ValueRange;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ArgumentUtils;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected RangeEffectiveStatement createEffective(
- final StmtContext<List<ValueRange>, RangeStatement, RangeEffectiveStatement> ctx,
- final RangeStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularRangeEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected RangeEffectiveStatement createEmptyEffective(
- final StmtContext<List<ValueRange>, RangeStatement, RangeEffectiveStatement> ctx,
- final RangeStatement declared) {
- return new EmptyRangeEffectiveStatement(declared);
+ protected RangeEffectiveStatement createEffective(final Current<List<ValueRange>, RangeStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return substatements.isEmpty() ? new EmptyRangeEffectiveStatement(stmt.declared())
+ : new RegularRangeEffectiveStatement(stmt.declared(), substatements);
}
@Override
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.ReferenceStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStringStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected ReferenceEffectiveStatement createEffective(
- final StmtContext<String, ReferenceStatement, ReferenceEffectiveStatement> ctx,
- final ReferenceStatement declared,
+ protected ReferenceEffectiveStatement createEffective(final Current<String, ReferenceStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularReferenceEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected ReferenceEffectiveStatement createEmptyEffective(
- final StmtContext<String, ReferenceStatement, ReferenceEffectiveStatement> ctx,
- final ReferenceStatement declared) {
- return new EmptyReferenceEffectiveStatement(declared);
+ return substatements.isEmpty() ? new EmptyReferenceEffectiveStatement(stmt.declared())
+ : new RegularReferenceEffectiveStatement(stmt.declared(), substatements);
}
}
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier.Descendant;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ArgumentUtils;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
abstract class AbstractRefineStatementSupport
}
@Override
- protected final RefineEffectiveStatement createEffective(
- final StmtContext<Descendant, RefineStatement, RefineEffectiveStatement> ctx,
- final RefineStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RefineEffectiveStatementImpl(declared, substatements, ctx.getSchemaPath().get(),
- (SchemaNode) ctx.getEffectOfStatement().iterator().next().buildEffective());
- }
-
- @Override
- protected final RefineEffectiveStatement createEmptyEffective(
- final StmtContext<Descendant, RefineStatement, RefineEffectiveStatement> ctx,
- final RefineStatement declared) {
+ protected final RefineEffectiveStatement createEffective(final Current<Descendant, RefineStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
// Empty refine is exceedingly unlikely: let's be lazy and reuse the implementation
- return createEffective(ctx, declared, ImmutableList.of());
+ return new RefineEffectiveStatementImpl(stmt.declared(), substatements, stmt.getSchemaPath(),
+ (SchemaNode) stmt.caerbannog().getEffectOfStatement().iterator().next().buildEffective());
}
}
}
@Override
- protected RequireInstanceEffectiveStatement createEffective(
- final StmtContext<Boolean, RequireInstanceStatement, RequireInstanceEffectiveStatement> ctx,
- final RequireInstanceStatement declared,
+ protected RequireInstanceEffectiveStatement createEffective(final RequireInstanceStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return new RegularRequireInstanceEffectiveStatement(declared, substatements);
}
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
}
@Override
- protected RevisionEffectiveStatement createEffective(
- final StmtContext<Revision, RevisionStatement, RevisionEffectiveStatement> ctx,
- final RevisionStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularRevisionEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected RevisionEffectiveStatement createEmptyEffective(
- final StmtContext<Revision, RevisionStatement, RevisionEffectiveStatement> ctx,
- final RevisionStatement declared) {
- return new EmptyRevisionEffectiveStatement(declared);
+ protected RevisionEffectiveStatement createEffective(final Current<Revision, RevisionStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return substatements.isEmpty() ? new EmptyRevisionEffectiveStatement(stmt.declared())
+ : new RegularRevisionEffectiveStatement(stmt.declared(), substatements);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.RevisionDateStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
}
@Override
- protected RevisionDateEffectiveStatement createEffective(
- final StmtContext<Revision, RevisionDateStatement, RevisionDateEffectiveStatement> ctx,
- final RevisionDateStatement declared,
+ protected RevisionDateEffectiveStatement createEffective(final Current<Revision, RevisionDateStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularRevisionDateEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected RevisionDateEffectiveStatement createEmptyEffective(
- final StmtContext<Revision, RevisionDateStatement, RevisionDateEffectiveStatement> ctx,
- final RevisionDateStatement declared) {
- return new EmptyRevisionDateEffectiveStatement(declared);
+ return substatements.isEmpty() ? new EmptyRevisionDateEffectiveStatement(stmt.declared())
+ : new RegularRevisionDateEffectiveStatement(stmt.declared(), substatements);
}
}
\ No newline at end of file
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.rpc;
+import static com.google.common.base.Preconditions.checkState;
+
import com.google.common.collect.ImmutableList;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseSchemaTreeStatementSupport;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
}
@Override
- protected final RpcEffectiveStatement createEffective(
- final StmtContext<QName, RpcStatement, RpcEffectiveStatement> ctx, final RpcStatement declared,
+ protected RpcEffectiveStatement createEffective(final Current<QName, RpcStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RpcEffectiveStatementImpl(declared, ctx.getSchemaPath().get(), computeFlags(ctx, substatements), ctx,
- substatements);
- }
+ checkState(!substatements.isEmpty(), "Missing implicit input/output statements at %s", stmt.sourceReference());
- @Override
- protected final RpcEffectiveStatement createEmptyEffective(
- final StmtContext<QName, RpcStatement, RpcEffectiveStatement> ctx, final RpcStatement declared) {
- throw new IllegalStateException("Missing implicit input/output statements at "
- + ctx.getStatementSourceReference());
+ return new RpcEffectiveStatementImpl(stmt.declared(), substatements, stmt.sourceReference(),
+ computeFlags(substatements), stmt.getSchemaPath());
}
abstract StatementSupport<?, ?, ?> implictInput();
abstract StatementSupport<?, ?, ?> implictOutput();
- private static int computeFlags(final StmtContext<?, ?, ?> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ private static int computeFlags(final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return new FlagsBuilder()
.setStatus(findFirstArgument(substatements, StatusEffectiveStatement.class, Status.CURRENT))
.toFlags();
import org.opendaylight.yangtools.yang.model.api.stmt.RpcStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractDeclaredEffectiveStatement.DefaultWithDataTree.WithSubstatements;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.OperationDefinitionMixin;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
final class RpcEffectiveStatementImpl extends WithSubstatements<QName, RpcStatement, RpcEffectiveStatement>
implements RpcDefinition, RpcEffectiveStatement, OperationDefinitionMixin<RpcStatement> {
private final @NonNull SchemaPath path;
private final int flags;
- RpcEffectiveStatementImpl(final RpcStatement declared, final SchemaPath path, final int flags,
- final StmtContext<QName, RpcStatement, RpcEffectiveStatement> ctx,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- super(declared, ctx, substatements);
+ RpcEffectiveStatementImpl(final RpcStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements, final StatementSourceReference ref,
+ final int flags, final SchemaPath path) {
+ super(declared, substatements, ref);
this.path = requireNonNull(path);
this.flags = flags;
}
import org.opendaylight.yangtools.yang.model.api.stmt.StatusEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.StatusStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
}
@Override
- protected StatusEffectiveStatement createEffective(
- final StmtContext<Status, StatusStatement, StatusEffectiveStatement> ctx, final StatusStatement declared,
+ protected StatusEffectiveStatement createEffective(final Current<Status, StatusStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularStatusEffectiveStatement(declared, substatements);
+ return substatements.isEmpty() ? createEmptyEffective(stmt.declared())
+ : new RegularStatusEffectiveStatement(stmt.declared(), substatements);
}
- @Override
- protected StatusEffectiveStatement createEmptyEffective(
- final StmtContext<Status, StatusStatement, StatusEffectiveStatement> ctx, final StatusStatement declared) {
+ private static @NonNull StatusEffectiveStatement createEmptyEffective(final StatusStatement declared) {
// Aggressively reuse effective instances which are backed by the corresponding empty declared instance, as this
// is the case unless there is a weird extension in use.
if (EMPTY_DEPRECATED_DECL.equals(declared)) {
import org.opendaylight.yangtools.yang.model.repo.api.SourceIdentifier;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.SubmoduleNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
import org.opendaylight.yangtools.yang.parser.spi.source.BelongsToPrefixToModuleName;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
abstract class AbstractSubmoduleStatementSupport
extends BaseStatementSupport<UnqualifiedQName, SubmoduleStatement, SubmoduleEffectiveStatement> {
@Override
protected final SubmoduleStatement createEmptyDeclared(
final StmtContext<UnqualifiedQName, SubmoduleStatement, ?> ctx) {
- throw noBelongsTo(ctx);
+ throw noBelongsTo(ctx.getStatementSourceReference());
}
@Override
- protected final SubmoduleEffectiveStatement createEffective(
- final StmtContext<UnqualifiedQName, SubmoduleStatement, SubmoduleEffectiveStatement> ctx,
- final SubmoduleStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new SubmoduleEffectiveStatementImpl(ctx, declared, substatements);
- }
-
- @Override
- protected final SubmoduleEffectiveStatement createEmptyEffective(
- final StmtContext<UnqualifiedQName, SubmoduleStatement, SubmoduleEffectiveStatement> ctx,
- final SubmoduleStatement declared) {
- throw noBelongsTo(ctx);
+ protected SubmoduleEffectiveStatement createEffective(final Current<UnqualifiedQName, SubmoduleStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ if (substatements.isEmpty()) {
+ throw noBelongsTo(stmt.sourceReference());
+ }
+ return new SubmoduleEffectiveStatementImpl(stmt, substatements);
}
- private static SourceException noBelongsTo(final StmtContext<?, ?, ?> ctx) {
- return new SourceException("No belongs-to declared in submodule", ctx.getStatementSourceReference());
+ private static SourceException noBelongsTo(final StatementSourceReference ref) {
+ return new SourceException("No belongs-to declared in submodule", ref);
}
}
import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SubmoduleStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.AbstractEffectiveModule;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.MutableStatement;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
private ImmutableSet<Submodule> submodules;
private boolean sealed;
- SubmoduleEffectiveStatementImpl(
- final StmtContext<UnqualifiedQName, SubmoduleStatement, SubmoduleEffectiveStatement> ctx,
- final SubmoduleStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- super(declared, ctx, substatements, findSubmodulePrefix(ctx));
+ SubmoduleEffectiveStatementImpl(final Current<UnqualifiedQName, SubmoduleStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(stmt, substatements, findSubmodulePrefix(stmt.caerbannog()));
- final String belongsToModuleName = firstAttributeOf(ctx.declaredSubstatements(), BelongsToStatement.class);
- final QNameModule belongsToModuleQName = ctx.getFromNamespace(ModuleNameToModuleQName.class,
- belongsToModuleName);
+ final QNameModule belongsToModuleQName = stmt.getFromNamespace(ModuleNameToModuleQName.class,
+ firstAttributeOf(stmt.caerbannog().declaredSubstatements(), BelongsToStatement.class));
final Builder<String, ModuleEffectiveStatement> prefixToModuleBuilder = ImmutableMap.builder();
- appendPrefixes(ctx, prefixToModuleBuilder);
+ appendPrefixes(stmt, prefixToModuleBuilder);
prefixToModule = prefixToModuleBuilder.build();
final Map<QNameModule, String> tmp = Maps.newLinkedHashMapWithExpectedSize(prefixToModule.size());
* collect only submodule contexts here and then build them during
* sealing of this statement.
*/
- final Map<String, StmtContext<?, ?, ?>> includedSubmodulesMap = ctx.getAllFromCurrentStmtCtxNamespace(
+ final Map<String, StmtContext<?, ?, ?>> includedSubmodulesMap = stmt.getAllFromCurrentStmtCtxNamespace(
IncludedSubmoduleNameToModuleCtx.class);
if (includedSubmodulesMap != null) {
final Set<StmtContext<?, SubmoduleStatement, SubmoduleEffectiveStatement>> submoduleContextsInit =
}
if (!submoduleContexts.isEmpty()) {
- ((Mutable<?, ?, ?>) ctx).addMutableStmtToSeal(this);
+ ((Mutable<?, ?, ?>) stmt.caerbannog()).addMutableStmtToSeal(this);
sealed = false;
} else {
submodules = ImmutableSet.of();
import org.opendaylight.yangtools.yang.model.util.type.IdentityrefTypeBuilder;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.IdentityNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
abstract class AbstractIdentityRefSpecificationSupport
extends BaseStatementSupport<String, IdentityRefSpecification,
@Override
protected final IdentityRefSpecification createEmptyDeclared(
final StmtContext<String, IdentityRefSpecification, ?> ctx) {
- throw noBase(ctx);
+ throw noBase(ctx.getStatementSourceReference());
}
@Override
protected final EffectiveStatement<String, IdentityRefSpecification> createEffective(
- final StmtContext<String, IdentityRefSpecification,
- EffectiveStatement<String, IdentityRefSpecification>> ctx,
- final IdentityRefSpecification declared,
+ final Current<String, IdentityRefSpecification> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- final IdentityrefTypeBuilder builder = BaseTypes.identityrefTypeBuilder(ctx.getSchemaPath().get());
- for (final EffectiveStatement<?, ?> stmt : substatements) {
- if (stmt instanceof BaseEffectiveStatement) {
- final QName identityQName = ((BaseEffectiveStatement) stmt).argument();
+ if (substatements.isEmpty()) {
+ throw noBase(stmt.sourceReference());
+ }
+
+ final IdentityrefTypeBuilder builder = BaseTypes.identityrefTypeBuilder(stmt.getSchemaPath());
+ for (final EffectiveStatement<?, ?> subStmt : substatements) {
+ if (subStmt instanceof BaseEffectiveStatement) {
+ final QName identityQName = ((BaseEffectiveStatement) subStmt).argument();
final StmtContext<?, IdentityStatement, IdentityEffectiveStatement> identityCtx =
- ctx.getFromNamespace(IdentityNamespace.class, identityQName);
+ stmt.getFromNamespace(IdentityNamespace.class, identityQName);
builder.addIdentity((IdentitySchemaNode) identityCtx.buildEffective());
}
}
- return new TypeEffectiveStatementImpl<>(declared, substatements, builder);
- }
-
- @Override
- protected final EffectiveStatement<String, IdentityRefSpecification> createEmptyEffective(
- final StmtContext<String, IdentityRefSpecification,
- EffectiveStatement<String, IdentityRefSpecification>> ctx,
- final IdentityRefSpecification declared) {
- throw noBase(ctx);
+ return new TypeEffectiveStatementImpl<>(stmt.declared(), substatements, builder);
}
- private static SourceException noBase(final StmtContext<?, ?, ?> ctx) {
+ private static SourceException noBase(final StatementSourceReference ref) {
/*
* https://tools.ietf.org/html/rfc7950#section-9.10.2
*
* statement, MUST be present at least once if the type is
* "identityref".
*/
- return new SourceException("At least one base statement has to be present",
- ctx.getStatementSourceReference());
+ return new SourceException("At least one base statement has to be present", ref);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
import org.opendaylight.yangtools.yang.model.util.type.LeafrefTypeBuilder;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
abstract class AbstractLeafrefSpecificationSupport
extends BaseStatementSupport<String, LeafrefSpecification, EffectiveStatement<String, LeafrefSpecification>> {
@Override
protected final LeafrefSpecification createEmptyDeclared(final StmtContext<String, LeafrefSpecification, ?> ctx) {
- throw noPath(ctx);
+ throw noPath(ctx.getStatementSourceReference());
}
@Override
- protected final EffectiveStatement<String, LeafrefSpecification> createEffective(
- final StmtContext<String, LeafrefSpecification, EffectiveStatement<String, LeafrefSpecification>> ctx,
- final LeafrefSpecification declared,
+ protected EffectiveStatement<String, LeafrefSpecification> createEffective(
+ final Current<String, LeafrefSpecification> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- final LeafrefTypeBuilder builder = BaseTypes.leafrefTypeBuilder(ctx.getSchemaPath().get());
+ if (substatements.isEmpty()) {
+ throw noPath(stmt.sourceReference());
+ }
+
+ final LeafrefTypeBuilder builder = BaseTypes.leafrefTypeBuilder(stmt.getSchemaPath());
- for (final EffectiveStatement<?, ?> stmt : substatements) {
- if (stmt instanceof PathEffectiveStatement) {
- builder.setPathStatement(((PathEffectiveStatement) stmt).argument());
- } else if (stmt instanceof RequireInstanceEffectiveStatement) {
- builder.setRequireInstance(((RequireInstanceEffectiveStatement)stmt).argument());
+ for (final EffectiveStatement<?, ?> subStmt : substatements) {
+ if (subStmt instanceof PathEffectiveStatement) {
+ builder.setPathStatement(((PathEffectiveStatement) subStmt).argument());
+ } else if (subStmt instanceof RequireInstanceEffectiveStatement) {
+ builder.setRequireInstance(((RequireInstanceEffectiveStatement)subStmt).argument());
}
}
- return new TypeEffectiveStatementImpl<>(declared, substatements, builder);
- }
-
- @Override
- protected final EffectiveStatement<String, LeafrefSpecification> createEmptyEffective(
- final StmtContext<String, LeafrefSpecification, EffectiveStatement<String, LeafrefSpecification>> ctx,
- final LeafrefSpecification declared) {
- throw noPath(ctx);
+ return new TypeEffectiveStatementImpl<>(stmt.declared(), substatements, builder);
}
- private static SourceException noPath(final StmtContext<?, ?, ?> ctx) {
+ private static SourceException noPath(final StatementSourceReference ref) {
/*
* https://tools.ietf.org/html/rfc7950#section-9.12
*
* When the type is "union", the "type" statement (Section 7.4) MUST be
* present.
*/
- return new SourceException("A path statement has to be present", ctx.getStatementSourceReference());
+ return new SourceException("A path statement has to be present", ref);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.util.type.StringTypeBuilder;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
import org.opendaylight.yangtools.yang.parser.spi.TypeNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
}
@Override
- protected final TypeEffectiveStatement<TypeStatement> createEffective(
- final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
- final TypeStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ protected EffectiveStatement<String, TypeStatement> createEffective(final Current<String, TypeStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
// First look up the proper base type
- final TypeEffectiveStatement<TypeStatement> typeStmt = resolveType(ctx);
+ final TypeEffectiveStatement<TypeStatement> typeStmt = resolveType(stmt);
+ if (substatements.isEmpty()) {
+ return typeStmt;
+ }
+
// Now instantiate the proper effective statement for that type
final TypeDefinition<?> baseType = typeStmt.getTypeDefinition();
+ final TypeStatement declared = stmt.declared();
if (baseType instanceof BinaryTypeDefinition) {
- return createBinary(ctx, (BinaryTypeDefinition) baseType, declared, substatements);
+ return createBinary(stmt, (BinaryTypeDefinition) baseType, declared, substatements);
} else if (baseType instanceof BitsTypeDefinition) {
- return createBits(ctx, (BitsTypeDefinition) baseType, declared, substatements);
+ return createBits(stmt, (BitsTypeDefinition) baseType, declared, substatements);
} else if (baseType instanceof BooleanTypeDefinition) {
- return createBoolean(ctx, (BooleanTypeDefinition) baseType, declared, substatements);
+ return createBoolean(stmt, (BooleanTypeDefinition) baseType, declared, substatements);
} else if (baseType instanceof DecimalTypeDefinition) {
- return createDecimal(ctx, (DecimalTypeDefinition) baseType, declared, substatements);
+ return createDecimal(stmt, (DecimalTypeDefinition) baseType, declared, substatements);
} else if (baseType instanceof EmptyTypeDefinition) {
- return createEmpty(ctx, (EmptyTypeDefinition) baseType, declared, substatements);
+ return createEmpty(stmt, (EmptyTypeDefinition) baseType, declared, substatements);
} else if (baseType instanceof EnumTypeDefinition) {
- return createEnum(ctx, (EnumTypeDefinition) baseType, declared, substatements);
+ return createEnum(stmt, (EnumTypeDefinition) baseType, declared, substatements);
} else if (baseType instanceof IdentityrefTypeDefinition) {
- return createIdentityref(ctx, (IdentityrefTypeDefinition) baseType, declared, substatements);
+ return createIdentityref(stmt, (IdentityrefTypeDefinition) baseType, declared, substatements);
} else if (baseType instanceof InstanceIdentifierTypeDefinition) {
- return createInstanceIdentifier(ctx, (InstanceIdentifierTypeDefinition) baseType, declared, substatements);
+ return createInstanceIdentifier(stmt, (InstanceIdentifierTypeDefinition) baseType, declared, substatements);
} else if (baseType instanceof Int8TypeDefinition) {
- return createIntegral(ctx, declared, substatements,
- RestrictedTypes.newInt8Builder((Int8TypeDefinition) baseType, typeEffectiveSchemaPath(ctx)));
+ return createIntegral(stmt, declared, substatements,
+ RestrictedTypes.newInt8Builder((Int8TypeDefinition) baseType, typeEffectiveSchemaPath(stmt)));
} else if (baseType instanceof Int16TypeDefinition) {
- return createIntegral(ctx, declared, substatements,
- RestrictedTypes.newInt16Builder((Int16TypeDefinition) baseType, typeEffectiveSchemaPath(ctx)));
+ return createIntegral(stmt, declared, substatements,
+ RestrictedTypes.newInt16Builder((Int16TypeDefinition) baseType, typeEffectiveSchemaPath(stmt)));
} else if (baseType instanceof Int32TypeDefinition) {
- return createIntegral(ctx, declared, substatements,
- RestrictedTypes.newInt32Builder((Int32TypeDefinition) baseType, typeEffectiveSchemaPath(ctx)));
+ return createIntegral(stmt, declared, substatements,
+ RestrictedTypes.newInt32Builder((Int32TypeDefinition) baseType, typeEffectiveSchemaPath(stmt)));
} else if (baseType instanceof Int64TypeDefinition) {
- return createIntegral(ctx, declared, substatements,
- RestrictedTypes.newInt64Builder((Int64TypeDefinition) baseType, typeEffectiveSchemaPath(ctx)));
+ return createIntegral(stmt, declared, substatements,
+ RestrictedTypes.newInt64Builder((Int64TypeDefinition) baseType, typeEffectiveSchemaPath(stmt)));
} else if (baseType instanceof LeafrefTypeDefinition) {
- return createLeafref(ctx, (LeafrefTypeDefinition) baseType, declared, substatements);
+ return createLeafref(stmt, (LeafrefTypeDefinition) baseType, declared, substatements);
} else if (baseType instanceof StringTypeDefinition) {
- return createString(ctx, (StringTypeDefinition) baseType, declared, substatements);
+ return createString(stmt, (StringTypeDefinition) baseType, declared, substatements);
} else if (baseType instanceof Uint8TypeDefinition) {
- return createIntegral(ctx, declared, substatements,
- RestrictedTypes.newUint8Builder((Uint8TypeDefinition) baseType, typeEffectiveSchemaPath(ctx)));
+ return createIntegral(stmt, declared, substatements,
+ RestrictedTypes.newUint8Builder((Uint8TypeDefinition) baseType, typeEffectiveSchemaPath(stmt)));
} else if (baseType instanceof Uint16TypeDefinition) {
- return createIntegral(ctx, declared, substatements,
- RestrictedTypes.newUint16Builder((Uint16TypeDefinition) baseType, typeEffectiveSchemaPath(ctx)));
+ return createIntegral(stmt, declared, substatements,
+ RestrictedTypes.newUint16Builder((Uint16TypeDefinition) baseType, typeEffectiveSchemaPath(stmt)));
} else if (baseType instanceof Uint32TypeDefinition) {
- return createIntegral(ctx, declared, substatements,
- RestrictedTypes.newUint32Builder((Uint32TypeDefinition) baseType, typeEffectiveSchemaPath(ctx)));
+ return createIntegral(stmt, declared, substatements,
+ RestrictedTypes.newUint32Builder((Uint32TypeDefinition) baseType, typeEffectiveSchemaPath(stmt)));
} else if (baseType instanceof Uint64TypeDefinition) {
- return createIntegral(ctx, declared, substatements,
- RestrictedTypes.newUint64Builder((Uint64TypeDefinition) baseType, typeEffectiveSchemaPath(ctx)));
+ return createIntegral(stmt, declared, substatements,
+ RestrictedTypes.newUint64Builder((Uint64TypeDefinition) baseType, typeEffectiveSchemaPath(stmt)));
} else if (baseType instanceof UnionTypeDefinition) {
- return createUnion(ctx, (UnionTypeDefinition) baseType, declared, substatements);
+ return createUnion(stmt, (UnionTypeDefinition) baseType, declared, substatements);
} else {
throw new IllegalStateException("Unhandled base type " + baseType);
}
}
- @Override
- protected final EffectiveStatement<String, TypeStatement> createEmptyEffective(
- final StmtContext<String, TypeStatement, EffectiveStatement<String, TypeStatement>> ctx,
- final TypeStatement declared) {
- return resolveType(ctx);
- }
-
- static final SchemaPath typeEffectiveSchemaPath(final StmtContext<?, ?, ?> stmtCtx) {
- final SchemaPath path = stmtCtx.getSchemaPath().get();
+ static final SchemaPath typeEffectiveSchemaPath(final Current<?, ?> stmt) {
+ final SchemaPath path = stmt.getSchemaPath();
final SchemaPath parent = path.getParent();
final QName parentQName = parent.getLastComponent();
checkArgument(parentQName != null, "Path %s has an empty parent", path);
* @return Resolved type
* @throws SourceException if the target type cannot be found
*/
- private static @NonNull TypeEffectiveStatement<TypeStatement> resolveType(final StmtContext<String, ?, ?> ctx) {
- final String argument = ctx.coerceStatementArgument();
+ private static @NonNull TypeEffectiveStatement<TypeStatement> resolveType(final Current<String, ?> ctx) {
+ final String argument = ctx.coerceArgument();
switch (argument) {
case BINARY:
return BuiltinEffectiveStatement.BINARY;
case UINT64:
return BuiltinEffectiveStatement.UINT64;
default:
- final QName qname = StmtContextUtils.parseNodeIdentifier(ctx, argument);
+ final QName qname = StmtContextUtils.parseNodeIdentifier(ctx.caerbannog(), argument);
final StmtContext<?, TypedefStatement, TypedefEffectiveStatement> typedef =
SourceException.throwIfNull(ctx.getFromNamespace(TypeNamespace.class, qname),
- ctx.getStatementSourceReference(), "Type '%s' not found", qname);
+ ctx.sourceReference(), "Type '%s' not found", qname);
return typedef.buildEffective().asTypeEffectiveStatement();
}
}
- private static @NonNull TypeEffectiveStatement<TypeStatement> createBinary(final StmtContext<?, ?, ?> ctx,
+ private static @NonNull TypeEffectiveStatement<TypeStatement> createBinary(final Current<?, ?> ctx,
final BinaryTypeDefinition baseType, final TypeStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
final LengthRestrictedTypeBuilder<BinaryTypeDefinition> builder =
try {
builder.setLengthConstraint(length, length.argument());
} catch (IllegalStateException e) {
- throw new SourceException(ctx.getStatementSourceReference(), e,
- "Multiple length constraints encountered");
+ throw new SourceException(ctx.sourceReference(), e, "Multiple length constraints encountered");
} catch (InvalidLengthConstraintException e) {
- throw new SourceException(ctx.getStatementSourceReference(), e, "Invalid length constraint %s",
+ throw new SourceException(ctx.sourceReference(), e, "Invalid length constraint %s",
length.argument());
}
}
return new TypeEffectiveStatementImpl<>(declared, substatements, builder);
}
- private static @NonNull TypeEffectiveStatement<TypeStatement> createBits(final StmtContext<?, ?, ?> ctx,
+ private static @NonNull TypeEffectiveStatement<TypeStatement> createBits(final Current<?, ?> ctx,
final BitsTypeDefinition baseType, final TypeStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- final BitsTypeBuilder builder = RestrictedTypes.newBitsBuilder(baseType, ctx.getSchemaPath().get());
+ final BitsTypeBuilder builder = RestrictedTypes.newBitsBuilder(baseType, ctx.getSchemaPath());
- final YangVersion yangVersion = ctx.getRootVersion();
+ final YangVersion yangVersion = ctx.yangVersion();
for (final EffectiveStatement<?, ?> stmt : substatements) {
if (stmt instanceof BitEffectiveStatement) {
- SourceException.throwIf(yangVersion != YangVersion.VERSION_1_1, ctx.getStatementSourceReference(),
+ SourceException.throwIf(yangVersion != YangVersion.VERSION_1_1, ctx.sourceReference(),
"Restricted bits type is allowed only in YANG 1.1 version.");
final BitEffectiveStatement bitSubStmt = (BitEffectiveStatement) stmt;
return new TypeEffectiveStatementImpl<>(declared, substatements, builder);
}
- private static @NonNull TypeEffectiveStatement<TypeStatement> createBoolean(final StmtContext<?, ?, ?> ctx,
+ private static @NonNull TypeEffectiveStatement<TypeStatement> createBoolean(final Current<?, ?> ctx,
final BooleanTypeDefinition baseType, final TypeStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return new TypeEffectiveStatementImpl<>(declared, substatements, RestrictedTypes.newBooleanBuilder(baseType,
typeEffectiveSchemaPath(ctx)));
}
- private static @NonNull TypeEffectiveStatement<TypeStatement> createDecimal(final StmtContext<?, ?, ?> ctx,
+ private static @NonNull TypeEffectiveStatement<TypeStatement> createDecimal(final Current<?, ?> ctx,
final DecimalTypeDefinition baseType, final TypeStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
final RangeRestrictedTypeBuilder<DecimalTypeDefinition, BigDecimal> builder =
}
if (stmt instanceof FractionDigitsEffectiveStatement) {
final Integer digits = ((FractionDigitsEffectiveStatement)stmt).argument();
- SourceException.throwIf(baseType.getFractionDigits() != digits, ctx.getStatementSourceReference(),
+ SourceException.throwIf(baseType.getFractionDigits() != digits, ctx.sourceReference(),
"Cannot override fraction-digits from base type %s to %s", baseType, digits);
}
}
return new TypeEffectiveStatementImpl<>(declared, substatements, builder);
}
- private static @NonNull TypeEffectiveStatement<TypeStatement> createEmpty(final StmtContext<?, ?, ?> ctx,
+ private static @NonNull TypeEffectiveStatement<TypeStatement> createEmpty(final Current<?, ?> ctx,
final EmptyTypeDefinition baseType, final TypeStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return new TypeEffectiveStatementImpl<>(declared, substatements, RestrictedTypes.newEmptyBuilder(baseType,
typeEffectiveSchemaPath(ctx)));
}
- private static @NonNull TypeEffectiveStatement<TypeStatement> createEnum(final StmtContext<?, ?, ?> ctx,
+ private static @NonNull TypeEffectiveStatement<TypeStatement> createEnum(final Current<?, ?> ctx,
final EnumTypeDefinition baseType, final TypeStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- final EnumerationTypeBuilder builder = RestrictedTypes.newEnumerationBuilder(baseType,
- ctx.getSchemaPath().get());
+ final EnumerationTypeBuilder builder = RestrictedTypes.newEnumerationBuilder(baseType, ctx.getSchemaPath());
- final YangVersion yangVersion = ctx.getRootVersion();
+ final YangVersion yangVersion = ctx.yangVersion();
for (final EffectiveStatement<?, ?> stmt : substatements) {
if (stmt instanceof EnumEffectiveStatement) {
- SourceException.throwIf(yangVersion != YangVersion.VERSION_1_1, ctx.getStatementSourceReference(),
+ SourceException.throwIf(yangVersion != YangVersion.VERSION_1_1, ctx.sourceReference(),
"Restricted enumeration type is allowed only in YANG 1.1 version.");
final EnumEffectiveStatement enumSubStmt = (EnumEffectiveStatement) stmt;
return new TypeEffectiveStatementImpl<>(declared, substatements, builder);
}
- private static @NonNull TypeEffectiveStatement<TypeStatement> createIdentityref(final StmtContext<?, ?, ?> ctx,
+ private static @NonNull TypeEffectiveStatement<TypeStatement> createIdentityref(final Current<?, ?> ctx,
final IdentityrefTypeDefinition baseType, final TypeStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return new TypeEffectiveStatementImpl<>(declared, substatements, RestrictedTypes.newIdentityrefBuilder(baseType,
}
private static @NonNull TypeEffectiveStatement<TypeStatement> createInstanceIdentifier(
- final StmtContext<?, ?, ?> ctx, final InstanceIdentifierTypeDefinition baseType,
- final TypeStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ final Current<?, ?> ctx, final InstanceIdentifierTypeDefinition baseType, final TypeStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
final InstanceIdentifierTypeBuilder builder = RestrictedTypes.newInstanceIdentifierBuilder(baseType,
typeEffectiveSchemaPath(ctx));
}
private static <T extends RangeRestrictedTypeDefinition<T, N>, N extends Number & Comparable<N>>
- @NonNull TypeEffectiveStatement<TypeStatement> createIntegral(final StmtContext<?, ?, ?> ctx,
+ @NonNull TypeEffectiveStatement<TypeStatement> createIntegral(final Current<?, ?> ctx,
final TypeStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
final RangeRestrictedTypeBuilder<T, N> builder) {
for (EffectiveStatement<?, ?> stmt : substatements) {
try {
return new TypeEffectiveStatementImpl<>(declared, substatements, builder);
} catch (InvalidRangeConstraintException e) {
- throw new SourceException(ctx.getStatementSourceReference(), e, "Invalid range constraint: %s",
+ throw new SourceException(ctx.sourceReference(), e, "Invalid range constraint: %s",
e.getOffendingRanges());
}
}
- private static @NonNull TypeEffectiveStatement<TypeStatement> createLeafref(final StmtContext<?, ?, ?> ctx,
+ private static @NonNull TypeEffectiveStatement<TypeStatement> createLeafref(final Current<?, ?> ctx,
final LeafrefTypeDefinition baseType, final TypeStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
final RequireInstanceRestrictedTypeBuilder<LeafrefTypeDefinition> builder =
return new TypeEffectiveStatementImpl<>(declared, substatements, builder);
}
- private static @NonNull TypeEffectiveStatement<TypeStatement> createString(final StmtContext<?, ?, ?> ctx,
+ private static @NonNull TypeEffectiveStatement<TypeStatement> createString(final Current<?, ?> ctx,
final StringTypeDefinition baseType, final TypeStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
final StringTypeBuilder builder = RestrictedTypes.newStringBuilder(baseType,
try {
builder.setLengthConstraint(length, length.argument());
} catch (IllegalStateException e) {
- throw new SourceException(ctx.getStatementSourceReference(), e,
- "Multiple length constraints encountered");
+ throw new SourceException(ctx.sourceReference(), e, "Multiple length constraints encountered");
} catch (InvalidLengthConstraintException e) {
- throw new SourceException(ctx.getStatementSourceReference(), e, "Invalid length constraint %s",
+ throw new SourceException(ctx.sourceReference(), e, "Invalid length constraint %s",
length.argument());
}
}
return new TypeEffectiveStatementImpl<>(declared, substatements, builder);
}
- private static @NonNull TypeEffectiveStatement<TypeStatement> createUnion(final StmtContext<?, ?, ?> ctx,
+ private static @NonNull TypeEffectiveStatement<TypeStatement> createUnion(final Current<?, ?> ctx,
final UnionTypeDefinition baseType, final TypeStatement declared,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return new TypeEffectiveStatementImpl<>(declared, substatements, RestrictedTypes.newUnionBuilder(baseType,
}
private static Uint32 getBaseTypeBitPosition(final String bitName, final BitsTypeDefinition baseType,
- final StmtContext<?, ?, ?> ctx) {
+ final Current<?, ?> ctx) {
for (Bit baseTypeBit : baseType.getBits()) {
if (bitName.equals(baseTypeBit.getName())) {
return baseTypeBit.getPosition();
}
}
- throw new SourceException(ctx.getStatementSourceReference(),
- "Bit '%s' is not a subset of its base bits type %s.", bitName, baseType.getQName());
+ throw new SourceException(ctx.sourceReference(), "Bit '%s' is not a subset of its base bits type %s.",
+ bitName, baseType.getQName());
}
private static int getBaseTypeEnumValue(final String enumName, final EnumTypeDefinition baseType,
- final StmtContext<?, ?, ?> ctx) {
+ final Current<?, ?> ctx) {
for (EnumPair baseTypeEnumPair : baseType.getValues()) {
if (enumName.equals(baseTypeEnumPair.getName())) {
return baseTypeEnumPair.getValue();
}
}
- throw new SourceException(ctx.getStatementSourceReference(),
- "Enum '%s' is not a subset of its base enumeration type %s.", enumName, baseType.getQName());
+ throw new SourceException(ctx.sourceReference(), "Enum '%s' is not a subset of its base enumeration type %s.",
+ enumName, baseType.getQName());
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
import org.opendaylight.yangtools.yang.model.util.type.BitsTypeBuilder;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
final class BitsSpecificationSupport
extends BaseStatementSupport<String, BitsSpecification, EffectiveStatement<String, BitsSpecification>> {
@Override
protected BitsSpecification createEmptyDeclared(final StmtContext<String, BitsSpecification, ?> ctx) {
- throw noBits(ctx);
+ throw noBits(ctx.getStatementSourceReference());
}
@Override
protected EffectiveStatement<String, BitsSpecification> createEffective(
- final StmtContext<String, BitsSpecification, EffectiveStatement<String, BitsSpecification>> ctx,
- final BitsSpecification declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- final BitsTypeBuilder builder = BaseTypes.bitsTypeBuilder(ctx.getSchemaPath().get());
+ final Current<String, BitsSpecification> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ if (substatements.isEmpty()) {
+ throw noBits(stmt.sourceReference());
+ }
+
+ final BitsTypeBuilder builder = BaseTypes.bitsTypeBuilder(stmt.getSchemaPath());
Uint32 highestPosition = null;
- for (final EffectiveStatement<?, ?> stmt : substatements) {
- if (stmt instanceof BitEffectiveStatement) {
- final BitEffectiveStatement bitSubStmt = (BitEffectiveStatement) stmt;
+ for (final EffectiveStatement<?, ?> subStmt : substatements) {
+ if (subStmt instanceof BitEffectiveStatement) {
+ final BitEffectiveStatement bitSubStmt = (BitEffectiveStatement) subStmt;
final Optional<Uint32> declaredPosition = bitSubStmt.getDeclaredPosition();
final Uint32 effectivePos;
if (declaredPosition.isEmpty()) {
if (highestPosition != null) {
- SourceException.throwIf(Uint32.MAX_VALUE.equals(highestPosition),
- ctx.getStatementSourceReference(), "Bit %s must have a position statement", bitSubStmt);
+ SourceException.throwIf(Uint32.MAX_VALUE.equals(highestPosition), stmt.sourceReference(),
+ "Bit %s must have a position statement", bitSubStmt);
effectivePos = Uint32.fromIntBits(highestPosition.intValue() + 1);
} else {
effectivePos = Uint32.ZERO;
}
}
- return new TypeEffectiveStatementImpl<>(declared, substatements, builder);
- }
-
- @Override
- protected EffectiveStatement<String, BitsSpecification> createEmptyEffective(
- final StmtContext<String, BitsSpecification, EffectiveStatement<String, BitsSpecification>> ctx,
- final BitsSpecification declared) {
- throw noBits(ctx);
+ return new TypeEffectiveStatementImpl<>(stmt.declared(), substatements, builder);
}
- private static SourceException noBits(final StmtContext<?, ?, ?> ctx) {
+ private static SourceException noBits(final StatementSourceReference ref) {
/*
* https://tools.ietf.org/html/rfc7950#section-9.7.4:
*
* The "bit" statement, which is a substatement to the "type" statement,
* MUST be present if the type is "bits".
*/
- return new SourceException("At least one bit statement has to be present", ctx.getStatementSourceReference());
+ return new SourceException("At least one bit statement has to be present", ref);
}
}
import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
import org.opendaylight.yangtools.yang.model.util.type.DecimalTypeBuilder;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
final class Decimal64SpecificationSupport extends BaseStatementSupport<String, Decimal64Specification,
EffectiveStatement<String, Decimal64Specification>> {
@Override
protected Decimal64Specification createEmptyDeclared(final StmtContext<String, Decimal64Specification, ?> ctx) {
- throw noFracDigits(ctx);
+ throw noFracDigits(ctx.getStatementSourceReference());
}
@Override
protected EffectiveStatement<String, Decimal64Specification> createEffective(
- final StmtContext<String, Decimal64Specification, EffectiveStatement<String, Decimal64Specification>> ctx,
- final Decimal64Specification declared,
+ final Current<String, Decimal64Specification> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- final DecimalTypeBuilder builder = BaseTypes.decimalTypeBuilder(ctx.getSchemaPath().get());
- for (final EffectiveStatement<?, ?> stmt : substatements) {
- if (stmt instanceof FractionDigitsEffectiveStatement) {
- builder.setFractionDigits(((FractionDigitsEffectiveStatement) stmt).argument());
+ if (substatements.isEmpty()) {
+ throw noFracDigits(stmt.sourceReference());
+ }
+
+ final DecimalTypeBuilder builder = BaseTypes.decimalTypeBuilder(stmt.getSchemaPath());
+ for (final EffectiveStatement<?, ?> subStmt : substatements) {
+ if (subStmt instanceof FractionDigitsEffectiveStatement) {
+ builder.setFractionDigits(((FractionDigitsEffectiveStatement) subStmt).argument());
}
- if (stmt instanceof RangeEffectiveStatement) {
- final RangeEffectiveStatement range = (RangeEffectiveStatement) stmt;
+ if (subStmt instanceof RangeEffectiveStatement) {
+ final RangeEffectiveStatement range = (RangeEffectiveStatement) subStmt;
builder.setRangeConstraint(range, range.argument());
}
}
- return new TypeEffectiveStatementImpl<>(declared, substatements, builder);
- }
-
- @Override
- protected EffectiveStatement<String, Decimal64Specification> createEmptyEffective(
- final StmtContext<String, Decimal64Specification, EffectiveStatement<String, Decimal64Specification>> ctx,
- final Decimal64Specification declared) {
- throw noFracDigits(ctx);
+ return new TypeEffectiveStatementImpl<>(stmt.declared(), substatements, builder);
}
- private static SourceException noFracDigits(final StmtContext<?, ?, ?> ctx) {
+ private static SourceException noFracDigits(final StatementSourceReference ref) {
/*
* https://tools.ietf.org/html/rfc7950#section-9.3.4
*
* The "fraction-digits" statement, which is a substatement to the
* "type" statement, MUST be present if the type is "decimal64".
*/
- return new SourceException("At least one fraction-digits statement has to be present",
- ctx.getStatementSourceReference());
+ return new SourceException("At least one fraction-digits statement has to be present", ref);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
import org.opendaylight.yangtools.yang.model.util.type.EnumerationTypeBuilder;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
final class EnumSpecificationSupport
extends BaseStatementSupport<String, EnumSpecification, EffectiveStatement<String, EnumSpecification>> {
@Override
protected EnumSpecification createEmptyDeclared(final StmtContext<String, EnumSpecification, ?> ctx) {
- throw noEnum(ctx);
+ throw noEnum(ctx.getStatementSourceReference());
}
@Override
protected EffectiveStatement<String, EnumSpecification> createEffective(
- final StmtContext<String, EnumSpecification, EffectiveStatement<String, EnumSpecification>> ctx,
- final EnumSpecification declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- final EnumerationTypeBuilder builder = BaseTypes.enumerationTypeBuilder(ctx.getSchemaPath().get());
+ final Current<String, EnumSpecification> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ if (substatements.isEmpty()) {
+ throw noEnum(stmt.sourceReference());
+ }
+
+ final EnumerationTypeBuilder builder = BaseTypes.enumerationTypeBuilder(stmt.getSchemaPath());
Integer highestValue = null;
- for (final EffectiveStatement<?, ?> stmt : substatements) {
- if (stmt instanceof EnumEffectiveStatement) {
- final EnumEffectiveStatement enumSubStmt = (EnumEffectiveStatement) stmt;
+ for (final EffectiveStatement<?, ?> subStmt : substatements) {
+ if (subStmt instanceof EnumEffectiveStatement) {
+ final EnumEffectiveStatement enumSubStmt = (EnumEffectiveStatement) subStmt;
final Optional<Integer> declaredValue =
enumSubStmt.findFirstEffectiveSubstatementArgument(ValueEffectiveStatement.class);
final int effectiveValue;
if (declaredValue.isEmpty()) {
if (highestValue != null) {
- SourceException.throwIf(highestValue == 2147483647, ctx.getStatementSourceReference(),
+ SourceException.throwIf(highestValue == 2147483647, stmt.sourceReference(),
"Enum '%s' must have a value statement", enumSubStmt);
effectiveValue = highestValue + 1;
} else {
}
}
- return new TypeEffectiveStatementImpl<>(declared, substatements, builder);
- }
-
- @Override
- protected EffectiveStatement<String, EnumSpecification> createEmptyEffective(
- final StmtContext<String, EnumSpecification, EffectiveStatement<String, EnumSpecification>> ctx,
- final EnumSpecification declared) {
- throw noEnum(ctx);
+ return new TypeEffectiveStatementImpl<>(stmt.declared(), substatements, builder);
}
- private static SourceException noEnum(final StmtContext<?, ?, ?> ctx) {
+ private static SourceException noEnum(final StatementSourceReference ref) {
/*
* https://tools.ietf.org/html/rfc7950#section-9.6.4
*
* The "enum" statement, which is a substatement to the "type"
* statement, MUST be present if the type is "enumeration".
*/
- return new SourceException("At least one enum statement has to be present", ctx.getStatementSourceReference());
+ return new SourceException("At least one enum statement has to be present", ref);
}
}
\ No newline at end of file
import org.opendaylight.yangtools.yang.model.util.type.InstanceIdentifierTypeBuilder;
import org.opendaylight.yangtools.yang.model.util.type.RestrictedTypes;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
@Override
protected EffectiveStatement<String, InstanceIdentifierSpecification> createEffective(
- final StmtContext<String, InstanceIdentifierSpecification,
- EffectiveStatement<String, InstanceIdentifierSpecification>> ctx,
- final InstanceIdentifierSpecification declared,
+ final Current<String, InstanceIdentifierSpecification> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
final InstanceIdentifierTypeBuilder builder = RestrictedTypes.newInstanceIdentifierBuilder(
- BaseTypes.instanceIdentifierType(), ctx.getSchemaPath().get());
+ BaseTypes.instanceIdentifierType(), stmt.getSchemaPath());
- for (EffectiveStatement<?, ?> stmt : substatements) {
- if (stmt instanceof RequireInstanceEffectiveStatement) {
- builder.setRequireInstance(((RequireInstanceEffectiveStatement)stmt).argument());
+ // TODO: we could do better here for empty substatements, but its really splitting hairs
+ for (EffectiveStatement<?, ?> subStmt : substatements) {
+ if (subStmt instanceof RequireInstanceEffectiveStatement) {
+ builder.setRequireInstance(((RequireInstanceEffectiveStatement)subStmt).argument());
}
}
- return new TypeEffectiveStatementImpl<>(declared, substatements, builder);
- }
-
- @Override
- protected EffectiveStatement<String, InstanceIdentifierSpecification> createEmptyEffective(
- final StmtContext<String, InstanceIdentifierSpecification,
- EffectiveStatement<String, InstanceIdentifierSpecification>> ctx,
- final InstanceIdentifierSpecification declared) {
- // TODO: we could do better here, but its really splitting hairs
- return createEffective(ctx, declared, ImmutableList.of());
+ return new TypeEffectiveStatementImpl<>(stmt.declared(), substatements, builder);
}
}
\ No newline at end of file
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.type;
import com.google.common.collect.ImmutableList;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.util.type.BaseTypes;
import org.opendaylight.yangtools.yang.model.util.type.UnionTypeBuilder;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
final class UnionSpecificationSupport
extends BaseStatementSupport<String, UnionSpecification, EffectiveStatement<String, UnionSpecification>> {
@Override
protected UnionSpecification createEmptyDeclared(final StmtContext<String, UnionSpecification, ?> ctx) {
- throw noType(ctx);
+ throw noType(ctx.getStatementSourceReference());
}
@Override
protected EffectiveStatement<String, UnionSpecification> createEffective(
- final StmtContext<String, UnionSpecification, EffectiveStatement<String, UnionSpecification>> ctx,
- final UnionSpecification declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- final UnionTypeBuilder builder = BaseTypes.unionTypeBuilder(ctx.getSchemaPath().get());
+ final Current<String, UnionSpecification> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ if (substatements.isEmpty()) {
+ throw noType(stmt.sourceReference());
+ }
+
+ final UnionTypeBuilder builder = BaseTypes.unionTypeBuilder(stmt.getSchemaPath());
- for (final EffectiveStatement<?, ?> stmt : substatements) {
- if (stmt instanceof TypeEffectiveStatement) {
- builder.addType(((TypeEffectiveStatement<?>)stmt).getTypeDefinition());
+ for (final EffectiveStatement<?, ?> subStmt : substatements) {
+ if (subStmt instanceof TypeEffectiveStatement) {
+ builder.addType(((TypeEffectiveStatement<?>)subStmt).getTypeDefinition());
}
}
- return new TypeEffectiveStatementImpl<>(declared, substatements, builder);
- }
-
- @Override
- protected EffectiveStatement<String, UnionSpecification> createEmptyEffective(
- final StmtContext<String, UnionSpecification, EffectiveStatement<String, UnionSpecification>> ctx,
- final UnionSpecification declared) {
- throw noType(ctx);
+ return new TypeEffectiveStatementImpl<>(stmt.declared(), substatements, builder);
}
- private static SourceException noType(final StmtContext<?, ?, ?> ctx) {
+ private static SourceException noType(final @NonNull StatementSourceReference ref) {
/*
* https://tools.ietf.org/html/rfc7950#section-9.12
*
* When the type is "union", the "type" statement (Section 7.4) MUST be
* present.
*/
- return new SourceException("At least one type statement has to be present", ctx.getStatementSourceReference());
+ return new SourceException("At least one type statement has to be present", ref);
}
}
*/
package org.opendaylight.yangtools.yang.parser.rfc7950.stmt.typedef;
+import static com.google.common.base.Preconditions.checkState;
+
import com.google.common.collect.ImmutableList;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.model.api.Status;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStatementMixins.EffectiveStatementWithFlags.FlagsBuilder;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.EffectiveStmtUtils;
import org.opendaylight.yangtools.yang.parser.spi.TypeNamespace;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContextUtils;
}
@Override
- protected TypedefEffectiveStatement createEffective(
- final StmtContext<QName, TypedefStatement, TypedefEffectiveStatement> ctx,
- final TypedefStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ protected TypedefEffectiveStatement createEffective(final Current<QName, TypedefStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ final TypedefStatement declared = stmt.declared();
+ checkState(!substatements.isEmpty(), "Refusing to create empty typedef for %s", stmt.declared());
+
final TypeEffectiveStatement<?> typeEffectiveStmt = findFirstStatement(substatements,
TypeEffectiveStatement.class);
final String dflt = findFirstArgument(substatements, DefaultEffectiveStatement.class, null);
SourceException.throwIf(
- EffectiveStmtUtils.hasDefaultValueMarkedWithIfFeature(ctx.getRootVersion(), typeEffectiveStmt, dflt),
- ctx.getStatementSourceReference(),
- "Typedef '%s' has default value '%s' marked with an if-feature statement.", ctx.getStatementArgument(),
- dflt);
+ EffectiveStmtUtils.hasDefaultValueMarkedWithIfFeature(stmt.yangVersion(), typeEffectiveStmt, dflt),
+ stmt.sourceReference(),
+ "Typedef '%s' has default value '%s' marked with an if-feature statement.", stmt.argument(), dflt);
- return new TypedefEffectiveStatementImpl(declared, ctx.getSchemaPath().get(), computeFlags(substatements),
+ return new TypedefEffectiveStatementImpl(declared, stmt.getSchemaPath(), computeFlags(substatements),
substatements);
}
- @Override
- protected TypedefEffectiveStatement createEmptyEffective(
- final StmtContext<QName, TypedefStatement, TypedefEffectiveStatement> ctx,
- final TypedefStatement declared) {
- throw new IllegalStateException("Refusing to create empty typedef for " + declared);
- }
-
private static void checkConflict(final StmtContext<?, ?, ?> parent, final StmtContext<QName, ?, ?> stmt) {
final QName arg = stmt.coerceStatementArgument();
final StmtContext<?, ?, ?> existing = parent.getFromNamespace(TypeNamespace.class, arg);
import org.opendaylight.yangtools.yang.model.api.stmt.UniqueStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.ArgumentUtils;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.parser.spi.source.SourceException;
}
@Override
- protected UniqueEffectiveStatement createEffective(
- final StmtContext<Set<Descendant>, UniqueStatement, UniqueEffectiveStatement> ctx,
- final UniqueStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularUniqueEffectiveStatement(declared, substatements);
- }
+ protected UniqueEffectiveStatement createEffective(final Current<Set<Descendant>, UniqueStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return substatements.isEmpty() ? new EmptyUniqueEffectiveStatement(stmt.declared())
+ : new RegularUniqueEffectiveStatement(stmt.declared(), substatements);
- @Override
- protected UniqueEffectiveStatement createEmptyEffective(
- final StmtContext<Set<Descendant>, UniqueStatement, UniqueEffectiveStatement> ctx,
- final UniqueStatement declared) {
- return new EmptyUniqueEffectiveStatement(declared);
}
private static ImmutableSet<Descendant> parseUniqueConstraintArgument(final StmtContext<?, ?, ?> ctx,
import org.opendaylight.yangtools.yang.model.api.stmt.UnitsEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.UnitsStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStringStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected UnitsEffectiveStatement createEffective(
- final StmtContext<String, UnitsStatement, UnitsEffectiveStatement> ctx,
- final UnitsStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularUnitsEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected UnitsEffectiveStatement createEmptyEffective(
- final StmtContext<String, UnitsStatement, UnitsEffectiveStatement> ctx,
- final UnitsStatement declared) {
- return new EmptyUnitsEffectiveStatement(declared);
+ protected UnitsEffectiveStatement createEffective(final Current<String, UnitsStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return substatements.isEmpty() ? new EmptyUnitsEffectiveStatement(stmt.declared())
+ : new RegularUnitsEffectiveStatement(stmt.declared(), substatements);
}
}
import org.opendaylight.yangtools.yang.parser.spi.GroupingNamespace;
import org.opendaylight.yangtools.yang.parser.spi.SchemaTreeNamespace;
import org.opendaylight.yangtools.yang.parser.spi.meta.CopyType;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.InferenceException;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder;
import org.opendaylight.yangtools.yang.parser.spi.meta.ModelActionBuilder.InferenceAction;
}
@Override
- protected UsesEffectiveStatement createEffective(
- final StmtContext<QName, UsesStatement, UsesEffectiveStatement> ctx, final UsesStatement declared,
+ protected UsesEffectiveStatement createEffective(final Current<QName, UsesStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- final GroupingDefinition sourceGrouping = getSourceGrouping(ctx);
- final int flags = historyAndStatusFlags(ctx, substatements);
- final QName argument = ctx.coerceStatementArgument();
+ final GroupingDefinition sourceGrouping = getSourceGrouping(stmt);
+ final int flags = historyAndStatusFlags(stmt.history(), substatements);
+ final QName argument = stmt.coerceArgument();
+ final UsesStatement declared = stmt.declared();
+
+ if (substatements.isEmpty()) {
+ return argument.equals(declared.argument())
+ ? new EmptyLocalUsesEffectiveStatement(declared, sourceGrouping, flags)
+ : new SimpleCopiedUsesEffectiveStatement(declared, argument, sourceGrouping, flags);
+ }
+
if (declared.argument().equals(argument)) {
return new RegularLocalUsesEffectiveStatement(declared, sourceGrouping, flags, substatements);
}
return new FullCopiedUsesEffectiveStatement(declared, argument, sourceGrouping, flags, substatements);
}
- @Override
- protected UsesEffectiveStatement createEmptyEffective(
- final StmtContext<QName, UsesStatement, UsesEffectiveStatement> ctx, final UsesStatement declared) {
- final GroupingDefinition sourceGrouping = getSourceGrouping(ctx);
- final int flags = historyAndStatusFlags(ctx, ImmutableList.of());
- final QName argument = ctx.coerceStatementArgument();
- return argument.equals(declared.argument())
- ? new EmptyLocalUsesEffectiveStatement(declared, sourceGrouping, flags)
- : new SimpleCopiedUsesEffectiveStatement(declared, argument, sourceGrouping, flags);
- }
-
static @NonNull ImmutableMap<Descendant, SchemaNode> indexRefines(
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
final Map<Descendant, SchemaNode> refines = new LinkedHashMap<>();
return ImmutableMap.copyOf(refines);
}
- private static GroupingDefinition getSourceGrouping(final StmtContext<QName, ?, ?> ctx) {
- return (GroupingDefinition) ctx.getFromNamespace(GroupingNamespace.class, ctx.coerceStatementArgument())
+ private static GroupingDefinition getSourceGrouping(final Current<QName, ?> stmt) {
+ return (GroupingDefinition) stmt.getFromNamespace(GroupingNamespace.class, stmt.coerceArgument())
.buildEffective();
}
}
@Override
- protected ValueEffectiveStatement createEmptyEffective(@NonNull final ValueStatement declared) {
- return new EmptyValueEffectiveStatement(declared);
+ protected ValueEffectiveStatement createEffective(final ValueStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return new RegularValueEffectiveStatement(declared, substatements);
}
@Override
- protected ValueEffectiveStatement createEffective(
- final StmtContext<Integer, ValueStatement, ValueEffectiveStatement> ctx, final ValueStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularValueEffectiveStatement(declared, substatements);
+ protected ValueEffectiveStatement createEmptyEffective(@NonNull final ValueStatement declared) {
+ return new EmptyValueEffectiveStatement(declared);
}
}
import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.XPathSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
import org.opendaylight.yangtools.yang.xpath.api.YangXPathExpression.QualifiedBound;
}
@Override
- protected WhenEffectiveStatement createEffective(
- final StmtContext<QualifiedBound, WhenStatement, WhenEffectiveStatement> ctx,
- final WhenStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularWhenEffectiveStatement(declared, substatements);
- }
-
- @Override
- protected WhenEffectiveStatement createEmptyEffective(
- final StmtContext<QualifiedBound, WhenStatement, WhenEffectiveStatement> ctx,
- final WhenStatement declared) {
- return new EmptyWhenEffectiveStatement(declared);
+ protected WhenEffectiveStatement createEffective(final Current<QualifiedBound, WhenStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ return substatements.isEmpty() ? new EmptyWhenEffectiveStatement(stmt.declared())
+ : new RegularWhenEffectiveStatement(stmt.declared(), substatements);
}
}
import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionEffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.YangVersionStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
}
@Override
- protected YangVersionEffectiveStatement createEffective(
- final StmtContext<YangVersion, YangVersionStatement, YangVersionEffectiveStatement> ctx,
- final YangVersionStatement declared,
+ protected YangVersionEffectiveStatement createEffective(final Current<YangVersion, YangVersionStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new RegularYangVersionEffectiveStatement(declared, substatements);
+ return substatements.isEmpty() ? createEmptyEffective(stmt.declared())
+ : new RegularYangVersionEffectiveStatement(stmt.declared(), substatements);
}
- @Override
- protected YangVersionEffectiveStatement createEmptyEffective(
- final StmtContext<YangVersion, YangVersionStatement, YangVersionEffectiveStatement> ctx,
- final YangVersionStatement declared) {
+ private static @NonNull YangVersionEffectiveStatement createEmptyEffective(final YangVersionStatement declared) {
if (EMPTY_VER1_DECL.equals(declared)) {
return EMPTY_VER1_EFF;
} else if (EMPTY_VER1_1_DECL.equals(declared)) {
}
@Override
- protected YinElementEffectiveStatement createEffective(
- final StmtContext<Boolean, YinElementStatement, YinElementEffectiveStatement> ctx,
- final YinElementStatement declared, final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ protected YinElementEffectiveStatement createEffective(final YinElementStatement declared,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
return new RegularYinElementEffectiveStatement(declared, substatements);
}
import org.opendaylight.yangtools.yang.model.api.SchemaPath;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.UnknownEffectiveStatementBase;
-import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
final class ThirdPartyExtensionEffectiveStatementImpl
extends UnknownEffectiveStatementBase<String, ThirdPartyExtensionStatement>
private final @NonNull SchemaPath path;
private final String valueFromNamespace;
- ThirdPartyExtensionEffectiveStatementImpl(final ThirdPartyExtensionStatement declared,
- final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
- final StmtContext<String, ThirdPartyExtensionStatement, ?> ctx) {
- super(ctx.getStatementArgument(), declared, substatements, ctx);
- path = ctx.coerceParentContext().getSchemaPath().get().createChild(getNodeType());
- valueFromNamespace = ctx.getFromNamespace(ThirdPartyNamespace.class, ctx);
+ ThirdPartyExtensionEffectiveStatementImpl(final Current<String, ThirdPartyExtensionStatement> stmt,
+ final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
+ super(stmt, substatements);
+ path = stmt.getParent().getSchemaPath().createChild(getNodeType());
+ valueFromNamespace = stmt.getFromNamespace(ThirdPartyNamespace.class, stmt.caerbannog());
}
@Override
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.parser.rfc7950.stmt.BaseStringStatementSupport;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
import org.opendaylight.yangtools.yang.parser.spi.meta.SubstatementValidator;
@Override
protected ThirdPartyExtensionEffectiveStatement createEffective(
- final StmtContext<String, ThirdPartyExtensionStatement, ThirdPartyExtensionEffectiveStatement> ctx,
- final ThirdPartyExtensionStatement declared,
+ final Current<String, ThirdPartyExtensionStatement> stmt,
final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
- return new ThirdPartyExtensionEffectiveStatementImpl(declared, substatements, ctx);
- }
-
- @Override
- protected ThirdPartyExtensionEffectiveStatement createEmptyEffective(
- final StmtContext<String, ThirdPartyExtensionStatement, ThirdPartyExtensionEffectiveStatement> ctx,
- final ThirdPartyExtensionStatement declared) {
- return createEffective(ctx, declared, ImmutableList.of());
+ return new ThirdPartyExtensionEffectiveStatementImpl(stmt, substatements);
}
}
--- /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 static com.google.common.base.Verify.verifyNotNull;
+
+import com.google.common.annotations.Beta;
+import com.google.common.base.VerifyException;
+import java.util.Map;
+import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
+import org.opendaylight.yangtools.concepts.Immutable;
+import org.opendaylight.yangtools.yang.common.YangVersion;
+import org.opendaylight.yangtools.yang.model.api.SchemaPath;
+import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
+import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.meta.IdentifierNamespace;
+import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.model.api.meta.StatementSource;
+import org.opendaylight.yangtools.yang.parser.spi.source.StatementSourceReference;
+
+/**
+ * Effective view of a {@link StmtContext} for the purposes of creating an {@link EffectiveStatement}.
+ */
+@Beta
+public interface EffectiveStmtCtx extends Immutable {
+ /**
+ * Return parent of this context, if there is one. All statements except for top-level source statements, such as
+ * {@code module} and {@code submodule}.
+ *
+ * @return Parent context, or null if this statement is the root
+ */
+ // FIXME: YANGTOOLS-1185: rename to effectiveParent()
+ @Nullable Parent parent();
+
+ /**
+ * Return parent of this context.
+ *
+ * @return Parent context
+ * @throws VerifyException if this context is already the root
+ */
+ // FIXME: YANGTOOLS-1185: rename to getEffectiveParent()
+ default @NonNull Parent getParent() {
+ return verifyNotNull(parent(), "Attempted to access beyond root context");
+ }
+
+ /**
+ * Minimum amount of parent state required to build an accurate effective view of a particular child. Child state
+ * is expressed as {@link Current}.
+ */
+ @Beta
+ interface Parent extends EffectiveStmtCtx {
+ // FIXME: 7.0.0: this should be Optional<Boolean>
+ boolean effectiveConfig();
+
+ // FIXME: 7.0.0: this needs to be a tri-state present/absent/disabled
+ @Deprecated
+ @NonNull Optional<SchemaPath> schemaPath();
+
+ @Deprecated
+ default @NonNull SchemaPath getSchemaPath() {
+ return schemaPath().orElseThrow();
+ }
+
+ @NonNull StatementDefinition publicDefinition();
+ }
+
+ /**
+ * Minimum amount of state required to build an accurate effective view of a statement. This is a strict superset
+ * of information available in {@link Parent}.
+ *
+ * @param <A> Argument type
+ * @param <D> Class representing declared version of this statement
+ */
+ @Beta
+ interface Current<A, D extends DeclaredStatement<A>> extends Parent {
+ default @NonNull StatementSource source() {
+ return sourceReference().getStatementSource();
+ }
+
+ @NonNull StatementSourceReference sourceReference();
+
+ @NonNull CopyHistory history();
+
+ @NonNull D declared();
+
+ <K, V, T extends K, N extends IdentifierNamespace<K, V>> @Nullable V getFromNamespace(Class<@NonNull N> type,
+ T key);
+
+ <K, V, N extends IdentifierNamespace<K, V>> Map<K, V> getAllFromCurrentStmtCtxNamespace(Class<N> type);
+
+ @Nullable A argument();
+
+ default @NonNull A coerceArgument() {
+ return verifyNotNull(argument(), "Attempted to use non-existent argument");
+ }
+
+ @Nullable String rawArgument();
+
+ @Nullable EffectiveStatement<?, ?> original();
+
+ @NonNull YangVersion yangVersion();
+
+ /**
+ * Summon the <a href="https://en.wikipedia.org/wiki/Rabbit_of_Caerbannog">Rabbit of Caerbannog</a>.
+ *
+ * @param <E> Effective Statement representation
+ * @return The {@code Legendary Black Beast of Arrrghhh}.
+ */
+ // FIXME: YANGTOOLS-1186: lob the Holy Hand Grenade of Antioch
+ @Deprecated
+ <E extends EffectiveStatement<A, D>> @NonNull StmtContext<A, D, E> caerbannog();
+ }
+}
import com.google.common.annotations.Beta;
import com.google.common.collect.ForwardingObject;
+import java.util.stream.Stream;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
import org.opendaylight.yangtools.yang.model.api.meta.StatementDefinition;
+import org.opendaylight.yangtools.yang.parser.spi.meta.EffectiveStmtCtx.Current;
import org.opendaylight.yangtools.yang.parser.spi.meta.StmtContext.Mutable;
/**
}
@Override
- public E createEffective(final StmtContext<A, D, E> ctx) {
- return delegate().createEffective(ctx);
+ public E createEffective(final Current<A, D> stmt,
+ final Stream<? extends StmtContext<?, ?, ?>> declaredSubstatements,
+ final Stream<? extends StmtContext<?, ?, ?>> effectiveSubstatements) {
+ return delegate().createEffective(stmt, declaredSubstatements, effectiveSubstatements);
}
@Override
*/
package org.opendaylight.yangtools.yang.parser.spi.meta;
+import java.util.stream.Stream;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.yangtools.yang.model.api.meta.DeclaredStatement;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+/**
+ * An entity capable of creating {@link DeclaredStatement} and {@link EffectiveStatement} instances for a particular
+ * type. This interface is usually realized as an implementation-specific combination with {@link StatementSupport}.
+ *
+ * @param <A> Argument type
+ * @param <D> Declared Statement representation
+ * @param <E> Effective Statement representation
+ */
public interface StatementFactory<A, D extends DeclaredStatement<A>, E extends EffectiveStatement<A, D>> {
/**
* Create a {@link DeclaredStatement} for specified context.
/**
* Create a {@link EffectiveStatement} for specified context.
*
- * @param ctx Statement context
- * @return An effective statement instance.
+ * @param stmt Effective capture of this statement's significant state
+ * @return An effective statement instance
*/
- @NonNull E createEffective(@NonNull StmtContext<A, D, E> ctx);
+ @NonNull E createEffective(EffectiveStmtCtx.@NonNull Current<A, D> stmt,
+ Stream<? extends StmtContext<?, ?, ?>> declaredSubstatements,
+ Stream<? extends StmtContext<?, ?, ?>> effectiveSubstatements);
}
Code Review / yangtools.git / commitdiff