From: Robert Varga <robert.varga@pantheon.tech>
Date: Mon, 17 Oct 2022 21:02:00 +0000 (+0200)
Subject: Clean up Datastore addressing
X-Git-Tag: v11.0.0~94
X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;h=00bbb3ce2797200977ac56e424e09e4be8641ff1;p=mdsal.git

Clean up Datastore addressing

Rather than using Class files, use explicit well-known constants.

Change-Id: I999e3a7e32f7743320da5c3a0b42ec136653255e
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
---

diff --git a/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/Datastore.java b/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/Datastore.java
index b95ce5c096..740e267a7c 100644
--- a/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/Datastore.java
+++ b/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/Datastore.java
@@ -7,6 +7,8 @@
  */
 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;
 
@@ -16,50 +18,51 @@ 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;
         };
diff --git a/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/ManagedNewTransactionRunnerImpl.java b/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/ManagedNewTransactionRunnerImpl.java
index f061976f01..44ccf73603 100644
--- a/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/ManagedNewTransactionRunnerImpl.java
+++ b/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/ManagedNewTransactionRunnerImpl.java
@@ -46,9 +46,8 @@ public class ManagedNewTransactionRunnerImpl extends ManagedTransactionFactoryIm
     @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);
     }
 
@@ -74,20 +73,20 @@ public class ManagedNewTransactionRunnerImpl extends ManagedTransactionFactoryIm
     // 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);
     }
 
diff --git a/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/ManagedTransactionFactory.java b/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/ManagedTransactionFactory.java
index 76e618a72e..7c65397a5a 100644
--- a/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/ManagedTransactionFactory.java
+++ b/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/ManagedTransactionFactory.java
@@ -41,15 +41,14 @@ public interface ManagedTransactionFactory {
      * @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.
@@ -65,12 +64,12 @@ public interface ManagedTransactionFactory {
      * @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;
 
     /**
@@ -97,15 +96,14 @@ public interface ManagedTransactionFactory {
      * @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.
@@ -120,14 +118,13 @@ public interface ManagedTransactionFactory {
      *
      * @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.
@@ -142,11 +139,11 @@ public interface ManagedTransactionFactory {
      *
      * @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;
 
     /**
@@ -172,15 +169,14 @@ public interface ManagedTransactionFactory {
      *
      * @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
@@ -192,8 +188,7 @@ public interface ManagedTransactionFactory {
      * {@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,
@@ -205,13 +200,12 @@ public interface ManagedTransactionFactory {
      *
      * @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);
 }
diff --git a/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/ManagedTransactionFactoryImpl.java b/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/ManagedTransactionFactoryImpl.java
index db610bd0ea..e9a16ed4b4 100644
--- a/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/ManagedTransactionFactoryImpl.java
+++ b/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/ManagedTransactionFactoryImpl.java
@@ -37,52 +37,49 @@ class ManagedTransactionFactoryImpl<T extends TransactionFactory> implements Man
     @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);
         }
     }
@@ -90,27 +87,27 @@ class ManagedTransactionFactoryImpl<T extends TransactionFactory> implements Man
     @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);
@@ -118,13 +115,12 @@ class ManagedTransactionFactoryImpl<T extends TransactionFactory> implements Man
 
     @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
diff --git a/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/RetryingManagedNewTransactionRunnerImpl.java b/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/RetryingManagedNewTransactionRunnerImpl.java
index 9146a2ce9d..b750a81f46 100644
--- a/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/RetryingManagedNewTransactionRunnerImpl.java
+++ b/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/RetryingManagedNewTransactionRunnerImpl.java
@@ -40,15 +40,16 @@ class RetryingManagedNewTransactionRunnerImpl implements ManagedNewTransactionRu
 
     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;
@@ -56,20 +57,20 @@ class RetryingManagedNewTransactionRunnerImpl implements ManagedNewTransactionRu
 
     @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;
             }
@@ -77,19 +78,19 @@ class RetryingManagedNewTransactionRunnerImpl implements ManagedNewTransactionRu
     }
 
     @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;
             }
@@ -98,19 +99,19 @@ class RetryingManagedNewTransactionRunnerImpl implements ManagedNewTransactionRu
 
     @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;
             }
@@ -118,26 +119,26 @@ class RetryingManagedNewTransactionRunnerImpl implements ManagedNewTransactionRu
     }
 
     @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;
             }
@@ -145,19 +146,19 @@ class RetryingManagedNewTransactionRunnerImpl implements ManagedNewTransactionRu
     }
 
     @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;
             }
@@ -165,23 +166,22 @@ class RetryingManagedNewTransactionRunnerImpl implements ManagedNewTransactionRu
     }
 
     @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;
@@ -190,23 +190,22 @@ class RetryingManagedNewTransactionRunnerImpl implements ManagedNewTransactionRu
     }
 
     @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;
@@ -214,8 +213,8 @@ class RetryingManagedNewTransactionRunnerImpl implements ManagedNewTransactionRu
             }, 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());
     }
 }
diff --git a/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/TypedReadTransactionImpl.java b/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/TypedReadTransactionImpl.java
index 9a440ddf88..c1de38c640 100644
--- a/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/TypedReadTransactionImpl.java
+++ b/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/TypedReadTransactionImpl.java
@@ -22,8 +22,8 @@ import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  */
 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
diff --git a/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/TypedReadWriteTransactionImpl.java b/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/TypedReadWriteTransactionImpl.java
index 39bd29414b..6ceac314d9 100644
--- a/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/TypedReadWriteTransactionImpl.java
+++ b/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/TypedReadWriteTransactionImpl.java
@@ -23,8 +23,8 @@ import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 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
diff --git a/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/TypedTransaction.java b/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/TypedTransaction.java
index 3a0a5d6c70..1496958e78 100644
--- a/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/TypedTransaction.java
+++ b/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/TypedTransaction.java
@@ -20,8 +20,8 @@ abstract class TypedTransaction<D extends Datastore, X extends Transaction> exte
     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;
     }
 
@@ -35,8 +35,8 @@ abstract class TypedTransaction<D extends Datastore, X extends Transaction> exte
     }
 
     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");
     }
