import java.util.Deque;
import java.util.Iterator;
import java.util.Optional;
+import java.util.OptionalLong;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
final boolean success = markSealed();
checkState(success, "Proxy %s was already sealed", getIdentifier());
- if (!sealAndSend(Optional.empty())) {
+ if (!sealAndSend(OptionalLong.empty())) {
sealSuccessor();
}
}
}
private void predecessorSealed() {
- if (markSealed() && !sealAndSend(Optional.empty())) {
+ if (markSealed() && !sealAndSend(OptionalLong.empty())) {
sealSuccessor();
}
}
* @param enqueuedTicks Enqueue ticks when this is invoked from replay path.
* @return True if seal operation was successful, false if this proxy has a successor.
*/
- boolean sealAndSend(final Optional<Long> enqueuedTicks) {
+ boolean sealAndSend(final OptionalLong enqueuedTicks) {
return sealState();
}
successor.handleReplayedRemoteRequest(optState.get(), null, enqueuedTicks);
}
if (successor.markSealed()) {
- successor.sealAndSend(Optional.of(enqueuedTicks));
+ successor.sealAndSend(OptionalLong.of(enqueuedTicks));
}
}
}
abstract void handleReplayedRemoteRequest(TransactionRequest<?> request,
@Nullable Consumer<Response<?, ?>> callback, long enqueuedTicks);
- private static IllegalStateException unhandledResponseException(Response<?, ?> resp) {
+ private static IllegalStateException unhandledResponseException(final Response<?, ?> resp) {
return new IllegalStateException("Unhandled response " + resp.getClass());
}
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import java.util.Optional;
+import java.util.OptionalLong;
import java.util.function.Consumer;
import org.opendaylight.controller.cluster.access.client.RequestTimeoutException;
import org.opendaylight.controller.cluster.access.commands.AbortLocalTransactionRequest;
@Override
void doDelete(final YangInstanceIdentifier path) {
- appendModification(new TransactionDelete(path), Optional.empty());
+ appendModification(new TransactionDelete(path), OptionalLong.empty());
}
@Override
void doMerge(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
- appendModification(new TransactionMerge(path, data), Optional.empty());
+ appendModification(new TransactionMerge(path, data), OptionalLong.empty());
}
@Override
void doWrite(final YangInstanceIdentifier path, final NormalizedNode<?, ?> data) {
- appendModification(new TransactionWrite(path, data), Optional.empty());
+ appendModification(new TransactionWrite(path, data), OptionalLong.empty());
}
private <T> FluentFuture<T> sendReadRequest(final AbstractReadTransactionRequest<?> request,
}
private void ensureFlushedBuider() {
- ensureFlushedBuider(Optional.empty());
+ ensureFlushedBuider(OptionalLong.empty());
}
- private void ensureFlushedBuider(final Optional<Long> enqueuedTicks) {
+ private void ensureFlushedBuider(final OptionalLong enqueuedTicks) {
if (builderBusy) {
flushBuilder(enqueuedTicks);
}
}
- private void flushBuilder(final Optional<Long> enqueuedTicks) {
+ private void flushBuilder(final OptionalLong enqueuedTicks) {
final ModifyTransactionRequest request = builder.build();
builderBusy = false;
sendModification(request, enqueuedTicks);
}
- private void sendModification(final TransactionRequest<?> request, final Optional<Long> enqueuedTicks) {
+ private void sendModification(final TransactionRequest<?> request, final OptionalLong enqueuedTicks) {
if (enqueuedTicks.isPresent()) {
- enqueueRequest(request, response -> completeModify(request, response), enqueuedTicks.get().longValue());
+ enqueueRequest(request, response -> completeModify(request, response), enqueuedTicks.getAsLong());
} else {
sendRequest(request, response -> completeModify(request, response));
}
}
private void appendModification(final TransactionModification modification) {
- appendModification(modification, Optional.empty());
+ appendModification(modification, OptionalLong.empty());
}
- private void appendModification(final TransactionModification modification, final Optional<Long> enqueuedTicks) {
+ private void appendModification(final TransactionModification modification, final OptionalLong enqueuedTicks) {
if (operationFailure == null) {
ensureInitializedBuilder();
}
@Override
- boolean sealAndSend(final Optional<Long> enqueuedTicks) {
+ boolean sealAndSend(final OptionalLong enqueuedTicks) {
if (sendReadyOnSeal) {
ensureInitializedBuilder();
builder.setReady();
private void replayLocalCommitRequest(final CommitLocalTransactionRequest request,
final Consumer<Response<?, ?>> callback, final long enqueuedTicks) {
final DataTreeModification mod = request.getModification();
- final Optional<Long> optTicks = Optional.of(Long.valueOf(enqueuedTicks));
+ final OptionalLong optTicks = OptionalLong.of(enqueuedTicks);
mod.applyToCursor(new AbstractDataTreeModificationCursor() {
@Override
void handleReplayedRemoteRequest(final TransactionRequest<?> request, final Consumer<Response<?, ?>> callback,
final long enqueuedTicks) {
final Consumer<Response<?, ?>> cb = callback != null ? callback : resp -> { /* NOOP */ };
- final Optional<Long> optTicks = Optional.of(Long.valueOf(enqueuedTicks));
+ final OptionalLong optTicks = OptionalLong.of(enqueuedTicks);
if (request instanceof ModifyTransactionRequest) {
handleReplayedModifyTransactionRequest(enqueuedTicks, cb, (ModifyTransactionRequest) request);