Use instanceof patterns to reduce the number of casts.
Change-Id: I40eb35b3b1afdae30d461a608aeabda2d7e09ce8
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
return;
}
- if (message instanceof ThisActorSystemQuarantinedEvent) {
- final ThisActorSystemQuarantinedEvent event = (ThisActorSystemQuarantinedEvent) message;
+ if (message instanceof ThisActorSystemQuarantinedEvent event) {
LOG.warn("Got quarantined by {}", event.remoteAddress());
quarantined = true;
// execute the callback
callback.apply();
- } else if (message instanceof AssociationErrorEvent) {
+ } else if (message instanceof AssociationErrorEvent event) {
final String errorMessage = message.toString();
LOG.trace("errorMessage:{}", errorMessage);
if (errorMessage.contains("The remote system has a UID that has been quarantined")) {
- final Address address = ((AssociationErrorEvent) message).getRemoteAddress();
+ final Address address = event.getRemoteAddress();
addressSet.add(address);
count++;
LOG.trace("address:{} addressSet: {} count:{}", address, addressSet, count);
if (count >= MESSAGE_THRESHOLD && addressSet.size() > 1) {
count = 0;
addressSet.clear();
- final AssociationErrorEvent event = (AssociationErrorEvent) message;
LOG.warn("Got quarantined via AssociationEvent by {}", event.remoteAddress());
quarantined = true;
count = 0;
addressSet.clear();
}
- } else if (message instanceof ClusterEvent.MemberDowned) {
- final ClusterEvent.MemberDowned event = (ClusterEvent.MemberDowned) message;
+ } else if (message instanceof ClusterEvent.MemberDowned event) {
if (Cluster.get(getContext().system()).selfMember().equals(event.member())) {
LOG.warn("This member has been downed, restarting");
String newParentPath = parentPath + "/" + dataContainerNode.getIdentifier().toString();
- for (NormalizedNode node : dataContainerNode.body()) {
- if (node instanceof MixinNode && node instanceof NormalizedNodeContainer) {
- navigateNormalizedNodeContainerMixin(level, newParentPath, (NormalizedNodeContainer<?>) node);
+ for (var node : dataContainerNode.body()) {
+ if (node instanceof MixinNode && node instanceof NormalizedNodeContainer<?> container) {
+ navigateNormalizedNodeContainerMixin(level, newParentPath, container);
} else {
navigateNormalizedNode(level, newParentPath, node);
}
}
-
}
private void navigateNormalizedNodeContainerMixin(final int level, final String parentPath,
String newParentPath = parentPath + "/" + node.getIdentifier().toString();
- for (NormalizedNode normalizedNode : node.body()) {
- if (normalizedNode instanceof MixinNode && normalizedNode instanceof NormalizedNodeContainer) {
- navigateNormalizedNodeContainerMixin(level + 1, newParentPath,
- (NormalizedNodeContainer<?>) normalizedNode);
+ for (var normalizedNode : node.body()) {
+ if (normalizedNode instanceof MixinNode && normalizedNode instanceof NormalizedNodeContainer<?> container) {
+ navigateNormalizedNodeContainerMixin(level + 1, newParentPath, container);
} else {
navigateNormalizedNode(level, newParentPath, normalizedNode);
}
}
-
}
private void navigateNormalizedNode(final int level, final String parentPath, final NormalizedNode normalizedNode) {
- if (normalizedNode instanceof DataContainerNode) {
- navigateDataContainerNode(level + 1, parentPath, (DataContainerNode) normalizedNode);
+ if (normalizedNode instanceof DataContainerNode dataContainer) {
+ navigateDataContainerNode(level + 1, parentPath, dataContainer);
} else {
visitor.visitNode(level + 1, parentPath, normalizedNode);
}
UINT8 {
@Override
public Object apply(final Object obj) {
- if (obj instanceof Short) {
+ if (obj instanceof Short shortObj) {
LOG.trace("Translating legacy uint8 {}", obj);
- return Uint8.valueOf((Short) obj);
+ return Uint8.valueOf(shortObj);
}
return obj;
}
UINT16 {
@Override
public Object apply(final Object obj) {
- if (obj instanceof Integer) {
+ if (obj instanceof Integer intObj) {
LOG.trace("Translating legacy uint16 {}", obj);
- return Uint16.valueOf((Integer) obj);
+ return Uint16.valueOf(intObj);
}
return obj;
}
UINT32 {
@Override
public Object apply(final Object obj) {
- if (obj instanceof Long) {
+ if (obj instanceof Long longObj) {
LOG.trace("Translating legacy uint32 {}", obj);
- return Uint32.valueOf((Long) obj);
+ return Uint32.valueOf(longObj);
}
return obj;
}
UINT64 {
@Override
public Object apply(final Object obj) {
- if (obj instanceof BigInteger) {
+ if (obj instanceof BigInteger bigInt) {
LOG.trace("Translating legacy uint64 {}", obj);
- return Uint64.valueOf((BigInteger) obj);
+ return Uint64.valueOf(bigInt);
}
return obj;
}
private void adaptEntry(final ReusableImmutableNormalizedNodeStreamWriter writer, final NodeWithValue<?> name) {
final NodeWithValue<?> adapted;
final DataSchemaNode schema = currentSchema().getDataSchemaNode();
- if (schema instanceof TypedDataSchemaNode) {
+ if (schema instanceof TypedDataSchemaNode typed) {
final Object oldValue = name.getValue();
- final Object newValue = adaptValue(((TypedDataSchemaNode) schema).getType(), oldValue);
+ final Object newValue = adaptValue(typed.getType(), oldValue);
adapted = newValue == oldValue ? name : new NodeWithValue<>(name.getNodeType(), newValue);
} else {
adapted = name;
final NodeIdentifierWithPredicates name, final int size) {
final NodeIdentifierWithPredicates adapted;
final DataSchemaNode schema = currentSchema().getDataSchemaNode();
- if (schema instanceof ListSchemaNode) {
- adapted = NIP_ADAPTERS.getUnchecked((ListSchemaNode) schema).apply(name);
+ if (schema instanceof ListSchemaNode list) {
+ adapted = NIP_ADAPTERS.getUnchecked(list).apply(name);
} else {
adapted = name;
}
public Either<byte[], ChunkedByteArray> toVariant() {
checkClosed();
- return result instanceof byte[] ? Either.ofFirst((byte[]) result)
+ return result instanceof byte[] bytes ? Either.ofFirst(bytes)
: Either.ofSecond(new ChunkedByteArray(size, (ImmutableList<byte[]>) result));
}
@VisibleForTesting
ChunkedByteArray toChunkedByteArray() {
checkClosed();
- return new ChunkedByteArray(size, result instanceof byte[] ? ImmutableList.of((byte[]) result)
+ return new ChunkedByteArray(size, result instanceof byte[] bytes ? ImmutableList.of(bytes)
: (ImmutableList<byte[]>) result);
}
private final String logContext;
MessageAssembler(final Builder builder) {
- this.fileBackedStreamFactory = requireNonNull(builder.fileBackedStreamFactory,
+ fileBackedStreamFactory = requireNonNull(builder.fileBackedStreamFactory,
"FiledBackedStreamFactory cannot be null");
- this.assembledMessageCallback = requireNonNull(builder.assembledMessageCallback,
+ assembledMessageCallback = requireNonNull(builder.assembledMessageCallback,
"assembledMessageCallback cannot be null");
- this.logContext = builder.logContext;
+ logContext = builder.logContext;
stateCache = CacheBuilder.newBuilder()
.expireAfterAccess(builder.expireStateAfterInactivityDuration, builder.expireStateAfterInactivityUnit)
* @return true if the message was handled, false otherwise
*/
public boolean handleMessage(final Object message, final @NonNull ActorRef sendTo) {
- if (message instanceof MessageSlice) {
- LOG.debug("{}: handleMessage: {}", logContext, message);
- onMessageSlice((MessageSlice) message, sendTo);
+ if (message instanceof MessageSlice messageSlice) {
+ LOG.debug("{}: handleMessage: {}", logContext, messageSlice);
+ onMessageSlice(messageSlice, sendTo);
return true;
- } else if (message instanceof AbortSlicing) {
- LOG.debug("{}: handleMessage: {}", logContext, message);
- onAbortSlicing((AbortSlicing) message);
+ } else if (message instanceof AbortSlicing abortSlicing) {
+ LOG.debug("{}: handleMessage: {}", logContext, abortSlicing);
+ onAbortSlicing(abortSlicing);
return true;
}
final AssembledMessageState state = stateCache.get(identifier, () -> createState(messageSlice));
processMessageSliceForState(messageSlice, state, sendTo);
} catch (ExecutionException e) {
- final MessageSliceException messageSliceEx;
final Throwable cause = e.getCause();
- if (cause instanceof MessageSliceException) {
- messageSliceEx = (MessageSliceException) cause;
- } else {
- messageSliceEx = new MessageSliceException(String.format(
- "Error creating state for identifier %s", identifier), cause);
- }
+ final MessageSliceException messageSliceEx = cause instanceof MessageSliceException sliceEx ? sliceEx
+ : new MessageSliceException(String.format("Error creating state for identifier %s", identifier), cause);
messageSlice.getReplyTo().tell(MessageSliceReply.failed(identifier, messageSliceEx, sendTo),
ActorRef.noSender());
* @return this Builder
*/
public Builder fileBackedStreamFactory(final FileBackedOutputStreamFactory newFileBackedStreamFactory) {
- this.fileBackedStreamFactory = requireNonNull(newFileBackedStreamFactory);
+ fileBackedStreamFactory = requireNonNull(newFileBackedStreamFactory);
return this;
}
* @return this Builder
*/
public Builder assembledMessageCallback(final BiConsumer<Object, ActorRef> newAssembledMessageCallback) {
- this.assembledMessageCallback = newAssembledMessageCallback;
+ assembledMessageCallback = newAssembledMessageCallback;
return this;
}
*/
public Builder expireStateAfterInactivity(final long duration, final TimeUnit unit) {
checkArgument(duration > 0, "duration must be > 0");
- this.expireStateAfterInactivityDuration = duration;
- this.expireStateAfterInactivityUnit = unit;
+ expireStateAfterInactivityDuration = duration;
+ expireStateAfterInactivityUnit = unit;
return this;
}
* @return this Builder
*/
public Builder logContext(final String newLogContext) {
- this.logContext = newLogContext;
+ logContext = newLogContext;
return this;
}
@Override
public boolean equals(final Object obj) {
- if (this == obj) {
- return true;
- }
-
- if (!(obj instanceof MessageSliceIdentifier)) {
- return false;
- }
-
- MessageSliceIdentifier other = (MessageSliceIdentifier) obj;
- return other.clientIdentifier.equals(clientIdentifier) && other.slicerId == slicerId
- && other.messageId == messageId;
+ return this == obj || obj instanceof MessageSliceIdentifier other
+ && other.clientIdentifier.equals(clientIdentifier) && other.slicerId == slicerId
+ && other.messageId == messageId;
}
@Override
private final long id;
MessageSlicer(final Builder builder) {
- this.fileBackedStreamFactory = builder.fileBackedStreamFactory;
- this.messageSliceSize = builder.messageSliceSize;
- this.maxSlicingTries = builder.maxSlicingTries;
+ fileBackedStreamFactory = builder.fileBackedStreamFactory;
+ messageSliceSize = builder.messageSliceSize;
+ maxSlicingTries = builder.maxSlicingTries;
id = SLICER_ID_COUNTER.getAndIncrement();
- this.logContext = builder.logContext + "_slicer-id-" + id;
+ logContext = builder.logContext + "_slicer-id-" + id;
CacheBuilder<Identifier, SlicedMessageState<ActorRef>> cacheBuilder =
CacheBuilder.newBuilder().removalListener(this::stateRemoved);
* @return true if the message was handled, false otherwise
*/
public boolean handleMessage(final Object message) {
- if (message instanceof MessageSliceReply) {
- LOG.debug("{}: handleMessage: {}", logContext, message);
- return onMessageSliceReply((MessageSliceReply) message);
+ if (message instanceof MessageSliceReply sliceReply) {
+ LOG.debug("{}: handleMessage: {}", logContext, sliceReply);
+ return onMessageSliceReply(sliceReply);
}
return false;
private boolean onMessageSliceReply(final MessageSliceReply reply) {
final Identifier identifier = reply.getIdentifier();
- if (!(identifier instanceof MessageSliceIdentifier)
- || ((MessageSliceIdentifier)identifier).getSlicerId() != id) {
+ if (!(identifier instanceof MessageSliceIdentifier sliceIdentifier) || sliceIdentifier.getSlicerId() != id) {
return false;
}
* @return this Builder
*/
public Builder fileBackedStreamFactory(final FileBackedOutputStreamFactory newFileBackedStreamFactory) {
- this.fileBackedStreamFactory = requireNonNull(newFileBackedStreamFactory);
+ fileBackedStreamFactory = requireNonNull(newFileBackedStreamFactory);
return this;
}
*/
public Builder messageSliceSize(final int newMessageSliceSize) {
checkArgument(newMessageSliceSize > 0, "messageSliceSize must be > 0");
- this.messageSliceSize = newMessageSliceSize;
+ messageSliceSize = newMessageSliceSize;
return this;
}
*/
public Builder maxSlicingTries(final int newMaxSlicingTries) {
checkArgument(newMaxSlicingTries > 0, "newMaxSlicingTries must be > 0");
- this.maxSlicingTries = newMaxSlicingTries;
+ maxSlicingTries = newMaxSlicingTries;
return this;
}
*/
public Builder expireStateAfterInactivity(final long duration, final TimeUnit unit) {
checkArgument(duration > 0, "duration must be > 0");
- this.expireStateAfterInactivityDuration = duration;
- this.expireStateAfterInactivityUnit = unit;
+ expireStateAfterInactivityDuration = duration;
+ expireStateAfterInactivityUnit = unit;
return this;
}
* @return this Builder
*/
public Builder logContext(final String newLogContext) {
- this.logContext = requireNonNull(newLogContext);
+ logContext = requireNonNull(newLogContext);
return this;
}
}
- } else if (message instanceof RoleChanged) {
+ } else if (message instanceof RoleChanged roleChanged) {
// this message is sent by RaftActor. Notify registered listeners when this message is received.
- RoleChanged roleChanged = (RoleChanged) message;
LOG.info("RoleChangeNotifier for {} , received role change from {} to {}", memberId,
roleChanged.getOldRole(), roleChanged.getNewRole());
for (ActorRef listener: registeredListeners.values()) {
listener.tell(latestRoleChangeNotification, getSelf());
}
- } else if (message instanceof LeaderStateChanged) {
- latestLeaderStateChanged = (LeaderStateChanged)message;
+ } else if (message instanceof LeaderStateChanged leaderStateChanged) {
+ latestLeaderStateChanged = leaderStateChanged;
- for (ActorRef listener: registeredListeners.values()) {
+ for (ActorRef listener : registeredListeners.values()) {
listener.tell(latestLeaderStateChanged, getSelf());
}
} else {