Rather than using Class files, use explicit well-known constants.
Change-Id: I999e3a7e32f7743320da5c3a0b42ec136653255e
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
*/
package org.opendaylight.mdsal.binding.util;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.annotations.Beta;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
@Beta
// FIXME Base this on ietf-datastores.yang (RFC 8342)
public abstract sealed class Datastore {
-
- /** Class representing the configuration datastore. */
- public static final Class<Configuration> CONFIGURATION = Configuration.class;
-
- /** Class representing the operational datastore. */
- public static final Class<Operational> OPERATIONAL = Operational.class;
-
+ /**
+ * Class representing the configuration datastore.
+ */
public static final class Configuration extends Datastore {
-
+ private Configuration() {
+ super(LogicalDatastoreType.CONFIGURATION);
+ }
}
+ /**
+ * Class representing the operational datastore.
+ */
public static final class Operational extends Datastore {
-
+ private Operational() {
+ super(LogicalDatastoreType.OPERATIONAL);
+ }
}
- private Datastore() {
- // Hidden on purpose
+ public static final Operational OPERATIONAL = new Operational();
+ public static final Configuration CONFIGURATION = new Configuration();
+
+ private final LogicalDatastoreType type;
+
+ private Datastore(final LogicalDatastoreType type) {
+ this.type = requireNonNull(type);
}
/**
- * Returns the logical datastore type corresponding to the given datastore class.
+ * Returns the logical datastore type corresponding to thisclass.
*
- * @param datastoreClass The datastore class to convert.
* @return The corresponding logical datastore type.
- * @throws IllegalArgumentException if the provided datastore class isn’t handled.
*/
- public static LogicalDatastoreType toType(final Class<? extends Datastore> datastoreClass) {
- if (datastoreClass.equals(Configuration.class)) {
- return LogicalDatastoreType.CONFIGURATION;
- } else if (Operational.class.equals(datastoreClass)) {
- return LogicalDatastoreType.OPERATIONAL;
- } else {
- throw new IllegalArgumentException("Unknown datastore class " + datastoreClass);
- }
+ public LogicalDatastoreType type() {
+ return type;
}
/**
- * Returns the datastore class corresponding to the given logical datastore type.
- * @param datastoreType The logical datastore type to convert.
- * @return The corresponding datastore class.
- * @throws IllegalArgumentException if the provided logical datastore type isn’t handled.
+ * Returns the Datastore corresponding to the given logical datastore type.
+ *
+ * @param type The logical datastore type to convert.
+ * @return The corresponding Datastore
+ * @throws NullPointerException if {@code type} is {@code null}
*/
- public static Class<? extends Datastore> toClass(final LogicalDatastoreType datastoreType) {
- return switch (datastoreType) {
+ public static Datastore ofType(final LogicalDatastoreType type) {
+ return switch (type) {
case CONFIGURATION -> CONFIGURATION;
case OPERATIONAL -> OPERATIONAL;
};
@Override
@CheckReturnValue
public <D extends Datastore, E extends Exception, R> FluentFuture<R> applyWithNewReadWriteTransactionAndSubmit(
- final Class<D> datastoreType,
- final InterruptibleCheckedFunction<TypedReadWriteTransaction<D>, R, E> txFunction) {
- return super.applyWithNewTransactionAndSubmit(datastoreType, getTransactionFactory()::newReadWriteTransaction,
+ final D datastore, final InterruptibleCheckedFunction<TypedReadWriteTransaction<D>, R, E> txFunction) {
+ return super.applyWithNewTransactionAndSubmit(datastore, getTransactionFactory()::newReadWriteTransaction,
WriteTrackingTypedReadWriteTransactionImpl::new, txFunction::apply, this::commit);
}
// This is overridden to use this class’s commit method
@Override
@CheckReturnValue
- public <D extends Datastore, E extends Exception> FluentFuture<? extends Object>
- callWithNewReadWriteTransactionAndSubmit(final Class<D> datastoreType,
+ public <D extends Datastore, E extends Exception>
+ FluentFuture<? extends Object> callWithNewReadWriteTransactionAndSubmit(final D datastore,
final InterruptibleCheckedConsumer<TypedReadWriteTransaction<D>, E> txConsumer) {
- return callWithNewTransactionAndSubmit(datastoreType, getTransactionFactory()::newReadWriteTransaction,
+ return callWithNewTransactionAndSubmit(datastore, getTransactionFactory()::newReadWriteTransaction,
WriteTrackingTypedReadWriteTransactionImpl::new, txConsumer::accept, this::commit);
}
// This is overridden to use this class’s commit method
@Override
@CheckReturnValue
- public <D extends Datastore, E extends Exception> FluentFuture<? extends Object>
- callWithNewWriteOnlyTransactionAndSubmit(final Class<D> datastoreType,
- final InterruptibleCheckedConsumer<TypedWriteTransaction<D>, E> txConsumer) {
- return super.callWithNewTransactionAndSubmit(datastoreType, getTransactionFactory()::newWriteOnlyTransaction,
+ public <D extends Datastore, E extends Exception>
+ FluentFuture<? extends Object> callWithNewWriteOnlyTransactionAndSubmit(final D datastore,
+ final InterruptibleCheckedConsumer<TypedWriteTransaction<D>, E> txConsumer) {
+ return super.callWithNewTransactionAndSubmit(datastore, getTransactionFactory()::newWriteOnlyTransaction,
WriteTrackingTypedWriteTransactionImpl::new, txConsumer::accept, this::commit);
}
* @param <D> datastore type
* @param <E> thrown exception type
* @param <R> result type
- * @param datastoreType the {@link Datastore} type that will be accessed
+ * @param datastore the {@link Datastore} type that will be accessed
* @param txFunction the {@link InterruptibleCheckedFunction} that needs a new read transaction
* @return the result of the function.
* @throws E if an error occurs.
* @throws InterruptedException if the function is interrupted (this is passed through from the provided function).
*/
- <D extends Datastore, E extends Exception, R> R applyInterruptiblyWithNewReadOnlyTransactionAndClose(
- Class<D> datastoreType, InterruptibleCheckedFunction<TypedReadTransaction<D>, R, E> txFunction)
- throws E, InterruptedException;
+ <D extends Datastore, E extends Exception, R> R applyInterruptiblyWithNewReadOnlyTransactionAndClose(D datastore,
+ InterruptibleCheckedFunction<TypedReadTransaction<D>, R, E> txFunction) throws E, InterruptedException;
/**
* Invokes a function with a <b>NEW</b> {@link TypedReadTransaction}, and ensures that that transaction is closed.
* @param <D> datastore type
* @param <E> thrown exception type
* @param <R> result type
- * @param datastoreType the {@link Datastore} type that will be accessed
+ * @param datastore the {@link Datastore} type that will be accessed
* @param txFunction the {@link InterruptibleCheckedFunction} that needs a new read transaction
* @return the result of the function.
* @throws E if an error occurs.
*/
- <D extends Datastore, E extends Exception, R> R applyWithNewReadOnlyTransactionAndClose(Class<D> datastoreType,
+ <D extends Datastore, E extends Exception, R> R applyWithNewReadOnlyTransactionAndClose(D datastore,
CheckedFunction<TypedReadTransaction<D>, R, E> txFunction) throws E;
/**
* @param <D> datastore type
* @param <E> thrown exception type
* @param <R> result type
- * @param datastoreType the {@link Datastore} type that will be accessed
+ * @param datastore the {@link Datastore} type that will be accessed
* @param txFunction the {@link InterruptibleCheckedFunction} that needs a new read-write transaction
* @return the {@link FluentFuture} returned by {@link ReadWriteTransaction#commit()}, or a failed future with an
* application specific exception (not from submit())
*/
@CheckReturnValue
- <D extends Datastore, E extends Exception, R>
- FluentFuture<R> applyWithNewReadWriteTransactionAndSubmit(Class<D> datastoreType,
- InterruptibleCheckedFunction<TypedReadWriteTransaction<D>, R, E> txFunction);
+ <D extends Datastore, E extends Exception, R> FluentFuture<R> applyWithNewReadWriteTransactionAndSubmit(D datastore,
+ InterruptibleCheckedFunction<TypedReadWriteTransaction<D>, R, E> txFunction);
/**
* Invokes a function with a <b>NEW</b> {@link ReadTransaction}, and ensures that that transaction is closed.
*
* @param <D> datastore type
* @param <E> thrown exception type
- * @param datastoreType the {@link Datastore} type that will be accessed
+ * @param datastore the {@link Datastore} type that will be accessed
* @param txConsumer the {@link InterruptibleCheckedFunction} that needs a new read transaction
* @throws E if an error occurs.
* @throws InterruptedException if the function is interrupted (this is passed through from the provided function).
*/
- <D extends Datastore, E extends Exception> void callInterruptiblyWithNewReadOnlyTransactionAndClose(
- Class<D> datastoreType, InterruptibleCheckedConsumer<TypedReadTransaction<D>, E> txConsumer)
- throws E, InterruptedException;
+ <D extends Datastore, E extends Exception> void callInterruptiblyWithNewReadOnlyTransactionAndClose(D datastore,
+ InterruptibleCheckedConsumer<TypedReadTransaction<D>, E> txConsumer) throws E, InterruptedException;
/**
* Invokes a function with a <b>NEW</b> {@link ReadTransaction}, and ensures that that transaction is closed.
*
* @param <D> datastore type
* @param <E> thrown exception type
- * @param datastoreType the {@link Datastore} type that will be accessed
+ * @param datastore the {@link Datastore} type that will be accessed
* @param txConsumer the {@link InterruptibleCheckedFunction} that needs a new read transaction
* @throws E if an error occurs.
*/
- <D extends Datastore, E extends Exception> void callWithNewReadOnlyTransactionAndClose(Class<D> datastoreType,
+ <D extends Datastore, E extends Exception> void callWithNewReadOnlyTransactionAndClose(D datastore,
CheckedConsumer<TypedReadTransaction<D>, E> txConsumer) throws E;
/**
*
* @param <D> datastore type
* @param <E> thrown exception type
- * @param datastoreType the {@link Datastore} type that will be accessed
+ * @param datastore the {@link Datastore} type that will be accessed
* @param txConsumer the {@link InterruptibleCheckedConsumer} that needs a new read-write transaction
* @return the {@link FluentFuture} returned by {@link ReadWriteTransaction#commit()}, or a failed future with an
* application specific exception (not from submit())
*/
@CheckReturnValue
- <D extends Datastore, E extends Exception>
- FluentFuture<? extends Object> callWithNewReadWriteTransactionAndSubmit(Class<D> datastoreType,
- InterruptibleCheckedConsumer<TypedReadWriteTransaction<D>, E> txConsumer);
+ <D extends Datastore, E extends Exception> FluentFuture<? extends Object> callWithNewReadWriteTransactionAndSubmit(
+ D datastore, InterruptibleCheckedConsumer<TypedReadWriteTransaction<D>, E> txConsumer);
/**
* Invokes a consumer with a <b>NEW</b> {@link WriteTransaction}, and then submits that transaction and
* {@link WriteTransaction#cancel()}, or
* {@link WriteTransaction#commit()} (it will throw an {@link UnsupportedOperationException}).
*
- * <p>The provided transaction is specific to the given logical datastore type and cannot be used for any
- * other.
+ * <p>The provided transaction is specific to the given logical datastore type and cannot be used for any other.
*
* <p>This is an asynchronous API, like {@link DataBroker}'s own;
* when returning from this method, the operation of the Transaction may well still be ongoing in the background,
*
* @param <D> datastore type
* @param <E> thrown exception type
- * @param datastoreType the {@link Datastore} type that will be accessed
+ * @param datastore the {@link Datastore} type that will be accessed
* @param txConsumer the {@link InterruptibleCheckedConsumer} that needs a new write only transaction
* @return the {@link FluentFuture} returned by {@link WriteTransaction#commit()}, or a failed future with an
* application specific exception (not from submit())
*/
@CheckReturnValue
- <D extends Datastore, E extends Exception>
- FluentFuture<? extends Object> callWithNewWriteOnlyTransactionAndSubmit(Class<D> datastoreType,
- InterruptibleCheckedConsumer<TypedWriteTransaction<D>, E> txConsumer);
+ <D extends Datastore, E extends Exception> FluentFuture<? extends Object> callWithNewWriteOnlyTransactionAndSubmit(
+ D datastore, InterruptibleCheckedConsumer<TypedWriteTransaction<D>, E> txConsumer);
}
@Override
@SuppressFBWarnings("RCN_REDUNDANT_NULLCHECK_WOULD_HAVE_BEEN_A_NPE")
public <D extends Datastore, E extends Exception, R> R applyInterruptiblyWithNewReadOnlyTransactionAndClose(
- final Class<D> datastoreType, final InterruptibleCheckedFunction<TypedReadTransaction<D>, R, E> txFunction)
+ final D datastore, final InterruptibleCheckedFunction<TypedReadTransaction<D>, R, E> txFunction)
throws E, InterruptedException {
try (ReadTransaction realTx = transactionFactory.newReadOnlyTransaction()) {
- TypedReadTransaction<D>
- wrappedTx = new TypedReadTransactionImpl<>(datastoreType, realTx);
+ TypedReadTransaction<D> wrappedTx = new TypedReadTransactionImpl<>(datastore, realTx);
return txFunction.apply(wrappedTx);
}
}
@Override
@SuppressFBWarnings("RCN_REDUNDANT_NULLCHECK_WOULD_HAVE_BEEN_A_NPE")
- public <D extends Datastore, E extends Exception, R> R applyWithNewReadOnlyTransactionAndClose(
- final Class<D> datastoreType, final CheckedFunction<TypedReadTransaction<D>, R, E> txFunction) throws E {
+ public <D extends Datastore, E extends Exception, R> R applyWithNewReadOnlyTransactionAndClose(final D datastore,
+ final CheckedFunction<TypedReadTransaction<D>, R, E> txFunction) throws E {
try (ReadTransaction realTx = transactionFactory.newReadOnlyTransaction()) {
- TypedReadTransaction<D>
- wrappedTx = new TypedReadTransactionImpl<>(datastoreType, realTx);
+ TypedReadTransaction<D> wrappedTx = new TypedReadTransactionImpl<>(datastore, realTx);
return txFunction.apply(wrappedTx);
}
}
@Override
@CheckReturnValue
- public <D extends Datastore, E extends Exception, R>
- FluentFuture<R> applyWithNewReadWriteTransactionAndSubmit(final Class<D> datastoreType,
- final InterruptibleCheckedFunction<TypedReadWriteTransaction<D>, R, E> txFunction) {
- return applyWithNewTransactionAndSubmit(datastoreType, transactionFactory::newReadWriteTransaction,
+ public <D extends Datastore, E extends Exception, R> FluentFuture<R> applyWithNewReadWriteTransactionAndSubmit(
+ final D datastore, final InterruptibleCheckedFunction<TypedReadWriteTransaction<D>, R, E> txFunction) {
+ return applyWithNewTransactionAndSubmit(datastore, transactionFactory::newReadWriteTransaction,
TypedReadWriteTransactionImpl::new, txFunction, (realTx, wrappedTx) -> realTx.commit());
}
@Override
@SuppressFBWarnings("RCN_REDUNDANT_NULLCHECK_WOULD_HAVE_BEEN_A_NPE")
public <D extends Datastore, E extends Exception> void callInterruptiblyWithNewReadOnlyTransactionAndClose(
- final Class<D> datastoreType, final InterruptibleCheckedConsumer<TypedReadTransaction<D>, E> txConsumer)
+ final D datastore, final InterruptibleCheckedConsumer<TypedReadTransaction<D>, E> txConsumer)
throws E, InterruptedException {
try (ReadTransaction realTx = transactionFactory.newReadOnlyTransaction()) {
- TypedReadTransaction<D> wrappedTx = new TypedReadTransactionImpl<>(datastoreType, realTx);
+ TypedReadTransaction<D> wrappedTx = new TypedReadTransactionImpl<>(datastore, realTx);
txConsumer.accept(wrappedTx);
}
}
@Override
@SuppressFBWarnings("RCN_REDUNDANT_NULLCHECK_WOULD_HAVE_BEEN_A_NPE")
- public <D extends Datastore, E extends Exception> void callWithNewReadOnlyTransactionAndClose(
- final Class<D> datastoreType, final CheckedConsumer<TypedReadTransaction<D>, E> txConsumer) throws E {
+ public <D extends Datastore, E extends Exception> void callWithNewReadOnlyTransactionAndClose(final D datastore,
+ final CheckedConsumer<TypedReadTransaction<D>, E> txConsumer) throws E {
try (ReadTransaction realTx = transactionFactory.newReadOnlyTransaction()) {
- TypedReadTransaction<D> wrappedTx = new TypedReadTransactionImpl<>(datastoreType, realTx);
+ TypedReadTransaction<D> wrappedTx = new TypedReadTransactionImpl<>(datastore, realTx);
txConsumer.accept(wrappedTx);
}
}
@Override
@CheckReturnValue
public <D extends Datastore, E extends Exception>
- FluentFuture<? extends Object> callWithNewReadWriteTransactionAndSubmit(final Class<D> datastoreType,
+ FluentFuture<? extends Object> callWithNewReadWriteTransactionAndSubmit(final D datastore,
final InterruptibleCheckedConsumer<TypedReadWriteTransaction<D>, E> txConsumer) {
- return callWithNewTransactionAndSubmit(datastoreType, transactionFactory::newReadWriteTransaction,
+ return callWithNewTransactionAndSubmit(datastore, transactionFactory::newReadWriteTransaction,
TypedReadWriteTransactionImpl::new, txConsumer, (realTx, wrappedTx) -> realTx.commit());
}
@Override
@CheckReturnValue
- public <D extends Datastore, E extends Exception> FluentFuture<? extends Object>
- callWithNewWriteOnlyTransactionAndSubmit(final Class<D> datastoreType,
- final InterruptibleCheckedConsumer<TypedWriteTransaction<D>, E> txConsumer) {
- return callWithNewTransactionAndSubmit(datastoreType, transactionFactory::newWriteOnlyTransaction,
+ public <D extends Datastore, E extends Exception>
+ FluentFuture<? extends Object> callWithNewWriteOnlyTransactionAndSubmit(final D datastore,
+ final InterruptibleCheckedConsumer<TypedWriteTransaction<D>, E> txConsumer) {
+ return callWithNewTransactionAndSubmit(datastore, transactionFactory::newWriteOnlyTransaction,
TypedWriteTransactionImpl::new, txConsumer, (realTx, wrappedTx) -> realTx.commit());
}
@CheckReturnValue
- protected <D extends Datastore, X extends WriteTransaction, W, E extends Exception> FluentFuture<? extends Object>
- callWithNewTransactionAndSubmit(
- final Class<D> datastoreType, final Supplier<X> txSupplier, final BiFunction<Class<D>, X, W> txWrapper,
- final InterruptibleCheckedConsumer<W, E> txConsumer, final BiFunction<X, W, FluentFuture<?>> txSubmitter) {
- return applyWithNewTransactionAndSubmit(datastoreType, txSupplier, txWrapper, tx -> {
+ protected <D extends Datastore, X extends WriteTransaction, W, E extends Exception>
+ FluentFuture<? extends Object> callWithNewTransactionAndSubmit(final D datastore, final Supplier<X> txSupplier,
+ final BiFunction<D, X, W> txWrapper, final InterruptibleCheckedConsumer<W, E> txConsumer,
+ final BiFunction<X, W, FluentFuture<?>> txSubmitter) {
+ return applyWithNewTransactionAndSubmit(datastore, txSupplier, txWrapper, tx -> {
txConsumer.accept(tx);
return null;
}, txSubmitter);
@CheckReturnValue
@SuppressWarnings("checkstyle:IllegalCatch")
- protected <D extends Datastore, X extends WriteTransaction, W, R, E extends Exception> FluentFuture<R>
- applyWithNewTransactionAndSubmit(
- final Class<D> datastoreType, final Supplier<X> txSupplier, final BiFunction<Class<D>, X, W> txWrapper,
- final InterruptibleCheckedFunction<W, R, E> txFunction,
+ protected <D extends Datastore, X extends WriteTransaction, W, R, E extends Exception>
+ FluentFuture<R> applyWithNewTransactionAndSubmit(final D datastore, final Supplier<X> txSupplier,
+ final BiFunction<D, X, W> txWrapper, final InterruptibleCheckedFunction<W, R, E> txFunction,
final BiFunction<X, W, FluentFuture<?>> txSubmitter) {
X realTx = txSupplier.get();
- W wrappedTx = txWrapper.apply(datastoreType, realTx);
+ W wrappedTx = txWrapper.apply(datastore, realTx);
R result;
try {
// We must store the result before submitting the transaction; if we inline the next line in the
private final Executor executor;
- RetryingManagedNewTransactionRunnerImpl(ManagedNewTransactionRunner delegate) {
+ RetryingManagedNewTransactionRunnerImpl(final ManagedNewTransactionRunner delegate) {
this(delegate, MoreExecutors.directExecutor(), DEFAULT_RETRIES);
}
- RetryingManagedNewTransactionRunnerImpl(ManagedNewTransactionRunner delegate, int maxRetries) {
+ RetryingManagedNewTransactionRunnerImpl(final ManagedNewTransactionRunner delegate, final int maxRetries) {
this(delegate, MoreExecutors.directExecutor(), maxRetries);
}
- RetryingManagedNewTransactionRunnerImpl(ManagedNewTransactionRunner delegate, Executor executor, int maxRetries) {
+ RetryingManagedNewTransactionRunnerImpl(final ManagedNewTransactionRunner delegate, final Executor executor,
+ final int maxRetries) {
this.delegate = requireNonNull(delegate, "delegate must not be null");
this.executor = requireNonNull(executor, "executor must not be null");
this.maxRetries = maxRetries;
@Override
public <D extends Datastore, E extends Exception, R> R applyInterruptiblyWithNewReadOnlyTransactionAndClose(
- Class<D> datastoreType, InterruptibleCheckedFunction<TypedReadTransaction<D>, R, E> txFunction)
+ final D datastore, final InterruptibleCheckedFunction<TypedReadTransaction<D>, R, E> txFunction)
throws E, InterruptedException {
- return applyInterruptiblyWithNewReadOnlyTransactionAndClose(datastoreType, txFunction, maxRetries);
+ return applyInterruptiblyWithNewReadOnlyTransactionAndClose(datastore, txFunction, maxRetries);
}
@SuppressWarnings("checkstyle:IllegalCatch")
private <R, D extends Datastore, E extends Exception> R applyInterruptiblyWithNewReadOnlyTransactionAndClose(
- Class<D> datastoreType, InterruptibleCheckedFunction<TypedReadTransaction<D>, R, E> txFunction,
- int tries) throws E, InterruptedException {
+ final D datastore, final InterruptibleCheckedFunction<TypedReadTransaction<D>, R, E> txFunction,
+ final int tries) throws E, InterruptedException {
try {
- return delegate.applyInterruptiblyWithNewReadOnlyTransactionAndClose(datastoreType, txFunction);
+ return delegate.applyInterruptiblyWithNewReadOnlyTransactionAndClose(datastore, txFunction);
} catch (Exception e) {
if (isRetriableException(e) && tries - 1 > 0) {
- return applyInterruptiblyWithNewReadOnlyTransactionAndClose(datastoreType, txFunction, tries - 1);
+ return applyInterruptiblyWithNewReadOnlyTransactionAndClose(datastore, txFunction, tries - 1);
} else {
throw e;
}
}
@Override
- public <D extends Datastore, E extends Exception, R> R applyWithNewReadOnlyTransactionAndClose(
- Class<D> datastoreType, CheckedFunction<TypedReadTransaction<D>, R, E> txFunction) throws E {
- return applyWithNewReadOnlyTransactionAndClose(datastoreType, txFunction, maxRetries);
+ public <D extends Datastore, E extends Exception, R> R applyWithNewReadOnlyTransactionAndClose(final D datastore,
+ final CheckedFunction<TypedReadTransaction<D>, R, E> txFunction) throws E {
+ return applyWithNewReadOnlyTransactionAndClose(datastore, txFunction, maxRetries);
}
@SuppressWarnings("checkstyle:IllegalCatch")
- private <R, D extends Datastore, E extends Exception> R applyWithNewReadOnlyTransactionAndClose(
- Class<D> datastoreType, CheckedFunction<TypedReadTransaction<D>, R, E> txFunction, int tries) throws E {
+ private <R, D extends Datastore, E extends Exception> R applyWithNewReadOnlyTransactionAndClose(final D datastore,
+ final CheckedFunction<TypedReadTransaction<D>, R, E> txFunction, final int tries) throws E {
try {
- return delegate.applyWithNewReadOnlyTransactionAndClose(datastoreType, txFunction);
+ return delegate.applyWithNewReadOnlyTransactionAndClose(datastore, txFunction);
} catch (Exception e) {
if (isRetriableException(e) && tries - 1 > 0) {
- return applyWithNewReadOnlyTransactionAndClose(datastoreType, txFunction, tries - 1);
+ return applyWithNewReadOnlyTransactionAndClose(datastore, txFunction, tries - 1);
} else {
throw e;
}
@Override
public <D extends Datastore, E extends Exception, R> FluentFuture<R> applyWithNewReadWriteTransactionAndSubmit(
- Class<D> datastoreType, InterruptibleCheckedFunction<TypedReadWriteTransaction<D>, R, E> txFunction) {
- return applyWithNewReadWriteTransactionAndSubmit(datastoreType, txFunction, maxRetries);
+ final D datastore, final InterruptibleCheckedFunction<TypedReadWriteTransaction<D>, R, E> txFunction) {
+ return applyWithNewReadWriteTransactionAndSubmit(datastore, txFunction, maxRetries);
}
private <D extends Datastore, E extends Exception, R> FluentFuture<R> applyWithNewReadWriteTransactionAndSubmit(
- Class<D> datastoreType, InterruptibleCheckedFunction<TypedReadWriteTransaction<D>, R, E> txRunner,
- int tries) {
+ final D datastore, final InterruptibleCheckedFunction<TypedReadWriteTransaction<D>, R, E> txRunner,
+ final int tries) {
FluentFuture<R> future = requireNonNull(
- delegate.applyWithNewReadWriteTransactionAndSubmit(datastoreType, txRunner),
+ delegate.applyWithNewReadWriteTransactionAndSubmit(datastore, txRunner),
"delegate.callWithNewReadWriteTransactionAndSubmit() == null");
return future.catchingAsync(Exception.class, exception -> {
if (isRetriableException(exception) && tries - 1 > 0) {
- return applyWithNewReadWriteTransactionAndSubmit(datastoreType, txRunner, tries - 1);
+ return applyWithNewReadWriteTransactionAndSubmit(datastore, txRunner, tries - 1);
} else {
throw exception;
}
}
@Override
- public <R> R applyWithNewTransactionChainAndClose(Function<ManagedTransactionChain, R> chainConsumer) {
+ public <R> R applyWithNewTransactionChainAndClose(final Function<ManagedTransactionChain, R> chainConsumer) {
throw new UnsupportedOperationException("The retrying transaction manager doesn't support transaction chains");
}
@Override
public <D extends Datastore, E extends Exception> void callInterruptiblyWithNewReadOnlyTransactionAndClose(
- Class<D> datastoreType, InterruptibleCheckedConsumer<TypedReadTransaction<D>, E> txConsumer)
+ final D datastore, final InterruptibleCheckedConsumer<TypedReadTransaction<D>, E> txConsumer)
throws E, InterruptedException {
- callInterruptiblyWithNewReadOnlyTransactionAndClose(datastoreType, txConsumer, maxRetries);
+ callInterruptiblyWithNewReadOnlyTransactionAndClose(datastore, txConsumer, maxRetries);
}
@SuppressWarnings("checkstyle:IllegalCatch")
private <D extends Datastore, E extends Exception> void callInterruptiblyWithNewReadOnlyTransactionAndClose(
- Class<D> datastoreType, InterruptibleCheckedConsumer<TypedReadTransaction<D>, E> txConsumer, int tries)
- throws E, InterruptedException {
+ final D datastore, final InterruptibleCheckedConsumer<TypedReadTransaction<D>, E> txConsumer,
+ final int tries) throws E, InterruptedException {
try {
- delegate.callInterruptiblyWithNewReadOnlyTransactionAndClose(datastoreType, txConsumer);
+ delegate.callInterruptiblyWithNewReadOnlyTransactionAndClose(datastore, txConsumer);
} catch (Exception e) {
if (isRetriableException(e) && tries - 1 > 0) {
- callInterruptiblyWithNewReadOnlyTransactionAndClose(datastoreType, txConsumer, tries - 1);
+ callInterruptiblyWithNewReadOnlyTransactionAndClose(datastore, txConsumer, tries - 1);
} else {
throw e;
}
}
@Override
- public <D extends Datastore, E extends Exception> void callWithNewReadOnlyTransactionAndClose(
- Class<D> datastoreType, CheckedConsumer<TypedReadTransaction<D>, E> txConsumer) throws E {
- callWithNewReadOnlyTransactionAndClose(datastoreType, txConsumer, maxRetries);
+ public <D extends Datastore, E extends Exception> void callWithNewReadOnlyTransactionAndClose(final D datastore,
+ final CheckedConsumer<TypedReadTransaction<D>, E> txConsumer) throws E {
+ callWithNewReadOnlyTransactionAndClose(datastore, txConsumer, maxRetries);
}
@SuppressWarnings("checkstyle:IllegalCatch")
- private <D extends Datastore, E extends Exception> void callWithNewReadOnlyTransactionAndClose(
- Class<D> datastoreType, CheckedConsumer<TypedReadTransaction<D>, E> txConsumer, int tries) throws E {
+ private <D extends Datastore, E extends Exception> void callWithNewReadOnlyTransactionAndClose(final D datastore,
+ final CheckedConsumer<TypedReadTransaction<D>, E> txConsumer, final int tries) throws E {
try {
- delegate.callWithNewReadOnlyTransactionAndClose(datastoreType, txConsumer);
+ delegate.callWithNewReadOnlyTransactionAndClose(datastore, txConsumer);
} catch (Exception e) {
if (isRetriableException(e) && tries - 1 > 0) {
- callWithNewReadOnlyTransactionAndClose(datastoreType, txConsumer, tries - 1);
+ callWithNewReadOnlyTransactionAndClose(datastore, txConsumer, tries - 1);
} else {
throw e;
}
}
@Override
- public <D extends Datastore, E extends Exception> FluentFuture<? extends Object>
- callWithNewReadWriteTransactionAndSubmit(
- Class<D> datastoreType, InterruptibleCheckedConsumer<TypedReadWriteTransaction<D>, E> txConsumer) {
- return callWithNewReadWriteTransactionAndSubmit(datastoreType, txConsumer, maxRetries);
+ public <D extends Datastore, E extends Exception>
+ FluentFuture<? extends Object> callWithNewReadWriteTransactionAndSubmit(final D datastore,
+ final InterruptibleCheckedConsumer<TypedReadWriteTransaction<D>, E> txConsumer) {
+ return callWithNewReadWriteTransactionAndSubmit(datastore, txConsumer, maxRetries);
}
- private <D extends Datastore, E extends Exception, T> FluentFuture<T>
- callWithNewReadWriteTransactionAndSubmit(Class<D> datastoreType,
- InterruptibleCheckedConsumer<TypedReadWriteTransaction<D>, E> txRunner, int tries) {
-
+ private <D extends Datastore, E extends Exception, T> FluentFuture<T> callWithNewReadWriteTransactionAndSubmit(
+ final D datastore, final InterruptibleCheckedConsumer<TypedReadWriteTransaction<D>, E> txRunner,
+ final int tries) {
return (FluentFuture<T>) requireNonNull(
- delegate.callWithNewReadWriteTransactionAndSubmit(datastoreType, txRunner),
+ delegate.callWithNewReadWriteTransactionAndSubmit(datastore, txRunner),
"delegate.callWithNewWriteOnlyTransactionAndSubmit() == null")
.catchingAsync(Exception.class, exception -> {
// as per AsyncWriteTransaction.submit()'s JavaDoc re. retries
if (isRetriableException(exception) && tries - 1 > 0) {
- return callWithNewReadWriteTransactionAndSubmit(datastoreType, txRunner, tries - 1);
+ return callWithNewReadWriteTransactionAndSubmit(datastore, txRunner, tries - 1);
} else {
// out of retries, so propagate the exception
throw exception;
}
@Override
- public <D extends Datastore, E extends Exception> FluentFuture<? extends Object>
- callWithNewWriteOnlyTransactionAndSubmit(Class<D> datastoreType,
- InterruptibleCheckedConsumer<TypedWriteTransaction<D>, E> txConsumer) {
- return callWithNewWriteOnlyTransactionAndSubmit(datastoreType, txConsumer, maxRetries);
+ public <D extends Datastore, E extends Exception>
+ FluentFuture<? extends Object> callWithNewWriteOnlyTransactionAndSubmit(final D datastore,
+ final InterruptibleCheckedConsumer<TypedWriteTransaction<D>, E> txConsumer) {
+ return callWithNewWriteOnlyTransactionAndSubmit(datastore, txConsumer, maxRetries);
}
- private <D extends Datastore, E extends Exception, T> FluentFuture<T>
- callWithNewWriteOnlyTransactionAndSubmit(Class<D> datastoreType,
- InterruptibleCheckedConsumer<TypedWriteTransaction<D>, E> txRunner, int tries) {
-
+ private <D extends Datastore, E extends Exception, T> FluentFuture<T> callWithNewWriteOnlyTransactionAndSubmit(
+ final D datastore, final InterruptibleCheckedConsumer<TypedWriteTransaction<D>, E> txRunner,
+ final int tries) {
return (FluentFuture<T>) requireNonNull(
- delegate.callWithNewWriteOnlyTransactionAndSubmit(datastoreType, txRunner),
+ delegate.callWithNewWriteOnlyTransactionAndSubmit(datastore, txRunner),
"delegate.callWithNewWriteOnlyTransactionAndSubmit() == null")
.catchingAsync(OptimisticLockFailedException.class, optimisticLockFailedException -> {
// as per AsyncWriteTransaction.submit()'s JavaDoc re. retries
if (tries - 1 > 0) {
- return callWithNewWriteOnlyTransactionAndSubmit(datastoreType, txRunner, tries - 1);
+ return callWithNewWriteOnlyTransactionAndSubmit(datastore, txRunner, tries - 1);
} else {
// out of retries, so propagate the OptimisticLockFailedException
throw optimisticLockFailedException;
}, executor);
}
- private boolean isRetriableException(Throwable throwable) {
- return throwable instanceof OptimisticLockFailedException || throwable instanceof ReadFailedException || (
- throwable instanceof ExecutionException && isRetriableException(throwable.getCause()));
+ private boolean isRetriableException(final Throwable throwable) {
+ return throwable instanceof OptimisticLockFailedException || throwable instanceof ReadFailedException
+ || throwable instanceof ExecutionException && isRetriableException(throwable.getCause());
}
}
*/
final class TypedReadTransactionImpl<D extends Datastore> extends TypedTransaction<D, ReadTransaction>
implements TypedReadTransaction<D> {
- TypedReadTransactionImpl(final Class<D> datastoreType, final ReadTransaction realTx) {
- super(datastoreType, realTx);
+ TypedReadTransactionImpl(final D datastore, final ReadTransaction realTx) {
+ super(datastore, realTx);
}
@Override
class TypedReadWriteTransactionImpl<D extends Datastore>
extends TypedWriteTransactionImpl<D, ReadWriteTransaction>
implements TypedReadWriteTransaction<D> {
- TypedReadWriteTransactionImpl(final Class<D> datastoreType, final ReadWriteTransaction realTx) {
- super(datastoreType, realTx);
+ TypedReadWriteTransactionImpl(final D datastore, final ReadWriteTransaction realTx) {
+ super(datastore, realTx);
}
@Override
private final LogicalDatastoreType datastoreType;
private final X delegate;
- TypedTransaction(final Class<D> datastoreType, final X delegate) {
- this.datastoreType = Datastore.toType(datastoreType);
+ TypedTransaction(final D datastore, final X delegate) {
+ this.datastoreType = datastore.type();
this.delegate = delegate;
}
}
final <T extends DataObject> FluentFuture<QueryResult<T>> doExecute(final QueryExpression<T> query) {
- if (delegate instanceof QueryOperations) {
- return ((QueryOperations) delegate).execute(datastoreType, query);
+ if (delegate instanceof QueryOperations queryOps) {
+ return queryOps.execute(datastoreType, query);
}
throw new UnsupportedOperationException("Query execution requires backend support");
}
*/
class TypedWriteTransactionImpl<D extends Datastore, X extends WriteTransaction> extends TypedTransaction<D, X>
implements TypedWriteTransaction<D> {
- TypedWriteTransactionImpl(final Class<D> datastoreType, final X realTx) {
- super(datastoreType, realTx);
+ TypedWriteTransactionImpl(final D datastore, final X realTx) {
+ super(datastore, realTx);
}
@Override
// but the cost here is tiny (one read penalty at the end of a transaction) so we play it safe
private volatile boolean written;
- WriteTrackingTypedReadWriteTransactionImpl(final Class<D> datastoreType, final ReadWriteTransaction realTx) {
- super(datastoreType, realTx);
+ WriteTrackingTypedReadWriteTransactionImpl(final D datastore, final ReadWriteTransaction realTx) {
+ super(datastore, realTx);
}
@Override
// but the cost here is tiny (one read penalty at the end of a transaction) so we play it safe
private volatile boolean written;
- WriteTrackingTypedWriteTransactionImpl(final Class<D> datastoreType, final WriteTransaction realTx) {
- super(datastoreType, realTx);
+ WriteTrackingTypedWriteTransactionImpl(final D datastore, final WriteTransaction realTx) {
+ super(datastore, realTx);
}
@Override
public class DatastoreTest {
@Test
public void testDatastoreToType() {
- assertEquals(LogicalDatastoreType.CONFIGURATION, Datastore.toType(Datastore.CONFIGURATION));
- assertEquals(LogicalDatastoreType.OPERATIONAL, Datastore.toType(Datastore.OPERATIONAL));
- assertThrows(NullPointerException.class, () -> Datastore.toType(null));
+ assertEquals(LogicalDatastoreType.CONFIGURATION, Datastore.CONFIGURATION.type());
+ assertEquals(LogicalDatastoreType.OPERATIONAL, Datastore.OPERATIONAL.type());
}
@Test
public void testDatastoreToClass() {
- assertEquals(Datastore.CONFIGURATION, Datastore.toClass(LogicalDatastoreType.CONFIGURATION));
- assertEquals(Datastore.OPERATIONAL, Datastore.toClass(LogicalDatastoreType.OPERATIONAL));
- assertThrows(NullPointerException.class, () -> Datastore.toClass(null));
+ assertEquals(Datastore.CONFIGURATION, Datastore.ofType(LogicalDatastoreType.CONFIGURATION));
+ assertEquals(Datastore.OPERATIONAL, Datastore.ofType(LogicalDatastoreType.OPERATIONAL));
+ assertThrows(NullPointerException.class, () -> Datastore.ofType(null));
}
}
Code Review / mdsal.git / commitdiff