package org.opendaylight.yangtools.yang.data.impl.schema.tree;
import com.google.common.base.Optional;
-
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
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.DataValidationFailedException;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.TreeNode;
import org.opendaylight.yangtools.yang.data.api.schema.tree.spi.Version;
* update user did not invoked any operation.
*
*/
-abstract class RootModificationApplyOperation implements ModificationApplyOperation {
+abstract class RootModificationApplyOperation extends ModificationApplyOperation {
@Override
- public Optional<ModificationApplyOperation> getChild(final PathArgument child) {
+ public final Optional<ModificationApplyOperation> getChild(final PathArgument child) {
return getDelegate().getChild(child);
}
@Override
- public final void checkApplicable(final YangInstanceIdentifier path, final NodeModification modification, final Optional<TreeNode> current)
- throws DataValidationFailedException {
- getDelegate().checkApplicable(path, modification, current);
+ final void checkApplicable(final YangInstanceIdentifier path, final NodeModification modification,
+ final Optional<TreeNode> current, final Version version) throws DataValidationFailedException {
+ getDelegate().checkApplicable(path, modification, current, version);
}
@Override
- public final Optional<TreeNode> apply(final ModifiedNode modification, final Optional<TreeNode> currentMeta,
+ final Optional<TreeNode> apply(final ModifiedNode modification, final Optional<TreeNode> currentMeta,
final Version version) {
return getDelegate().apply(modification, currentMeta, version);
}
@Override
- public boolean equals(final Object obj) {
+ public final boolean equals(final Object obj) {
return getDelegate().equals(obj);
}
@Override
- public int hashCode() {
+ public final int hashCode() {
return getDelegate().hashCode();
}
@Override
- public String toString() {
+ public final String toString() {
return getDelegate().toString();
}
@Override
- public void verifyStructure(final ModifiedNode modification) throws IllegalArgumentException {
- getDelegate().verifyStructure(modification);
+ final void verifyStructure(final NormalizedNode<?, ?> modification, final boolean verifyChildren)
+ throws IllegalArgumentException {
+ getDelegate().verifyStructure(modification, verifyChildren);
+ }
+
+ @Override
+ void recursivelyVerifyStructure(NormalizedNode<?, ?> value) {
+ getDelegate().recursivelyVerifyStructure(value);
+ }
+
+ @Override
+ final ChildTrackingPolicy getChildPolicy() {
+ return getDelegate().getChildPolicy();
+ }
+
+ @Override
+ final void mergeIntoModifiedNode(final ModifiedNode node, final NormalizedNode<?, ?> value, final Version version) {
+ getDelegate().mergeIntoModifiedNode(node, value, version);
}
/**
* @return Derived {@link RootModificationApplyOperation} with separate
* upgrade lifecycle.
*/
- public abstract RootModificationApplyOperation snapshot();
+ abstract RootModificationApplyOperation snapshot();
/**
* Upgrades backing implementation to latest available, if possible.
* operation and latest operation is updated by
* {@link LatestOperationHolder#setCurrent(ModificationApplyOperation)}.
*/
- public abstract void upgradeIfPossible();
+ abstract void upgradeIfPossible();
- public static RootModificationApplyOperation from(final ModificationApplyOperation resolver) {
+ static RootModificationApplyOperation from(final ModificationApplyOperation resolver) {
if (resolver instanceof RootModificationApplyOperation) {
return ((RootModificationApplyOperation) resolver).snapshot();
}
- return new NotUpgradable(resolver);
- }
-
- /**
- * Implementation of Upgradable {@link RootModificationApplyOperation}
- *
- * This implementation is associated with {@link LatestOperationHolder}
- * which holds latest available implementation, which may be used for
- * upgrade.
- *
- * Upgrading {@link LatestOperationHolder} will not affect any instance,
- * unless client invoked {@link #upgradeIfPossible()} which will result in
- * changing delegate to the latest one.
- *
- */
- private static final class Upgradable extends RootModificationApplyOperation {
-
- private final LatestOperationHolder holder;
- private ModificationApplyOperation delegate;
-
- public Upgradable(final LatestOperationHolder holder, final ModificationApplyOperation delegate) {
- this.holder = holder;
- this.delegate = delegate;
-
- }
-
- @Override
- public void upgradeIfPossible() {
- ModificationApplyOperation holderCurrent = holder.getCurrent();
- if (holderCurrent != delegate) {
- // FIXME: Allow update only if there is addition of models, not
- // removals.
- delegate = holderCurrent;
- }
-
- }
-
- @Override
- ModificationApplyOperation getDelegate() {
- return delegate;
- }
-
- @Override
- public RootModificationApplyOperation snapshot() {
- return new Upgradable(holder, getDelegate());
- }
-
- }
-
- private static final class NotUpgradable extends RootModificationApplyOperation {
-
- private final ModificationApplyOperation delegate;
-
- public NotUpgradable(final ModificationApplyOperation delegate) {
- this.delegate = delegate;
- }
-
- @Override
- public ModificationApplyOperation getDelegate() {
- return delegate;
- }
-
- @Override
- public void upgradeIfPossible() {
- // Intentional noop
- }
-
- @Override
- public RootModificationApplyOperation snapshot() {
- return this;
- }
- }
-
- /**
- * Holder and factory for upgradable root modifications
- *
- * This class is factory for upgradable root modifications and provides an
- * access to set latest backing implementation.
- *
- */
- static class LatestOperationHolder {
-
- private ModificationApplyOperation current = new AlwaysFailOperation();
-
- /**
- * Return latest backing implemenation
- *
- * @return
- */
- public ModificationApplyOperation getCurrent() {
- return current;
- }
-
- /**
- * Sets latest backing implementation of associated
- * {@link RootModificationApplyOperation}.
- * <p>
- * Note: This does not result in upgrading implementation of already
- * existing {@link RootModificationApplyOperation}. Users, which
- * obtained instances using {@link #newSnapshot()}, deriving
- * {@link RootModificationApplyOperation} from this modification must
- * explicitly invoke
- * {@link RootModificationApplyOperation#upgradeIfPossible()} on their
- * instance to be updated to latest backing implementation.
- *
- * @param newApplyOper
- * New backing implementation
- */
- public void setCurrent(final ModificationApplyOperation newApplyOper) {
- current = newApplyOper;
- }
-
- /**
- *
- * Creates new upgradable {@link RootModificationApplyOperation}
- * associated with holder.
- *
- * @return New upgradable {@link RootModificationApplyOperation} with
- * {@link #getCurrent()} used as backing implementation.
- */
- public RootModificationApplyOperation newSnapshot() {
- return new Upgradable(this, current);
- }
-
+ return new NotUpgradableModificationApplyOperation(resolver);
}
}
Code Review / yangtools.git / blobdiff