* instead.
*/
@Deprecated
- <T extends DataObject> void put(@NonNull LogicalDatastoreType store, @NonNull InstanceIdentifier<T> path,
- @NonNull T data, boolean createMissingParents);
+ default <T extends DataObject> void put(@NonNull LogicalDatastoreType store, @NonNull InstanceIdentifier<T> path,
+ @NonNull T data, boolean createMissingParents) {
+ if (createMissingParents) {
+ mergeParentStructurePut(store, path, data);
+ } else {
+ put(store, path, data);
+ }
+ }
/**
* Stores a piece of data at the specified path. This acts as an add / replace operation, which is to say that whole
* @throws IllegalStateException if the transaction has already been submitted
* @throws NullPointerException if any of the arguments is null
*/
- // FIXME: 4.0.0: make this method non-default
// TODO: can we come up with a better name?
@Beta
- default <T extends DataObject> void mergeParentStructurePut(@NonNull final LogicalDatastoreType store,
- @NonNull final InstanceIdentifier<T> path, @NonNull final T data) {
- put(store, path, data, CREATE_MISSING_PARENTS);
- }
+ <T extends DataObject> void mergeParentStructurePut(@NonNull LogicalDatastoreType store,
+ @NonNull InstanceIdentifier<T> path, @NonNull T data);
/**
* Merges a piece of data with the existing data at a specified path. Any pre-existing data which is not explicitly
* instead.
*/
@Deprecated
- <T extends DataObject> void merge(@NonNull LogicalDatastoreType store, @NonNull InstanceIdentifier<T> path,
- @NonNull T data, boolean createMissingParents);
+ default <T extends DataObject> void merge(@NonNull LogicalDatastoreType store, @NonNull InstanceIdentifier<T> path,
+ @NonNull T data, boolean createMissingParents) {
+ if (createMissingParents) {
+ mergeParentStructureMerge(store, path, data);
+ } else {
+ merge(store, path, data);
+ }
+ }
/**
* Merges a piece of data with the existing data at a specified path. Any pre-existing data which is not explicitly
* @throws IllegalStateException if the transaction has already been submitted
* @throws NullPointerException if any of the arguments is null
*/
- // FIXME: 4.0.0: make this method non-default
// TODO: can we come up with a better name?
@Beta
- default <T extends DataObject> void mergeParentStructureMerge(@NonNull final LogicalDatastoreType store,
- @NonNull final InstanceIdentifier<T> path, @NonNull final T data) {
- merge(store, path, data, CREATE_MISSING_PARENTS);
- }
+ <T extends DataObject> void mergeParentStructureMerge(@NonNull LogicalDatastoreType store,
+ @NonNull InstanceIdentifier<T> path, @NonNull T data);
/**
* Removes a piece of data from specified path. This operation does not fail if the specified path does not exist.
+++ /dev/null
-/*
- * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.mdsal.binding.dom.adapter;
-
-import static com.google.common.base.Preconditions.checkArgument;
-
-import com.google.common.util.concurrent.FluentFuture;
-import java.util.Map.Entry;
-import java.util.Optional;
-import org.eclipse.jdt.annotation.NonNull;
-import org.opendaylight.mdsal.common.api.CommitInfo;
-import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
-import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-
-/**
- * Abstract Base Transaction for transactions which are backed by {@link DOMDataTreeWriteTransaction}.
- */
-// FIXME: 4.0.0: hide this class and merge it with BindingDOMWriteTransactionAdapter
-public abstract class AbstractWriteTransaction<T extends DOMDataTreeWriteTransaction> extends
- AbstractForwardedTransaction<T> {
-
- protected AbstractWriteTransaction(final T delegate, final BindingToNormalizedNodeCodec codec) {
- super(delegate, codec);
- }
-
- public final <U extends DataObject> void put(final LogicalDatastoreType store, final InstanceIdentifier<U> path,
- final U data, final boolean createParents) {
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalized = toNormalized("put", path, data);
- if (createParents) {
- ensureParentsByMerge(store, normalized.getKey(), path);
- }
-
- getDelegate().put(store, normalized.getKey(), normalized.getValue());
- }
-
- public final <U extends DataObject> void merge(final LogicalDatastoreType store, final InstanceIdentifier<U> path,
- final U data,final boolean createParents) {
- final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalized = toNormalized("merge", path, data);
- if (createParents) {
- ensureParentsByMerge(store, normalized.getKey(), path);
- }
-
- getDelegate().merge(store, normalized.getKey(), normalized.getValue());
- }
-
- private <U extends DataObject> Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> toNormalized(
- final String operation, final InstanceIdentifier<U> path, final U data) {
- checkArgument(!path.isWildcarded(), "Cannot %s data into wildcarded path %s", operation, path);
- return getCodec().toNormalizedNode(path, data);
- }
-
- /**
- * Use {@link YangInstanceIdentifier#getParent()} instead.
- */
- @Deprecated
- protected static Optional<YangInstanceIdentifier> getParent(final YangInstanceIdentifier child) {
- return Optional.ofNullable(child.getParent());
- }
-
- /**
- * Subclasses of this class are required to implement creation of parent nodes based on behaviour of their
- * underlying transaction.
- *
- * @param store an instance of LogicalDatastoreType
- * @param domPath an instance of YangInstanceIdentifier
- * @param path an instance of InstanceIdentifier
- */
- protected final void ensureParentsByMerge(final LogicalDatastoreType store, final YangInstanceIdentifier domPath,
- final InstanceIdentifier<?> path) {
- final YangInstanceIdentifier parentPath = domPath.getParent();
- if (parentPath != null) {
- final NormalizedNode<?, ?> parentNode = getCodec().instanceIdentifierToNode(parentPath);
- getDelegate().merge(store, YangInstanceIdentifier.create(parentNode.getIdentifier()), parentNode);
- }
- }
-
- protected final void doDelete(final LogicalDatastoreType store, final InstanceIdentifier<?> path) {
- checkArgument(!path.isWildcarded(), "Cannot delete wildcarded path %s", path);
-
- final YangInstanceIdentifier normalized = getCodec().toYangInstanceIdentifierBlocking(path);
- getDelegate().delete(store, normalized);
- }
-
- protected final @NonNull FluentFuture<? extends @NonNull CommitInfo> doCommit() {
- return getDelegate().commit();
- }
-
- protected final boolean doCancel() {
- return getDelegate().cancel();
- }
-}
*/
package org.opendaylight.mdsal.binding.dom.adapter;
+import static com.google.common.base.Preconditions.checkArgument;
+
import com.google.common.util.concurrent.FluentFuture;
+import java.util.Map.Entry;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
+import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
-class BindingDOMWriteTransactionAdapter<T extends DOMDataTreeWriteTransaction> extends AbstractWriteTransaction<T>
+class BindingDOMWriteTransactionAdapter<T extends DOMDataTreeWriteTransaction> extends AbstractForwardedTransaction<T>
implements WriteTransaction {
BindingDOMWriteTransactionAdapter(final T delegateTx, final BindingToNormalizedNodeCodec codec) {
super(delegateTx, codec);
@Override
public final <U extends DataObject> void put(final LogicalDatastoreType store, final InstanceIdentifier<U> path,
final U data) {
- put(store, path, data, false);
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalized = toNormalized("put", path, data);
+ getDelegate().put(store, normalized.getKey(), normalized.getValue());
+ }
+
+ @Override
+ public final <U extends DataObject> void mergeParentStructurePut(@NonNull LogicalDatastoreType store,
+ @NonNull InstanceIdentifier<U> path, @NonNull U data) {
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalized = toNormalized("put",
+ path, data);
+ ensureParentsByMerge(store, normalized.getKey(), path);
+ getDelegate().put(store, normalized.getKey(), normalized.getValue());
}
@Override
public final <D extends DataObject> void merge(final LogicalDatastoreType store, final InstanceIdentifier<D> path,
final D data) {
- merge(store, path, data, false);
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalized = toNormalized("merge", path, data);
+ getDelegate().merge(store, normalized.getKey(), normalized.getValue());
+ }
+
+ @Override
+ public final <U extends DataObject> void mergeParentStructureMerge(@NonNull LogicalDatastoreType store,
+ @NonNull InstanceIdentifier<U> path, @NonNull U data) {
+ final Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> normalized = toNormalized("merge", path, data);
+ ensureParentsByMerge(store, normalized.getKey(), path);
+ getDelegate().merge(store, normalized.getKey(), normalized.getValue());
}
@Override
public final void delete(final LogicalDatastoreType store, final InstanceIdentifier<?> path) {
- doDelete(store, path);
+ checkArgument(!path.isWildcarded(), "Cannot delete wildcarded path %s", path);
+
+ final YangInstanceIdentifier normalized = getCodec().toYangInstanceIdentifierBlocking(path);
+ getDelegate().delete(store, normalized);
}
@Override
public @NonNull FluentFuture<? extends @NonNull CommitInfo> commit() {
- return doCommit();
+ return getDelegate().commit();
}
@Override
public final boolean cancel() {
- return doCancel();
+ return getDelegate().cancel();
+ }
+
+ /**
+ * Subclasses of this class are required to implement creation of parent nodes based on behaviour of their
+ * underlying transaction.
+ *
+ * @param store an instance of LogicalDatastoreType
+ * @param domPath an instance of YangInstanceIdentifier
+ * @param path an instance of InstanceIdentifier
+ */
+ private void ensureParentsByMerge(final LogicalDatastoreType store, final YangInstanceIdentifier domPath,
+ final InstanceIdentifier<?> path) {
+ final YangInstanceIdentifier parentPath = domPath.getParent();
+ if (parentPath != null) {
+ final NormalizedNode<?, ?> parentNode = getCodec().instanceIdentifierToNode(parentPath);
+ getDelegate().merge(store, YangInstanceIdentifier.create(parentNode.getIdentifier()), parentNode);
+ }
+ }
+
+ private <U extends DataObject> Entry<YangInstanceIdentifier, NormalizedNode<?, ?>> toNormalized(
+ final String operation, final InstanceIdentifier<U> path, final U data) {
+ checkArgument(!path.isWildcarded(), "Cannot %s data into wildcarded path %s", operation, path);
+ return getCodec().toNormalizedNode(path, data);
}
}
* {@link #mergeParentStructurePut(InstanceIdentifier, DataObject)} instead.
*/
@Deprecated
- <T extends DataObject> void put(InstanceIdentifier<T> path, T data, boolean createMissingParents);
+ default <T extends DataObject> void put(final InstanceIdentifier<T> path, final T data,
+ final boolean createMissingParents) {
+ if (createMissingParents) {
+ mergeParentStructurePut(path, data);
+ } else {
+ put(path, data);
+ }
+ }
/**
* Writes an object to the given path, creating significant parents, like presence containers and list entries,
*/
// TODO: can we come up with a better name?
@Beta
- @SuppressWarnings("deprecation")
- default <T extends DataObject> void mergeParentStructurePut(final InstanceIdentifier<T> path, final T data) {
- put(path, data, WriteOperations.CREATE_MISSING_PARENTS);
- }
+ <T extends DataObject> void mergeParentStructurePut(InstanceIdentifier<T> path, T data);
/**
* Merges an object with the data already present at the given path.
* {@link #mergeParentStructureMerge(InstanceIdentifier, DataObject)} instead.
*/
@Deprecated
- <T extends DataObject> void merge(InstanceIdentifier<T> path, T data, boolean createMissingParents);
+ default <T extends DataObject> void merge(final InstanceIdentifier<T> path, final T data,
+ final boolean createMissingParents) {
+ if (createMissingParents) {
+ mergeParentStructureMerge(path, data);
+ } else {
+ merge(path, data);
+ }
+ }
/**
* Merges an object with the data already present at the given path, creating missing parents if requested.
* @param data The object to merge.
* @param <T> The type of the provided object.
*/
- // FIXME: 4.0.0: make this method non-default
// TODO: can we come up with a better name?
@Beta
- @SuppressWarnings("deprecation")
- default <T extends DataObject> void mergeParentStructureMerge(final InstanceIdentifier<T> path,
- final T data) {
- merge(path, data, WriteOperations.CREATE_MISSING_PARENTS);
- }
+ <T extends DataObject> void mergeParentStructureMerge(InstanceIdentifier<T> path, T data);
/**
* Deletes the object present at the given path.
Code Review / mdsal.git / commitdiff