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=a511ddf064b719cb1c0f1320b6da2ec21b98e959;hb=bf405586fc69c3781311cfb8ac19ba93b670ec8d;hp=9ab33e3707930068462158d140c13b071a7049a5;hpb=fbbc1eec9c6f433c454e3e9dea9c7e4b7f4e331d;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 9ab33e3707..a511ddf064 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
@@ -14,11 +14,10 @@ import org.opendaylight.yangtools.yang.common.QName;
 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.TreeType;
 import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
 import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.Version;
 import org.opendaylight.yangtools.yang.model.api.AugmentationSchema;
@@ -36,27 +35,35 @@ import org.slf4j.LoggerFactory;
 abstract class SchemaAwareApplyOperation extends ModificationApplyOperation {
     private static final Logger LOG = LoggerFactory.getLogger(SchemaAwareApplyOperation.class);
 
-    public static SchemaAwareApplyOperation from(final DataSchemaNode schemaNode) {
+    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);
+            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);
+            return fromListSchemaNode((ListSchemaNode) schemaNode, treeType);
         } else if (schemaNode instanceof ChoiceSchemaNode) {
-            return new ChoiceModificationStrategy((ChoiceSchemaNode) schemaNode);
+            return new ChoiceModificationStrategy((ChoiceSchemaNode) schemaNode, treeType);
         } else if (schemaNode instanceof LeafListSchemaNode) {
-            return fromLeafListSchemaNode((LeafListSchemaNode) schemaNode);
+            return fromLeafListSchemaNode((LeafListSchemaNode) schemaNode, treeType);
         } else if (schemaNode instanceof LeafSchemaNode) {
-            return new LeafModificationStrategy((LeafSchemaNode) schemaNode);
+            return new LeafModificationStrategy((LeafSchemaNode) schemaNode, treeType);
         }
         throw new IllegalArgumentException("Not supported schema node type for " + schemaNode.getClass());
     }
 
     public static SchemaAwareApplyOperation from(final DataNodeContainer resolvedTree,
-            final AugmentationTarget augSchemas, final AugmentationIdentifier identifier) {
+            final AugmentationTarget augSchemas, final AugmentationIdentifier identifier, final TreeType treeType) {
         for (final AugmentationSchema potential : augSchemas.getAvailableAugmentations()) {
             for (final DataSchemaNode child : potential.getChildNodes()) {
                 if (identifier.getPossibleChildNames().contains(child.getQName())) {
-                    return new AugmentationModificationStrategy(potential, resolvedTree);
+                    return new AugmentationModificationStrategy(potential, resolvedTree, treeType);
                 }
             }
         }
@@ -71,25 +78,25 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation {
         return condition;
     }
 
-    private static SchemaAwareApplyOperation fromListSchemaNode(final ListSchemaNode schemaNode) {
+    private static SchemaAwareApplyOperation fromListSchemaNode(final ListSchemaNode schemaNode, final TreeType treeType) {
         final List<QName> keyDefinition = schemaNode.getKeyDefinition();
         final SchemaAwareApplyOperation op;
         if (keyDefinition == null || keyDefinition.isEmpty()) {
-            op = new UnkeyedListModificationStrategy(schemaNode);
+            op = new UnkeyedListModificationStrategy(schemaNode, treeType);
         } else if (schemaNode.isUserOrdered()) {
-            op =  new OrderedMapModificationStrategy(schemaNode);
+            op =  new OrderedMapModificationStrategy(schemaNode, treeType);
         } else {
-            op = new UnorderedMapModificationStrategy(schemaNode);
+            op = new UnorderedMapModificationStrategy(schemaNode, treeType);
         }
         return MinMaxElementsValidation.from(op, schemaNode);
     }
 
-    private static SchemaAwareApplyOperation fromLeafListSchemaNode(final LeafListSchemaNode schemaNode) {
+    private static SchemaAwareApplyOperation fromLeafListSchemaNode(final LeafListSchemaNode schemaNode, final TreeType treeType) {
         final SchemaAwareApplyOperation op;
         if(schemaNode.isUserOrdered()) {
-            op =  new OrderedLeafSetModificationStrategy(schemaNode);
+            op =  new OrderedLeafSetModificationStrategy(schemaNode, treeType);
         } else {
-            op = new UnorderedLeafSetModificationStrategy(schemaNode);
+            op = new UnorderedLeafSetModificationStrategy(schemaNode, treeType);
         }
         return MinMaxElementsValidation.from(op, schemaNode);
     }
@@ -107,13 +114,6 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation {
         return potential.get();
     }
 
-    @Override
-    void verifyStructure(final ModifiedNode modification) throws IllegalArgumentException {
-        if (modification.getOperation() == LogicalOperation.WRITE) {
-            verifyWrittenStructure(modification.getWrittenValue());
-        }
-    }
-
     @Override
     final void checkApplicable(final YangInstanceIdentifier path,final NodeModification modification, final Optional<TreeNode> current) throws DataValidationFailedException {
         switch (modification.getOperation()) {
@@ -168,8 +168,8 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation {
             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.");
         }
     }
 
@@ -202,7 +202,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);
@@ -259,5 +259,15 @@ abstract class SchemaAwareApplyOperation extends ModificationApplyOperation {
     protected abstract void checkTouchApplicable(YangInstanceIdentifier path, final NodeModification modification,
             final Optional<TreeNode> current) throws DataValidationFailedException;
 
-    protected abstract void verifyWrittenStructure(NormalizedNode<?, ?> writtenValue);
+    /**
+     * 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
+     */
+    static boolean belongsToTree(final TreeType treeType, final DataSchemaNode node) {
+        return treeType == TreeType.OPERATIONAL || node.isConfiguration();
+    }
 }