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=aaee9c30d8fb96c27c9ca216d87a09da2861fe16;hb=9e5540fb30986583d69e51f9290dbb651338f4b0;hp=d71ea7930c3c0136c8227e9d6a8aff74f921050c;hpb=28573705736327e87f84931023a28806ac3d60f4;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 d71ea7930c..aaee9c30d8 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 @@ -9,25 +9,20 @@ package org.opendaylight.yangtools.yang.data.impl.schema.tree; import com.google.common.base.Optional; import com.google.common.base.Preconditions; - import java.util.List; - import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier; -import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.AugmentationIdentifier; -import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.NodeIdentifier; -import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier.PathArgument; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.AugmentationIdentifier; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; 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.spi.TreeNode; -import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNodeFactory; import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.Version; import org.opendaylight.yangtools.yang.model.api.AugmentationSchema; import org.opendaylight.yangtools.yang.model.api.AugmentationTarget; -import org.opendaylight.yangtools.yang.model.api.ChoiceNode; +import org.opendaylight.yangtools.yang.model.api.ChoiceSchemaNode; import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode; import org.opendaylight.yangtools.yang.model.api.DataNodeContainer; import org.opendaylight.yangtools.yang.model.api.DataSchemaNode; @@ -45,8 +40,8 @@ abstract class SchemaAwareApplyOperation implements ModificationApplyOperation { return new DataNodeContainerModificationStrategy.ContainerModificationStrategy((ContainerSchemaNode) schemaNode); } else if (schemaNode instanceof ListSchemaNode) { return fromListSchemaNode((ListSchemaNode) schemaNode); - } else if (schemaNode instanceof ChoiceNode) { - return new NormalizedNodeContainerModificationStrategy.ChoiceModificationStrategy((ChoiceNode) schemaNode); + } else if (schemaNode instanceof ChoiceSchemaNode) { + return new NormalizedNodeContainerModificationStrategy.ChoiceModificationStrategy((ChoiceSchemaNode) schemaNode); } else if (schemaNode instanceof LeafListSchemaNode) { return fromLeafListSchemaNode((LeafListSchemaNode) schemaNode); } else if (schemaNode instanceof LeafSchemaNode) { @@ -75,7 +70,7 @@ abstract class SchemaAwareApplyOperation implements ModificationApplyOperation { return null; } - public static boolean checkConflicting(final InstanceIdentifier path, final boolean condition, final String message) throws ConflictingModificationAppliedException { + public static boolean checkConflicting(final YangInstanceIdentifier path, final boolean condition, final String message) throws ConflictingModificationAppliedException { if(!condition) { throw new ConflictingModificationAppliedException(path, message); } @@ -102,7 +97,7 @@ abstract class SchemaAwareApplyOperation implements ModificationApplyOperation { } } - private static final void checkNotConflicting(final InstanceIdentifier path, final TreeNode original, final TreeNode current) throws ConflictingModificationAppliedException { + private static final 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()), @@ -117,17 +112,17 @@ abstract class SchemaAwareApplyOperation implements ModificationApplyOperation { @Override public void verifyStructure(final ModifiedNode modification) throws IllegalArgumentException { - if (modification.getType() == ModificationType.WRITE) { + if (modification.getOperation() == LogicalOperation.WRITE) { verifyWrittenStructure(modification.getWrittenValue()); } } @Override - public final void checkApplicable(final InstanceIdentifier path,final NodeModification modification, final Optional current) throws DataValidationFailedException { - switch (modification.getType()) { + public final void checkApplicable(final YangInstanceIdentifier path,final NodeModification modification, final Optional current) throws DataValidationFailedException { + switch (modification.getOperation()) { case DELETE: checkDeleteApplicable(modification, current); - case SUBTREE_MODIFIED: + case TOUCH: checkSubtreeModificationApplicable(path, modification, current); return; case WRITE: @@ -136,15 +131,15 @@ abstract class SchemaAwareApplyOperation implements ModificationApplyOperation { case MERGE: checkMergeApplicable(path, modification, current); return; - case UNMODIFIED: + case NONE: return; default: - throw new UnsupportedOperationException("Suplied modification type "+ modification.getType()+ "is not supported."); + throw new UnsupportedOperationException("Suplied modification type "+ modification.getOperation()+ "is not supported."); } } - protected void checkMergeApplicable(final InstanceIdentifier path, final NodeModification modification, final Optional current) throws DataValidationFailedException { + protected void checkMergeApplicable(final YangInstanceIdentifier path, final NodeModification modification, final Optional current) throws DataValidationFailedException { Optional original = modification.getOriginal(); if (original.isPresent() && current.isPresent()) { /* @@ -159,12 +154,25 @@ abstract class SchemaAwareApplyOperation implements ModificationApplyOperation { } } - protected void checkWriteApplicable(final InstanceIdentifier path, final NodeModification modification, final Optional current) throws DataValidationFailedException { + /** + * Checks if write operation can be applied to current TreeNode. + * The operation checks if original tree node to which the modification is going to be applied exists and if + * current node in TreeNode structure exists. + * + * @param path Path from current node in TreeNode + * @param modification modification to apply + * @param current current node in TreeNode for modification to apply + * @throws DataValidationFailedException + */ + protected void checkWriteApplicable(final YangInstanceIdentifier path, final NodeModification modification, + final Optional current) throws DataValidationFailedException { 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."); } } @@ -175,26 +183,36 @@ abstract class SchemaAwareApplyOperation implements ModificationApplyOperation { } } + boolean isOrdered() { + return false; + } + @Override public final Optional apply(final ModifiedNode modification, final Optional currentMeta, final Version version) { - switch (modification.getType()) { + switch (modification.getOperation()) { case DELETE: - return modification.storeSnapshot(Optional. absent()); - case SUBTREE_MODIFIED: + return modification.setSnapshot(Optional. absent()); + case TOUCH: Preconditions.checkArgument(currentMeta.isPresent(), "Metadata not available for modification", modification); - return modification.storeSnapshot(Optional.of(applySubtreeChange(modification, currentMeta.get(), + return modification.setSnapshot(Optional.of(applySubtreeChange(modification, currentMeta.get(), version))); case MERGE: - if(currentMeta.isPresent()) { - return modification.storeSnapshot(Optional.of(applyMerge(modification,currentMeta.get(), version))); + final TreeNode result; + + // 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); + } else { + result = applyWrite(modification, currentMeta, version); } - // intentional fall-through: if the node does not exist a merge is same as a write + + return modification.setSnapshot(Optional.of(result)); case WRITE: - return modification.storeSnapshot(Optional.of(applyWrite(modification, currentMeta, version))); - case UNMODIFIED: + return modification.setSnapshot(Optional.of(applyWrite(modification, currentMeta, version))); + case NONE: return currentMeta; default: throw new IllegalArgumentException("Provided modification type is not supported."); @@ -220,59 +238,8 @@ abstract class SchemaAwareApplyOperation implements ModificationApplyOperation { * @throws ConflictingModificationAppliedException If subtree was changed in conflicting way * @throws IncorrectDataStructureException If subtree modification is not applicable (e.g. leaf node). */ - protected abstract void checkSubtreeModificationApplicable(InstanceIdentifier path, final NodeModification modification, + protected abstract void checkSubtreeModificationApplicable(YangInstanceIdentifier path, final NodeModification modification, final Optional current) throws DataValidationFailedException; protected abstract void verifyWrittenStructure(NormalizedNode writtenValue); - - public static class UnkeyedListModificationStrategy extends SchemaAwareApplyOperation { - - private final Optional entryStrategy; - - protected UnkeyedListModificationStrategy(final ListSchemaNode schema) { - entryStrategy = Optional. of(new DataNodeContainerModificationStrategy.UnkeyedListItemModificationStrategy(schema)); - } - - @Override - protected TreeNode applyMerge(final ModifiedNode modification, final TreeNode currentMeta, - final Version version) { - return applyWrite(modification, Optional.of(currentMeta), version); - } - - @Override - protected TreeNode applySubtreeChange(final ModifiedNode modification, - final TreeNode currentMeta, final Version version) { - throw new UnsupportedOperationException("UnkeyedList does not support subtree change."); - } - - @Override - protected TreeNode applyWrite(final ModifiedNode modification, - final Optional currentMeta, final Version version) { - /* - * FIXME: BUG-1258: This is inefficient: it needlessly creates index nodes for the entire subtree. - * We can determine the depth into which metadata need to be created from the modification - * -- if it does not have children, no need to bother with metadata. - */ - return TreeNodeFactory.createTreeNode(modification.getWrittenValue(), version); - } - - @Override - public Optional getChild(final PathArgument child) { - if (child instanceof NodeIdentifier) { - return entryStrategy; - } - return Optional.absent(); - } - - @Override - protected void verifyWrittenStructure(final NormalizedNode writtenValue) { - - } - - @Override - protected void checkSubtreeModificationApplicable(final InstanceIdentifier path, final NodeModification modification, - final Optional current) throws IncorrectDataStructureException { - throw new IncorrectDataStructureException(path, "Subtree modification is not allowed."); - } - } }