Cleanup checkstyle warnings and turn enforcement on in yang-data-impl
[yangtools.git] / yang / yang-data-impl / src / main / java / org / opendaylight / yangtools / yang / data / impl / schema / tree / OperationWithModification.java
1 /*
2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
3  *
4  * This program and the accompanying materials are made available under the
5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6  * and is available at http://www.eclipse.org/legal/epl-v10.html
7  */
8 package org.opendaylight.yangtools.yang.data.impl.schema.tree;
9
10 import com.google.common.base.Optional;
11 import com.google.common.base.Preconditions;
12 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
13 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
14 import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
15 import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.Version;
16
17 final class OperationWithModification {
18     private final ModificationApplyOperation applyOperation;
19     private final ModifiedNode modification;
20
21     private OperationWithModification(final ModificationApplyOperation op, final ModifiedNode mod) {
22         this.applyOperation = Preconditions.checkNotNull(op);
23         this.modification = Preconditions.checkNotNull(mod);
24     }
25
26     void write(final NormalizedNode<?, ?> value) {
27         modification.write(value);
28         /**
29          * Fast validation of structure, full validation on written data will be run during seal.
30          */
31         applyOperation.verifyStructure(value, false);
32     }
33
34     void merge(final NormalizedNode<?, ?> data, final Version version) {
35         /*
36          * A merge operation will end up overwriting parts of the tree, retaining others. We want to
37          * make sure we do not validate the complete resulting structure, but rather just what was
38          * written. In order to do that, we first pretend the data was written, run verification and
39          * then perform the merge -- with the explicit assumption that adding the newly-validated
40          * data with the previously-validated data will not result in invalid data.
41          *
42          * We perform only quick validation here, full validation will be applied as-needed during
43          * preparation, as the merge is reconciled with current state.
44          */
45         applyOperation.verifyStructure(data, false);
46         applyOperation.mergeIntoModifiedNode(modification, data, version);
47     }
48
49     void delete() {
50         modification.delete();
51     }
52
53     /**
54      * Read a particular child. If the child has been modified and does not have a stable
55      * view, one will we instantiated with specified version.
56      */
57     Optional<NormalizedNode<?, ?>> read(final PathArgument child, final Version version) {
58         final Optional<ModifiedNode> maybeChild = modification.getChild(child);
59         if (maybeChild.isPresent()) {
60             final ModifiedNode childNode = maybeChild.get();
61
62             Optional<TreeNode> snapshot = childNode.getSnapshot();
63             if (snapshot == null) {
64                 // Snapshot is not present, force instantiation
65                 snapshot = applyOperation.getChild(child).get().apply(childNode, childNode.getOriginal(), version);
66             }
67
68             return snapshot.transform(TreeNode::getData);
69         }
70
71         Optional<TreeNode> snapshot = modification.getSnapshot();
72         if (snapshot == null) {
73             snapshot = apply(modification.getOriginal(), version);
74         }
75
76         if (snapshot.isPresent()) {
77             return snapshot.get().getChild(child).transform(TreeNode::getData);
78         }
79
80         return Optional.absent();
81     }
82
83     public ModifiedNode getModification() {
84         return modification;
85     }
86
87     public ModificationApplyOperation getApplyOperation() {
88         return applyOperation;
89     }
90
91     public Optional<TreeNode> apply(final Optional<TreeNode> data, final Version version) {
92         return applyOperation.apply(modification, data, version);
93     }
94
95     public static OperationWithModification from(final ModificationApplyOperation operation,
96             final ModifiedNode modification) {
97         return new OperationWithModification(operation, modification);
98     }
99 }