Merge "Bug 2362: Make sure JSON and XML codecs are not losing constraints."

[yangtools.git] / yang / yang-data-impl / src / main / java / org / opendaylight / yangtools / yang / data / impl / schema / tree / SchemaAwareApplyOperation.java

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 5e0184ef8251582ed3d0fb0f9b08031f78328024..80ef74cf9a3a8b9bcc44e0fdbec3b514237882db 100644 (file)
--- 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
@@ -33,20 +33,20 @@ import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-abstract class SchemaAwareApplyOperation implements ModificationApplyOperation {
+abstract class SchemaAwareApplyOperation extends ModificationApplyOperation {
     private static final Logger LOG = LoggerFactory.getLogger(SchemaAwareApplyOperation.class);
 
     public static SchemaAwareApplyOperation from(final DataSchemaNode schemaNode) {
         if (schemaNode instanceof ContainerSchemaNode) {
-            return new DataNodeContainerModificationStrategy.ContainerModificationStrategy((ContainerSchemaNode) schemaNode);
+            return new ContainerModificationStrategy((ContainerSchemaNode) schemaNode);
         } else if (schemaNode instanceof ListSchemaNode) {
             return fromListSchemaNode((ListSchemaNode) schemaNode);
         } else if (schemaNode instanceof ChoiceSchemaNode) {
-            return new NormalizedNodeContainerModificationStrategy.ChoiceModificationStrategy((ChoiceSchemaNode) schemaNode);
+            return new ChoiceModificationStrategy((ChoiceSchemaNode) schemaNode);
         } else if (schemaNode instanceof LeafListSchemaNode) {
             return fromLeafListSchemaNode((LeafListSchemaNode) schemaNode);
         } else if (schemaNode instanceof LeafSchemaNode) {
-            return new ValueNodeModificationStrategy.LeafModificationStrategy((LeafSchemaNode) schemaNode);
+            return new LeafModificationStrategy((LeafSchemaNode) schemaNode);
         }
         throw new IllegalArgumentException("Not supported schema node type for " + schemaNode.getClass());
     }
@@ -56,7 +56,7 @@ abstract class SchemaAwareApplyOperation implements ModificationApplyOperation {
         for (AugmentationSchema potential : augSchemas.getAvailableAugmentations()) {
             for (DataSchemaNode child : potential.getChildNodes()) {
                 if (identifier.getPossibleChildNames().contains(child.getQName())) {
-                    return new DataNodeContainerModificationStrategy.AugmentationModificationStrategy(potential, resolvedTree);
+                    return new AugmentationModificationStrategy(potential, resolvedTree);
                 }
             }
         }
@@ -77,17 +77,17 @@ abstract class SchemaAwareApplyOperation implements ModificationApplyOperation {
             return new UnkeyedListModificationStrategy(schemaNode);
         }
         if (schemaNode.isUserOrdered()) {
-            return new NormalizedNodeContainerModificationStrategy.OrderedMapModificationStrategy(schemaNode);
+            return new OrderedMapModificationStrategy(schemaNode);
         }
 
-        return new NormalizedNodeContainerModificationStrategy.UnorderedMapModificationStrategy(schemaNode);
+        return new UnorderedMapModificationStrategy(schemaNode);
     }
 
     private static SchemaAwareApplyOperation fromLeafListSchemaNode(final LeafListSchemaNode schemaNode) {
         if(schemaNode.isUserOrdered()) {
-            return new NormalizedNodeContainerModificationStrategy.OrderedLeafSetModificationStrategy(schemaNode);
+            return new OrderedLeafSetModificationStrategy(schemaNode);
         } else {
-            return new NormalizedNodeContainerModificationStrategy.UnorderedLeafSetModificationStrategy(schemaNode);
+            return new UnorderedLeafSetModificationStrategy(schemaNode);
         }
     }
 
@@ -105,32 +105,32 @@ abstract class SchemaAwareApplyOperation implements ModificationApplyOperation {
     }
 
     @Override
-    public void verifyStructure(final ModifiedNode modification) throws IllegalArgumentException {
+    void verifyStructure(final ModifiedNode modification) throws IllegalArgumentException {
         if (modification.getOperation() == LogicalOperation.WRITE) {
             verifyWrittenStructure(modification.getWrittenValue());
         }
     }
 
     @Override
-    public final void checkApplicable(final YangInstanceIdentifier path,final NodeModification modification, final Optional<TreeNode> current) throws DataValidationFailedException {
+    final void checkApplicable(final YangInstanceIdentifier path,final NodeModification modification, final Optional<TreeNode> current) throws DataValidationFailedException {
         switch (modification.getOperation()) {
         case DELETE:
             checkDeleteApplicable(modification, current);
+            break;
         case TOUCH:
-            checkSubtreeModificationApplicable(path, modification, current);
-            return;
+            checkTouchApplicable(path, modification, current);
+            break;
         case WRITE:
             checkWriteApplicable(path, modification, current);
-            return;
+            break;
         case MERGE:
             checkMergeApplicable(path, modification, current);
-            return;
+            break;
         case NONE:
-            return;
+            break;
         default:
-            throw new UnsupportedOperationException("Suplied modification type "+ modification.getOperation()+ "is not supported.");
+            throw new UnsupportedOperationException("Suplied modification type "+ modification.getOperation()+ " is not supported.");
         }
-
     }
 
     protected void checkMergeApplicable(final YangInstanceIdentifier path, final NodeModification modification, final Optional<TreeNode> current) throws DataValidationFailedException {
@@ -177,14 +177,13 @@ abstract class SchemaAwareApplyOperation implements ModificationApplyOperation {
         }
     }
 
-    boolean isOrdered() {
-        return false;
+    @Override
+    protected ChildTrackingPolicy getChildPolicy() {
+        return ChildTrackingPolicy.UNORDERED;
     }
 
     @Override
-    public final Optional<TreeNode> apply(final ModifiedNode modification,
-            final Optional<TreeNode> currentMeta, final Version version) {
-
+    final Optional<TreeNode> apply(final ModifiedNode modification, final Optional<TreeNode> currentMeta, final Version version) {
         switch (modification.getOperation()) {
         case DELETE:
             modification.resolveModificationType(ModificationType.DELETE);
@@ -192,8 +191,7 @@ abstract class SchemaAwareApplyOperation implements ModificationApplyOperation {
         case TOUCH:
             Preconditions.checkArgument(currentMeta.isPresent(), "Metadata not available for modification",
                     modification);
-            modification.resolveModificationType(ModificationType.SUBTREE_MODIFIED);
-            return modification.setSnapshot(Optional.of(applySubtreeChange(modification, currentMeta.get(),
+            return modification.setSnapshot(Optional.of(applyTouch(modification, currentMeta.get(),
                     version)));
         case MERGE:
             final TreeNode result;
@@ -228,14 +226,21 @@ abstract class SchemaAwareApplyOperation implements ModificationApplyOperation {
      * @param version New subtree version of parent node
      * @return A sealed TreeNode representing applied operation.
      */
-    protected abstract TreeNode applyMerge(ModifiedNode modification,
-            TreeNode currentMeta, Version version);
+    protected abstract TreeNode applyMerge(ModifiedNode modification, TreeNode currentMeta, Version version);
 
-    protected abstract TreeNode applyWrite(ModifiedNode modification,
-            Optional<TreeNode> currentMeta, Version version);
+    protected abstract TreeNode applyWrite(ModifiedNode modification, Optional<TreeNode> currentMeta, Version version);
 
-    protected abstract TreeNode applySubtreeChange(ModifiedNode modification,
-            TreeNode currentMeta, Version version);
+    /**
+     * Apply a nested operation. Since there may not actually be a nested operation
+     * to be applied, implementations of this method are responsible for calling
+     * {@link ModifiedNode#resolveModificationType(ModificationType)} as appropriate.
+     *
+     * @param modification Modified node
+     * @param currentMeta Store Metadata Node on which NodeModification should be applied
+     * @param version New subtree version of parent node
+     * @return A sealed TreeNode representing applied operation.
+     */
+    protected abstract TreeNode applyTouch(ModifiedNode modification, TreeNode currentMeta, Version version);
 
     /**
      *
@@ -247,7 +252,7 @@ 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(YangInstanceIdentifier path, final NodeModification modification,
+    protected abstract void checkTouchApplicable(YangInstanceIdentifier path, final NodeModification modification,
             final Optional<TreeNode> current) throws DataValidationFailedException;
 
     protected abstract void verifyWrittenStructure(NormalizedNode<?, ?> writtenValue);