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=80ef74cf9a3a8b9bcc44e0fdbec3b514237882db;hb=9a63295d0942fbb81837d54bff35a83ec0b0263b;hp=39c164faf1ecc5d3fb6945e42c8f22155c4d8aab;hpb=2719da7f1a121b999310aa1e075872e1a1d8d196;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 39c164faf1..80ef74cf9a 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 @@ -33,41 +33,34 @@ 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()); } public static SchemaAwareApplyOperation from(final DataNodeContainer resolvedTree, final AugmentationTarget augSchemas, final AugmentationIdentifier identifier) { - AugmentationSchema augSchema = null; - - allAugments: - for (AugmentationSchema potential : augSchemas.getAvailableAugmentations()) { - for (DataSchemaNode child : potential.getChildNodes()) { - if (identifier.getPossibleChildNames().contains(child.getQName())) { - augSchema = potential; - break allAugments; - } + for (AugmentationSchema potential : augSchemas.getAvailableAugmentations()) { + for (DataSchemaNode child : potential.getChildNodes()) { + if (identifier.getPossibleChildNames().contains(child.getQName())) { + return new AugmentationModificationStrategy(potential, resolvedTree); } } - - if (augSchema != null) { - return new DataNodeContainerModificationStrategy.AugmentationModificationStrategy(augSchema, resolvedTree); } + return null; } @@ -84,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); } } @@ -112,32 +105,32 @@ abstract class SchemaAwareApplyOperation implements ModificationApplyOperation { } @Override - public void verifyStructure(final ModifiedNode modification) throws IllegalArgumentException { - if (modification.getType() == ModificationType.WRITE) { + 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 current) throws DataValidationFailedException { - switch (modification.getType()) { + 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: - checkSubtreeModificationApplicable(path, modification, current); - return; + break; + case TOUCH: + checkTouchApplicable(path, modification, current); + break; case WRITE: checkWriteApplicable(path, modification, current); - return; + break; case MERGE: checkMergeApplicable(path, modification, current); - return; - case UNMODIFIED: - return; + break; + case NONE: + break; 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 YangInstanceIdentifier path, final NodeModification modification, final Optional current) throws DataValidationFailedException { @@ -184,21 +177,21 @@ abstract class SchemaAwareApplyOperation implements ModificationApplyOperation { } } - boolean isOrdered() { - return false; + @Override + protected ChildTrackingPolicy getChildPolicy() { + return ChildTrackingPolicy.UNORDERED; } @Override - public final Optional apply(final ModifiedNode modification, - final Optional currentMeta, final Version version) { - - switch (modification.getType()) { + final Optional apply(final ModifiedNode modification, final Optional currentMeta, final Version version) { + switch (modification.getOperation()) { case DELETE: + modification.resolveModificationType(ModificationType.DELETE); return modification.setSnapshot(Optional. absent()); - case SUBTREE_MODIFIED: + case TOUCH: Preconditions.checkArgument(currentMeta.isPresent(), "Metadata not available for modification", modification); - return modification.setSnapshot(Optional.of(applySubtreeChange(modification, currentMeta.get(), + return modification.setSnapshot(Optional.of(applyTouch(modification, currentMeta.get(), version))); case MERGE: final TreeNode result; @@ -207,27 +200,47 @@ abstract class SchemaAwareApplyOperation implements ModificationApplyOperation { if (currentMeta.isPresent()) { result = applyMerge(modification,currentMeta.get(), version); } else { + modification.resolveModificationType(ModificationType.WRITE); result = applyWrite(modification, currentMeta, version); } return modification.setSnapshot(Optional.of(result)); case WRITE: + modification.resolveModificationType(ModificationType.WRITE); return modification.setSnapshot(Optional.of(applyWrite(modification, currentMeta, version))); - case UNMODIFIED: + case NONE: + modification.resolveModificationType(ModificationType.UNMODIFIED); return currentMeta; default: throw new IllegalArgumentException("Provided modification type is not supported."); } } - protected abstract TreeNode applyMerge(ModifiedNode modification, - TreeNode currentMeta, Version version); + /** + * Apply a merge operation. Since the result of merge differs based on the data type + * being modified, 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 applyMerge(ModifiedNode modification, TreeNode currentMeta, Version version); - protected abstract TreeNode applyWrite(ModifiedNode modification, - Optional currentMeta, Version version); + protected abstract TreeNode applyWrite(ModifiedNode modification, Optional 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); /** * @@ -239,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 current) throws DataValidationFailedException; protected abstract void verifyWrittenStructure(NormalizedNode writtenValue);