package org.opendaylight.mdsal.binding.api;
import com.google.common.util.concurrent.FluentFuture;
+import com.google.common.util.concurrent.MoreExecutors;
import java.util.Optional;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
*
* @param store Logical data store from which read should occur.
* @param path Path which uniquely identifies subtree which client want to read
- * @return a FluentFuture containing the result of the read. The Future blocks until the commit operation is
- * complete. Once complete:
+ * @return a FluentFuture containing the result of the read. The Future blocks until the operation is complete. Once
+ * complete:
* <ul>
* <li>If the data at the supplied path exists, the Future returns an Optional object containing the data.
* </li>
* an exception derived from ReadFailedException.</li>
* </ul>
* @throws NullPointerException if any of the arguments is null
+ * @throws IllegalArgumentException if the path is {@link InstanceIdentifier#isWildcarded()}
*/
<T extends DataObject> @NonNull FluentFuture<Optional<T>> read(@NonNull LogicalDatastoreType store,
@NonNull InstanceIdentifier<T> path);
+
+ /**
+ * Determines if data data exists in the provided logical data store located at the provided path.
+ *
+ * <p>
+ * Default implementation just delegates to {@link #read(LogicalDatastoreType, InstanceIdentifier)}. Implementations
+ * are recommended to override with a more efficient implementation.
+ *
+ * @param store Logical data store from which read should occur.
+ * @param path Path which uniquely identifies subtree which client want to read
+ * @return a FluentFuture containing the result of the check. The Future blocks until the operation is complete.
+ * Once complete:
+ * <ul>
+ * <li>If the data at the supplied path exists, the Future returns {@link Boolean#TRUE}.
+ * </li>
+ * <li>If the data at the supplied path does not exist, the Future returns {@link Boolean#FALSE}.</li>
+ * <li>If the check fails, the Future will fail with a {@link ReadFailedException} or an exception derived
+ * from ReadFailedException.</li>
+ * </ul>
+ * @throws NullPointerException if any of the arguments is null
+ * @throws IllegalArgumentException if the path is {@link InstanceIdentifier#isWildcarded()} and the implementation
+ * does not support evaluating wildcards.
+ */
+ default @NonNull FluentFuture<Boolean> exists(final @NonNull LogicalDatastoreType store,
+ final @NonNull InstanceIdentifier<?> path) {
+ return read(store, path).transform(Optional::isPresent, MoreExecutors.directExecutor());
+ }
}
return codec;
}
- protected final <D extends DataObject> FluentFuture<Optional<D>> doRead(final DOMDataTreeReadOperations readOps,
- final LogicalDatastoreType store, final InstanceIdentifier<D> path) {
+ protected final <D extends DataObject> @NonNull FluentFuture<Optional<D>> doRead(
+ final DOMDataTreeReadOperations readOps, final LogicalDatastoreType store,
+ final InstanceIdentifier<D> path) {
checkArgument(!path.isWildcarded(), "Invalid read of wildcarded path %s", path);
return readOps.read(store, codec.toYangInstanceIdentifierBlocking(path))
.transform(codec.getCodecRegistry().deserializeFunction(path)::apply, MoreExecutors.directExecutor());
}
+
+ protected final @NonNull FluentFuture<Boolean> doExists(final DOMDataTreeReadOperations readOps,
+ final LogicalDatastoreType store, final InstanceIdentifier<?> path) {
+ checkArgument(!path.isWildcarded(), "Invalid exists of wildcarded path %s", path);
+ return readOps.exists(store, codec.toYangInstanceIdentifierBlocking(path));
+ }
}
@Override
public <T extends DataObject> FluentFuture<Optional<T>> read(final LogicalDatastoreType store,
final InstanceIdentifier<T> path) {
- return doRead(getDelegate(),store, path);
+ return doRead(getDelegate(), store, path);
+ }
+
+ @Override
+ public FluentFuture<Boolean> exists(final LogicalDatastoreType store, final InstanceIdentifier<?> path) {
+ return doExists(getDelegate(), store, path);
}
@Override
final InstanceIdentifier<T> path) {
return doRead(getDelegate(), store, path);
}
+
+ @Override
+ public FluentFuture<Boolean> exists(final LogicalDatastoreType store, final InstanceIdentifier<?> path) {
+ return doExists(getDelegate(), store, path);
+ }
}
return delegate.read(store, path);
}
+ @Override
+ public FluentFuture<Boolean> exists(final LogicalDatastoreType store, final InstanceIdentifier<?> path) {
+ return delegate.exists(store, path);
+ }
+
@Override
public void close() {
delegate.close();
return delegate.read(store, path);
}
+ @Override
+ public FluentFuture<Boolean> exists(final LogicalDatastoreType store, final InstanceIdentifier<?> path) {
+ return delegate.exists(store, path);
+ }
+
@Override
public boolean cancel() {
return delegate.cancel();
checkStore(store);
return delegate().read(path);
}
+
+ @Override
+ public FluentFuture<Boolean> exists(final LogicalDatastoreType store,final InstanceIdentifier<?> path) {
+ checkStore(store);
+ return delegate().exists(path);
+ }
}
}
package org.opendaylight.mdsal.binding.util;
import com.google.common.util.concurrent.FluentFuture;
+import com.google.common.util.concurrent.MoreExecutors;
import java.util.Optional;
import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.binding.api.Transaction;
* @return A future providing access to the result of the read, when it’s available, or any error encountered.
*/
<T extends DataObject> FluentFuture<Optional<T>> read(InstanceIdentifier<T> path);
+
+ /**
+ * Determines if an object exists at the given path. Default implementation just delegates to
+ * {@link #read(InstanceIdentifier)}. Implementations are recommended to override with a more efficient
+ * implementation.
+ *
+ * @see ReadTransaction#exists(LogicalDatastoreType, InstanceIdentifier)
+ *
+ * @param path The path to read from.
+ * @return A future providing access to the result of the check, when it’s available, or any error encountered.
+ */
+ default FluentFuture<Boolean> exists(final InstanceIdentifier<?> path) {
+ return read(path).transform(Optional::isPresent, MoreExecutors.directExecutor());
+ }
}
public <T extends DataObject> FluentFuture<Optional<T>> read(final InstanceIdentifier<T> path) {
return delegate().read(getDatastoreType(), path);
}
+
+ @Override
+ public FluentFuture<Boolean> exists(final InstanceIdentifier<?> path) {
+ return delegate().exists(getDatastoreType(), path);
+ }
}
public final <T extends DataObject> FluentFuture<Optional<T>> read(final InstanceIdentifier<T> path) {
return delegate().read(getDatastoreType(), path);
}
+
+ @Override
+ public FluentFuture<Boolean> exists(final InstanceIdentifier<?> path) {
+ return delegate().exists(getDatastoreType(), path);
+ }
}
Code Review / mdsal.git / commitdiff