*/
package org.opendaylight.yangtools.yang.parser.stmt.rfc6020;
-import com.google.common.base.Preconditions;
import com.google.common.base.Verify;
-import com.google.common.collect.ImmutableList.Builder;
+import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Iterables;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.regex.Pattern;
import javax.annotation.Nonnull;
import org.opendaylight.yangtools.yang.common.QName;
-import org.opendaylight.yangtools.yang.model.api.Rfc6020Mapping;
+import org.opendaylight.yangtools.yang.common.YangVersion;
+import org.opendaylight.yangtools.yang.model.api.YangStmtMapping;
import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.ActionStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.AugmentStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.DataDefinitionStatement;
+import org.opendaylight.yangtools.yang.model.api.stmt.NotificationStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.SchemaNodeIdentifier;
import org.opendaylight.yangtools.yang.model.api.stmt.UsesStatement;
import org.opendaylight.yangtools.yang.model.api.stmt.WhenStatement;
import org.opendaylight.yangtools.yang.parser.spi.source.StmtOrderingNamespace;
import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace;
import org.opendaylight.yangtools.yang.parser.spi.validation.ValidationBundlesNamespace.ValidationBundleType;
-import org.opendaylight.yangtools.yang.parser.stmt.reactor.RootStatementContext;
import org.opendaylight.yangtools.yang.parser.stmt.reactor.StatementContextBase;
import org.opendaylight.yangtools.yang.parser.stmt.rfc6020.effective.AugmentEffectiveStatementImpl;
import org.slf4j.Logger;
private static final Pattern PATH_REL_PATTERN1 = Pattern.compile("\\.\\.?\\s*/(.+)");
private static final Pattern PATH_REL_PATTERN2 = Pattern.compile("//.*");
private static final SubstatementValidator SUBSTATEMENT_VALIDATOR = SubstatementValidator
- .builder(Rfc6020Mapping.AUGMENT)
- .addAny(Rfc6020Mapping.ANYXML)
- .addAny(Rfc6020Mapping.CASE)
- .addAny(Rfc6020Mapping.CHOICE)
- .addAny(Rfc6020Mapping.CONTAINER)
- .addOptional(Rfc6020Mapping.DESCRIPTION)
- .addAny(Rfc6020Mapping.IF_FEATURE)
- .addAny(Rfc6020Mapping.LEAF)
- .addAny(Rfc6020Mapping.LEAF_LIST)
- .addAny(Rfc6020Mapping.LIST)
- .addOptional(Rfc6020Mapping.REFERENCE)
- .addOptional(Rfc6020Mapping.STATUS)
- .addAny(Rfc6020Mapping.USES)
- .addOptional(Rfc6020Mapping.WHEN)
+ .builder(YangStmtMapping.AUGMENT)
+ .addAny(YangStmtMapping.ANYXML)
+ .addAny(YangStmtMapping.CASE)
+ .addAny(YangStmtMapping.CHOICE)
+ .addAny(YangStmtMapping.CONTAINER)
+ .addOptional(YangStmtMapping.DESCRIPTION)
+ .addAny(YangStmtMapping.IF_FEATURE)
+ .addAny(YangStmtMapping.LEAF)
+ .addAny(YangStmtMapping.LEAF_LIST)
+ .addAny(YangStmtMapping.LIST)
+ .addOptional(YangStmtMapping.REFERENCE)
+ .addOptional(YangStmtMapping.STATUS)
+ .addAny(YangStmtMapping.USES)
+ .addOptional(YangStmtMapping.WHEN)
.build();
protected AugmentStatementImpl(final StmtContext<SchemaNodeIdentifier, AugmentStatement, ?> context) {
AbstractStatementSupport<SchemaNodeIdentifier, AugmentStatement, EffectiveStatement<SchemaNodeIdentifier, AugmentStatement>> {
public Definition() {
- super(Rfc6020Mapping.AUGMENT);
+ super(YangStmtMapping.AUGMENT);
}
@Override
public SchemaNodeIdentifier parseArgumentValue(final StmtContext<?, ?, ?> ctx, final String value) {
- Preconditions.checkArgument(!PATH_REL_PATTERN1.matcher(value).matches()
- && !PATH_REL_PATTERN2.matcher(value).matches(),
- "An argument for augment can be only absolute path; or descendant if used in uses");
+ SourceException.throwIf(PATH_REL_PATTERN1.matcher(value).matches()
+ || PATH_REL_PATTERN2.matcher(value).matches(), ctx.getStatementSourceReference(),
+ "Augment argument \'%s\' is not valid, it can be only absolute path; or descendant if used in uses",
+ value);
return Utils.nodeIdentifierFromPath(ctx, value);
}
@Override
public void onFullDefinitionDeclared(
- final StmtContext.Mutable<SchemaNodeIdentifier, AugmentStatement, EffectiveStatement<SchemaNodeIdentifier, AugmentStatement>> augmentNode) {
- if (!StmtContextUtils.areFeaturesSupported(augmentNode)) {
+ final Mutable<SchemaNodeIdentifier, AugmentStatement, EffectiveStatement<SchemaNodeIdentifier, AugmentStatement>> augmentNode) {
+ if (!augmentNode.isSupportedByFeatures()) {
return;
}
- SUBSTATEMENT_VALIDATOR.validate(augmentNode);
+ super.onFullDefinitionDeclared(augmentNode);
if (StmtContextUtils.isInExtensionBody(augmentNode)) {
return;
augmentAction.apply(new ModelActionBuilder.InferenceAction() {
@Override
- public void apply() {
- final StatementContextBase<?, ?, ?> augmentTargetCtx = (StatementContextBase<?, ?, ?>) target.get();
+ public void apply(final ModelActionBuilder.InferenceContext ctx) {
+ final StatementContextBase<?, ?, ?> augmentTargetCtx =
+ (StatementContextBase<?, ?, ?>) target.resolve(ctx);
if (!isSupportedAugmentTarget(augmentTargetCtx)
|| StmtContextUtils.isInExtensionBody(augmentTargetCtx)) {
augmentNode.setIsSupportedToBuildEffective(false);
/**
* Marks case short hand in augment
*/
- if (augmentTargetCtx.getPublicDefinition() == Rfc6020Mapping.CHOICE) {
+ if (augmentTargetCtx.getPublicDefinition() == YangStmtMapping.CHOICE) {
augmentNode.addToNs(AugmentToChoiceNamespace.class, augmentNode, Boolean.TRUE);
}
augmentTargetCtx.addEffectiveSubstatement(augmentSourceCtx);
updateAugmentOrder(augmentSourceCtx);
} catch (final SourceException e) {
- LOG.debug("Failed to add augmentation {} defined at {}",
+ LOG.warn("Failed to add augmentation {} defined at {}",
augmentTargetCtx.getStatementSourceReference(),
augmentSourceCtx.getStatementSourceReference(), e);
}
private void updateAugmentOrder(final StatementContextBase<?, ?, ?> augmentSourceCtx) {
Integer currentOrder = augmentSourceCtx.getFromNamespace(StmtOrderingNamespace.class,
- Rfc6020Mapping.AUGMENT);
+ YangStmtMapping.AUGMENT);
if (currentOrder == null) {
currentOrder = 1;
} else {
}
augmentSourceCtx.setOrder(currentOrder);
- augmentSourceCtx.addToNs(StmtOrderingNamespace.class, Rfc6020Mapping.AUGMENT, currentOrder);
+ augmentSourceCtx.addToNs(StmtOrderingNamespace.class, YangStmtMapping.AUGMENT, currentOrder);
}
@Override
/*
* Do not fail, if it is an uses-augment to an unknown node.
*/
- if (Rfc6020Mapping.USES == augmentNode.getParentContext().getPublicDefinition()) {
+ if (YangStmtMapping.USES == augmentNode.getParentContext().getPublicDefinition()) {
final StatementContextBase<?, ?, ?> targetNode = Utils.findNode(getSearchRoot(augmentNode),
augmentNode.getStatementArgument());
- if (Utils.isUnknownNode(targetNode)) {
+ if (StmtContextUtils.isUnknownNode(targetNode)) {
augmentNode.setIsSupportedToBuildEffective(false);
LOG.warn(
"Uses-augment to unknown node {}. Augmentation has not been performed. At line: {}",
private static Mutable<?, ?, ?> getSearchRoot(final Mutable<?, ?, ?> augmentContext) {
final Mutable<?, ?, ?> parent = augmentContext.getParentContext();
// Augment is in uses - we need to augment instantiated nodes in parent.
- if (Rfc6020Mapping.USES == parent.getPublicDefinition()) {
+ if (YangStmtMapping.USES == parent.getPublicDefinition()) {
return parent.getParentContext();
}
return parent;
final CopyType typeOfCopy = UsesStatement.class.equals(sourceCtx.getParentContext().getPublicDefinition()
.getDeclaredRepresentationClass()) ? CopyType.ADDED_BY_USES_AUGMENTATION
: CopyType.ADDED_BY_AUGMENTATION;
+ /*
+ * Since Yang 1.1, if an augmentation is made conditional with a
+ * "when" statement, it is allowed to add mandatory nodes.
+ */
+ final boolean skipCheckOfMandatoryNodes = YangVersion.VERSION_1_1.equals(sourceCtx.getRootVersion())
+ && isConditionalAugmentStmt(sourceCtx);
- final Collection<StatementContextBase<?, ?, ?>> declared = sourceCtx.declaredSubstatements();
- final Collection<StatementContextBase<?, ?, ?>> effective = sourceCtx.effectiveSubstatements();
- final Collection<StatementContextBase<?, ?, ?>> buffer = new ArrayList<>(declared.size() + effective.size());
+ final Collection<? extends Mutable<?, ?, ?>> declared = sourceCtx.mutableDeclaredSubstatements();
+ final Collection<? extends Mutable<?, ?, ?>> effective = sourceCtx.mutableEffectiveSubstatements();
+ final Collection<Mutable<?, ?, ?>> buffer = new ArrayList<>(declared.size() + effective.size());
- for (final StatementContextBase<?, ?, ?> originalStmtCtx : declared) {
- if (StmtContextUtils.areFeaturesSupported(originalStmtCtx)) {
- copyStatement(originalStmtCtx, targetCtx, typeOfCopy, buffer);
+ for (final Mutable<?, ?, ?> originalStmtCtx : declared) {
+ if (originalStmtCtx.isSupportedByFeatures()) {
+ copyStatement(originalStmtCtx, targetCtx, typeOfCopy, buffer, skipCheckOfMandatoryNodes);
}
}
- for (final StatementContextBase<?, ?, ?> originalStmtCtx : effective) {
- copyStatement(originalStmtCtx, targetCtx, typeOfCopy, buffer);
+ for (final Mutable<?, ?, ?> originalStmtCtx : effective) {
+ copyStatement(originalStmtCtx, targetCtx, typeOfCopy, buffer, skipCheckOfMandatoryNodes);
}
targetCtx.addEffectiveSubstatements(buffer);
}
- private static void copyStatement(final StatementContextBase<?, ?, ?> original,
- final StatementContextBase<?, ?, ?> target, final CopyType typeOfCopy,
- final Collection<StatementContextBase<?, ?, ?>> buffer) {
+ /**
+ * Checks whether supplied statement context is conditional augment
+ * statement.
+ *
+ * @param ctx
+ * statement context to be checked
+ *
+ * @return true if supplied statement context is conditional augment
+ * statement, otherwise false
+ */
+ private static boolean isConditionalAugmentStmt(final StmtContext<?, ?, ?> ctx) {
+ return ctx.getPublicDefinition() == YangStmtMapping.AUGMENT
+ && StmtContextUtils.findFirstSubstatement(ctx, WhenStatement.class) != null;
+ }
+
+ private static void copyStatement(final Mutable<?, ?, ?> original, final StatementContextBase<?, ?, ?> target,
+ final CopyType typeOfCopy, final Collection<Mutable<?, ?, ?>> buffer,
+ final boolean skipCheckOfMandatoryNodes) {
if (needToCopyByAugment(original)) {
- validateNodeCanBeCopiedByAugment(original, target, typeOfCopy);
+ validateNodeCanBeCopiedByAugment(original, target, typeOfCopy, skipCheckOfMandatoryNodes);
- final StatementContextBase<?, ?, ?> copy = original.createCopy(target, typeOfCopy);
+ final Mutable<?, ?, ?> copy = original.createCopy(target, typeOfCopy);
buffer.add(copy);
} else if (isReusedByAugment(original)) {
buffer.add(original);
}
}
- private static void validateNodeCanBeCopiedByAugment(final StatementContextBase<?, ?, ?> sourceCtx,
- final StatementContextBase<?, ?, ?> targetCtx, final CopyType typeOfCopy) {
+ private static void validateNodeCanBeCopiedByAugment(final StmtContext<?, ?, ?> sourceCtx,
+ final StatementContextBase<?, ?, ?> targetCtx, final CopyType typeOfCopy,
+ final boolean skipCheckOfMandatoryNodes) {
if (WhenStatement.class.equals(sourceCtx.getPublicDefinition().getDeclaredRepresentationClass())) {
return;
}
- if (typeOfCopy == CopyType.ADDED_BY_AUGMENTATION && reguiredCheckOfMandatoryNodes(sourceCtx, targetCtx)) {
+ if (!skipCheckOfMandatoryNodes && typeOfCopy == CopyType.ADDED_BY_AUGMENTATION
+ && reguiredCheckOfMandatoryNodes(sourceCtx, targetCtx)) {
checkForMandatoryNodes(sourceCtx);
}
- final List<StatementContextBase<?, ?, ?>> targetSubStatements = new Builder<StatementContextBase<?, ?, ?>>()
- .addAll(targetCtx.declaredSubstatements()).addAll(targetCtx.effectiveSubstatements()).build();
-
- for (final StatementContextBase<?, ?, ?> subStatement : targetSubStatements) {
+ final List<Mutable<?, ?, ?>> targetSubStatements = ImmutableList.<Mutable<?, ?, ?>>builder()
+ .addAll(targetCtx.mutableDeclaredSubstatements()).addAll(targetCtx.mutableEffectiveSubstatements())
+ .build();
+ for (final Mutable<?, ?, ?> subStatement : targetSubStatements) {
final boolean sourceIsDataNode = DataDefinitionStatement.class.isAssignableFrom(sourceCtx
.getPublicDefinition().getDeclaredRepresentationClass());
final boolean targetIsDataNode = DataDefinitionStatement.class.isAssignableFrom(subStatement
}
}
- private static void checkForMandatoryNodes(final StatementContextBase<?, ?, ?> sourceCtx) {
+ private static void checkForMandatoryNodes(final StmtContext<?, ?, ?> sourceCtx) {
if (StmtContextUtils.isNonPresenceContainer(sourceCtx)) {
/*
* We need to iterate over both declared and effective sub-statements,
* b) added to augment body also via uses of a grouping and
* such sub-statements are stored in effective sub-statements collection.
*/
- for (final StatementContextBase<?, ?, ?> sourceSubStatement : Iterables.concat(
- sourceCtx.declaredSubstatements(), sourceCtx.declaredSubstatements())) {
- checkForMandatoryNodes(sourceSubStatement);
- }
+ sourceCtx.declaredSubstatements().forEach(Definition::checkForMandatoryNodes);
+ sourceCtx.effectiveSubstatements().forEach(Definition::checkForMandatoryNodes);
}
InferenceException.throwIf(StmtContextUtils.isMandatoryNode(sourceCtx),
sourceCtx.rawStatementArgument());
}
- private static boolean reguiredCheckOfMandatoryNodes(final StatementContextBase<?, ?, ?> sourceCtx,
- StatementContextBase<?, ?, ?> targetCtx) {
+ private static boolean reguiredCheckOfMandatoryNodes(final StmtContext<?, ?, ?> sourceCtx,
+ Mutable<?, ?, ?> targetCtx) {
/*
* If the statement argument is not QName, it cannot be mandatory
* statement, therefore return false and skip mandatory nodes validation
}
final QName sourceStmtQName = (QName) sourceCtx.getStatementArgument();
- final RootStatementContext<?, ?, ?> root = targetCtx.getRoot();
+ // RootStatementContext, for example
+ final Mutable<?, ?, ?> root = targetCtx.getRoot();
do {
Verify.verify(targetCtx.getStatementArgument() instanceof QName,
"Argument of augment target statement must be QName.");
}
/*
- * If target or one of its parent is a presence container from
- * the same module, return false and skip mandatory nodes
- * validation
+ * If target or one of the target's ancestors from the same namespace
+ * is a presence container
+ * or is non-mandatory choice
+ * or is non-mandatory list
+ * return false and skip mandatory nodes validation, because these nodes
+ * are not mandatory node containers according to RFC 6020 section 3.1.
*/
- if (StmtContextUtils.isPresenceContainer(targetCtx)) {
+ if (StmtContextUtils.isPresenceContainer(targetCtx)
+ || StmtContextUtils.isNotMandatoryNodeOfType(targetCtx, YangStmtMapping.CHOICE)
+ || StmtContextUtils.isNotMandatoryNodeOfType(targetCtx, YangStmtMapping.LIST)) {
return false;
}
} while ((targetCtx = targetCtx.getParentContext()) != root);
return false;
}
- private static final Set<Rfc6020Mapping> NOCOPY_DEF_SET = ImmutableSet.of(Rfc6020Mapping.USES, Rfc6020Mapping.WHEN,
- Rfc6020Mapping.DESCRIPTION, Rfc6020Mapping.REFERENCE, Rfc6020Mapping.STATUS);
+ private static final Set<YangStmtMapping> NOCOPY_DEF_SET = ImmutableSet.of(YangStmtMapping.USES, YangStmtMapping.WHEN,
+ YangStmtMapping.DESCRIPTION, YangStmtMapping.REFERENCE, YangStmtMapping.STATUS);
public static boolean needToCopyByAugment(final StmtContext<?, ?, ?> stmtContext) {
return !NOCOPY_DEF_SET.contains(stmtContext.getPublicDefinition());
}
- private static final Set<Rfc6020Mapping> REUSED_DEF_SET = ImmutableSet.of(Rfc6020Mapping.TYPEDEF);
+ private static final Set<YangStmtMapping> REUSED_DEF_SET = ImmutableSet.of(YangStmtMapping.TYPEDEF);
public static boolean isReusedByAugment(final StmtContext<?, ?, ?> stmtContext) {
return REUSED_DEF_SET.contains(stmtContext.getPublicDefinition());
}
- static boolean isSupportedAugmentTarget(final StatementContextBase<?, ?, ?> substatementCtx) {
-
+ static boolean isSupportedAugmentTarget(final StmtContext<?, ?, ?> substatementCtx) {
/*
* :TODO Substatement must be allowed augment target type e.g.
* Container, etc... and must not be for example grouping, identity etc.
* the same QName. We must find the Container and the Grouping must be
* ignored as disallowed augment target.
*/
-
- final Collection<?> allowedAugmentTargets = substatementCtx.getFromNamespace(ValidationBundlesNamespace.class,
- ValidationBundleType.SUPPORTED_AUGMENT_TARGETS);
+ final Collection<?> allowedAugmentTargets = substatementCtx.getFromNamespace(
+ ValidationBundlesNamespace.class, ValidationBundleType.SUPPORTED_AUGMENT_TARGETS);
// if no allowed target is returned we consider all targets allowed
return allowedAugmentTargets == null || allowedAugmentTargets.isEmpty()
|| allowedAugmentTargets.contains(substatementCtx.getPublicDefinition());
}
+ @Override
+ protected SubstatementValidator getSubstatementValidator() {
+ return SUBSTATEMENT_VALIDATOR;
+ }
}
@Nonnull
public Collection<? extends DataDefinitionStatement> getDataDefinitions() {
return allDeclared(DataDefinitionStatement.class);
}
+
+ @Nonnull
+ @Override
+ public Collection<? extends ActionStatement> getActions() {
+ return allDeclared(ActionStatement.class);
+ }
+
+ @Override
+ public final Collection<? extends NotificationStatement> getNotifications() {
+ return allDeclared(NotificationStatement.class);
+ }
}
Code Review / yangtools.git / blobdiff