diff --git a/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/TypedWriteTransactionImpl.java b/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/TypedWriteTransactionImpl.java
index 77a95088fb..f5fa3e0700 100644
--- a/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/TypedWriteTransactionImpl.java
+++ b/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/TypedWriteTransactionImpl.java
@@ -19,8 +19,8 @@ import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  */
 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
diff --git a/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/WriteTrackingTypedReadWriteTransactionImpl.java b/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/WriteTrackingTypedReadWriteTransactionImpl.java
index 2625133944..cb5e427027 100644
--- a/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/WriteTrackingTypedReadWriteTransactionImpl.java
+++ b/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/WriteTrackingTypedReadWriteTransactionImpl.java
@@ -19,8 +19,8 @@ final class WriteTrackingTypedReadWriteTransactionImpl<D extends Datastore> exte
     // 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
diff --git a/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/WriteTrackingTypedWriteTransactionImpl.java b/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/WriteTrackingTypedWriteTransactionImpl.java
index d1ce3fee77..2141871da6 100644
--- a/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/WriteTrackingTypedWriteTransactionImpl.java
+++ b/binding/mdsal-binding-util/src/main/java/org/opendaylight/mdsal/binding/util/WriteTrackingTypedWriteTransactionImpl.java
@@ -19,8 +19,8 @@ final class WriteTrackingTypedWriteTransactionImpl<D extends Datastore>
     // 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
diff --git a/binding/mdsal-binding-util/src/test/java/org/opendaylight/mdsal/binding/util/DatastoreTest.java b/binding/mdsal-binding-util/src/test/java/org/opendaylight/mdsal/binding/util/DatastoreTest.java
index 1cd953bc30..5d96945b6c 100644
--- a/binding/mdsal-binding-util/src/test/java/org/opendaylight/mdsal/binding/util/DatastoreTest.java
+++ b/binding/mdsal-binding-util/src/test/java/org/opendaylight/mdsal/binding/util/DatastoreTest.java
@@ -16,15 +16,14 @@ import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 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));
     }
 }