X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=yang%2Fyang-data-impl%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fyangtools%2Fyang%2Fdata%2Fimpl%2Fschema%2Ftree%2FSchemaAwareApplyOperation.java;h=2ca70603d4cf33db7a5ab2131a326cde8d78d0b5;hb=6b5d20f6513bc3e6e5db4a2058ee81308edaa9c8;hp=1f33b7c7a7e2d4a528421a7343bc40d7c1ad7ff6;hpb=18377991e7595852d84c3e594153640d7eb2774d;p=yangtools.git diff --git a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/SchemaAwareApplyOperation.java b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/SchemaAwareApplyOperation.java index 1f33b7c7a7..2ca70603d4 100644 --- a/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/SchemaAwareApplyOperation.java +++ b/yang/yang-data-impl/src/main/java/org/opendaylight/yangtools/yang/data/impl/schema/tree/SchemaAwareApplyOperation.java @@ -16,7 +16,6 @@ import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.Augmentat import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; import org.opendaylight.yangtools.yang.data.api.schema.tree.ConflictingModificationAppliedException; import org.opendaylight.yangtools.yang.data.api.schema.tree.DataValidationFailedException; -import org.opendaylight.yangtools.yang.data.api.schema.tree.IncorrectDataStructureException; import org.opendaylight.yangtools.yang.data.api.schema.tree.ModificationType; import org.opendaylight.yangtools.yang.data.api.schema.tree.TreeType; import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode; @@ -36,16 +35,17 @@ import org.slf4j.LoggerFactory; abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { private static final Logger LOG = LoggerFactory.getLogger(SchemaAwareApplyOperation.class); - static SchemaAwareApplyOperation from(final ContainerSchemaNode schemaNode, final TreeType treeType) { - return new ContainerModificationStrategy(schemaNode, treeType); - } - - public static SchemaAwareApplyOperation from(final DataSchemaNode schemaNode, final TreeType treeType) { - if(treeType == TreeType.CONFIGURATION) { + public static ModificationApplyOperation from(final DataSchemaNode schemaNode, final TreeType treeType) { + if (treeType == TreeType.CONFIGURATION) { Preconditions.checkArgument(schemaNode.isConfiguration(), "Supplied %s does not belongs to configuration tree.", schemaNode.getPath()); } if (schemaNode instanceof ContainerSchemaNode) { - return new ContainerModificationStrategy((ContainerSchemaNode) schemaNode, treeType); + final ContainerSchemaNode containerSchema = (ContainerSchemaNode) schemaNode; + if (containerSchema.isPresenceContainer()) { + return new PresenceContainerModificationStrategy(containerSchema, treeType); + } else { + return new StructuralContainerModificationStrategy(containerSchema, treeType); + } } else if (schemaNode instanceof ListSchemaNode) { return fromListSchemaNode((ListSchemaNode) schemaNode, treeType); } else if (schemaNode instanceof ChoiceSchemaNode) { @@ -71,11 +71,11 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { return null; } - public static boolean checkConflicting(final YangInstanceIdentifier path, final boolean condition, final String message) throws ConflictingModificationAppliedException { - if(!condition) { + public static void checkConflicting(final YangInstanceIdentifier path, final boolean condition, + final String message) throws ConflictingModificationAppliedException { + if (!condition) { throw new ConflictingModificationAppliedException(path, message); } - return condition; } private static SchemaAwareApplyOperation fromListSchemaNode(final ListSchemaNode schemaNode, final TreeType treeType) { @@ -101,7 +101,7 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { return MinMaxElementsValidation.from(op, schemaNode); } - protected static final void checkNotConflicting(final YangInstanceIdentifier path, final TreeNode original, final TreeNode current) throws ConflictingModificationAppliedException { + protected static void checkNotConflicting(final YangInstanceIdentifier path, final TreeNode original, final TreeNode current) throws ConflictingModificationAppliedException { checkConflicting(path, original.getVersion().equals(current.getVersion()), "Node was replaced by other transaction."); checkConflicting(path, original.getSubtreeVersion().equals(current.getSubtreeVersion()), @@ -115,19 +115,19 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { } @Override - final void checkApplicable(final YangInstanceIdentifier path,final NodeModification modification, final Optional current) throws DataValidationFailedException { + final void checkApplicable(final YangInstanceIdentifier path,final NodeModification modification, final Optional current, final Version version) throws DataValidationFailedException { switch (modification.getOperation()) { case DELETE: checkDeleteApplicable(modification, current); break; case TOUCH: - checkTouchApplicable(path, modification, current); + checkTouchApplicable(path, modification, current, version); break; case WRITE: - checkWriteApplicable(path, modification, current); + checkWriteApplicable(path, modification, current, version); break; case MERGE: - checkMergeApplicable(path, modification, current); + checkMergeApplicable(path, modification, current, version); break; case NONE: break; @@ -136,7 +136,8 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { } } - protected void checkMergeApplicable(final YangInstanceIdentifier path, final NodeModification modification, final Optional current) throws DataValidationFailedException { + protected void checkMergeApplicable(final YangInstanceIdentifier path, final NodeModification modification, + final Optional current, final Version version) throws DataValidationFailedException { final Optional original = modification.getOriginal(); if (original.isPresent() && current.isPresent()) { /* @@ -162,14 +163,14 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { * @throws DataValidationFailedException */ protected void checkWriteApplicable(final YangInstanceIdentifier path, final NodeModification modification, - final Optional current) throws DataValidationFailedException { + final Optional current, final Version version) throws DataValidationFailedException { final Optional original = modification.getOriginal(); if (original.isPresent() && current.isPresent()) { checkNotConflicting(path, original.get(), current.get()); } else if(original.isPresent()) { throw new ConflictingModificationAppliedException(path,"Node was deleted by other transaction."); - } else if(current.isPresent()) { - throw new ConflictingModificationAppliedException(path,"Node was created by other transaction."); + } else if (current.isPresent()) { + throw new ConflictingModificationAppliedException(path, "Node was created by other transaction."); } } @@ -191,7 +192,7 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { case DELETE: // Deletion of a non-existing node is a no-op, report it as such modification.resolveModificationType(currentMeta.isPresent() ? ModificationType.DELETE : ModificationType.UNMODIFIED); - return modification.setSnapshot(Optional. absent()); + return modification.setSnapshot(Optional.absent()); case TOUCH: Preconditions.checkArgument(currentMeta.isPresent(), "Metadata not available for modification %s", modification); @@ -202,7 +203,7 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { // This is a slight optimization: a merge on a non-existing node equals to a write if (currentMeta.isPresent()) { - result = applyMerge(modification,currentMeta.get(), version); + result = applyMerge(modification, currentMeta.get(), version); } else { modification.resolveModificationType(ModificationType.WRITE); result = applyWrite(modification, currentMeta, version); @@ -254,22 +255,21 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation { * @param modification Node modification which should be applied. * @param current Current state of data tree * @throws ConflictingModificationAppliedException If subtree was changed in conflicting way - * @throws IncorrectDataStructureException If subtree modification is not applicable (e.g. leaf node). + * @throws org.opendaylight.yangtools.yang.data.api.schema.tree.IncorrectDataStructureException If subtree + * modification is not applicable (e.g. leaf node). */ - protected abstract void checkTouchApplicable(YangInstanceIdentifier path, final NodeModification modification, - final Optional current) throws DataValidationFailedException; + protected abstract void checkTouchApplicable(YangInstanceIdentifier path, NodeModification modification, + Optional current, Version version) throws DataValidationFailedException; /** - * Checks if supplied schema node belong to specified Data Tree type. + * Checks if supplied schema node belong to specified Data Tree type. All nodes belong to the operational tree, + * nodes in configuration tree are marked as such. * * @param treeType Tree Type * @param node Schema node - * @return + * @return {@code true} if the node matches the tree type, {@code false} otherwise. */ static boolean belongsToTree(final TreeType treeType, final DataSchemaNode node) { - if(treeType == TreeType.CONFIGURATION) { - return node.isConfiguration(); - } - return true; + return treeType == TreeType.OPERATIONAL || node.isConfiguration(); } }