import com.google.common.annotations.Beta;
import com.google.common.base.MoreObjects;
import java.util.Collection;
-import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
-import java.util.function.Function;
+import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.controller.cluster.access.concepts.TransactionIdentifier;
import org.opendaylight.yangtools.concepts.Identifiable;
return local == null ? null : local.values();
}
- final T ensureProxy(final YangInstanceIdentifier path, final Function<Long, T> createProxy) {
- final Map<Long, T> local = getState();
+ final T ensureProxy(final YangInstanceIdentifier path) {
+ final State<T> local = getState();
final Long shard = parent.resolveShardForPath(path);
- return local.computeIfAbsent(shard, createProxy);
+ return local.computeIfAbsent(shard, this::createProxy);
}
final AbstractClientHistory parent() {
return parent;
}
+ abstract @NonNull T createProxy(@NonNull Long shard);
+
private State<T> getState() {
final State<T> local = state;
checkState(local != null, "Transaction %s is closed", transactionId);
super(parent, transactionId);
}
- private AbstractProxyTransaction createProxy(final Long shard) {
- return parent().createSnapshotProxy(getIdentifier(), shard);
- }
-
- private AbstractProxyTransaction ensureSnapshotProxy(final YangInstanceIdentifier path) {
- return ensureProxy(path, this::createProxy);
- }
-
public FluentFuture<Boolean> exists(final YangInstanceIdentifier path) {
return ensureSnapshotProxy(path).exists(path);
}
public FluentFuture<Optional<NormalizedNode<?, ?>>> read(final YangInstanceIdentifier path) {
return ensureSnapshotProxy(path).read(path);
}
+
+ @Override
+ final AbstractProxyTransaction createProxy(final Long shard) {
+ return parent().createSnapshotProxy(getIdentifier(), shard);
+ }
+
+ private AbstractProxyTransaction ensureSnapshotProxy(final YangInstanceIdentifier path) {
+ return ensureProxy(path);
+ }
}
super(parent, transactionId);
}
- private AbstractProxyTransaction createProxy(final Long shard) {
- return parent().createTransactionProxy(getIdentifier(), shard);
- }
-
private AbstractProxyTransaction ensureTransactionProxy(final YangInstanceIdentifier path) {
- return ensureProxy(path, this::createProxy);
+ return ensureProxy(path);
}
public DOMDataTreeWriteCursor openCursor() {
return parent().onTransactionReady(this, cohort);
}
+ @Override
+ final AbstractProxyTransaction createProxy(final Long shard) {
+ return parent().createTransactionProxy(getIdentifier(), shard);
+ }
+
void closeCursor(final @NonNull DOMDataTreeCursor cursorToClose) {
if (cursorToClose.equals(this.cursor)) {
this.cursor = null;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.opendaylight.controller.cluster.databroker.actors.dds.TestUtils.CLIENT_ID;
import static org.opendaylight.controller.cluster.databroker.actors.dds.TestUtils.HISTORY_ID;
import akka.testkit.javadsl.TestKit;
import java.util.Collection;
import java.util.Collections;
-import java.util.function.Function;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
@Test
public void testEnsureProxy() {
- final Function<Long, AbstractProxyTransaction> function = mock(Function.class);
final AbstractProxyTransaction expected = mock(AbstractProxyTransaction.class);
- when(function.apply(0L)).thenReturn(expected);
- final AbstractProxyTransaction proxy = handle.ensureProxy(PATH, function);
- verify(function).apply(0L);
- Assert.assertEquals(expected, proxy);
+ final AbstractProxyTransaction proxy = handle.ensureProxy(PATH);
+ Assert.assertEquals(0, proxy.getIdentifier().getTransactionId());
}
@Test