*/
package org.opendaylight.controller.cluster.messaging;
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+
import akka.actor.ActorRef;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.RemovalNotification;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;
-import java.util.Iterator;
import java.util.Optional;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Predicate;
-import javax.annotation.Nonnull;
+import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.controller.cluster.io.FileBackedOutputStream;
import org.opendaylight.controller.cluster.io.FileBackedOutputStreamFactory;
import org.opendaylight.yangtools.concepts.Identifier;
private final String logContext;
private final long id;
- private MessageSlicer(final Builder builder) {
+ MessageSlicer(final Builder builder) {
this.fileBackedStreamFactory = builder.fileBackedStreamFactory;
this.messageSliceSize = builder.messageSliceSize;
this.maxSlicingTries = builder.maxSlicingTries;
this.logContext = builder.logContext + "_slicer-id-" + id;
CacheBuilder<Identifier, SlicedMessageState<ActorRef>> cacheBuilder =
- CacheBuilder.newBuilder().removalListener(notification -> stateRemoved(notification));
+ CacheBuilder.newBuilder().removalListener(this::stateRemoved);
if (builder.expireStateAfterInactivityDuration > 0) {
cacheBuilder = cacheBuilder.expireAfterAccess(builder.expireStateAfterInactivityDuration,
builder.expireStateAfterInactivityUnit);
if (message != null) {
LOG.debug("{}: slice: identifier: {}, message: {}", logContext, identifier, message);
- Preconditions.checkNotNull(fileBackedStreamFactory,
+ requireNonNull(fileBackedStreamFactory,
"The FiledBackedStreamFactory must be set in order to call this slice method");
// Serialize the message to a FileBackedOutputStream.
*
* @param filter filters by Identifier
*/
- public void cancelSlicing(@Nonnull final Predicate<Identifier> filter) {
- final Iterator<MessageSliceIdentifier> iter = stateCache.asMap().keySet().iterator();
- while (iter.hasNext()) {
- if (filter.test(iter.next().getClientIdentifier())) {
- iter.remove();
- }
- }
+ public void cancelSlicing(final @NonNull Predicate<Identifier> filter) {
+ stateCache.asMap().keySet().removeIf(
+ messageSliceIdentifier -> filter.test(messageSliceIdentifier.getClientIdentifier()));
}
private static MessageSlice getNextSliceMessage(final SlicedMessageState<ActorRef> state) throws IOException {
* @return this Builder
*/
public Builder fileBackedStreamFactory(final FileBackedOutputStreamFactory newFileBackedStreamFactory) {
- this.fileBackedStreamFactory = Preconditions.checkNotNull(newFileBackedStreamFactory);
+ this.fileBackedStreamFactory = requireNonNull(newFileBackedStreamFactory);
return this;
}
* @return this Builder
*/
public Builder messageSliceSize(final int newMessageSliceSize) {
- Preconditions.checkArgument(newMessageSliceSize > 0, "messageSliceSize must be > 0");
+ checkArgument(newMessageSliceSize > 0, "messageSliceSize must be > 0");
this.messageSliceSize = newMessageSliceSize;
return this;
}
* @return this Builder
*/
public Builder maxSlicingTries(final int newMaxSlicingTries) {
- Preconditions.checkArgument(newMaxSlicingTries > 0, "newMaxSlicingTries must be > 0");
+ checkArgument(newMaxSlicingTries > 0, "newMaxSlicingTries must be > 0");
this.maxSlicingTries = newMaxSlicingTries;
return this;
}
* @return this Builder
*/
public Builder expireStateAfterInactivity(final long duration, final TimeUnit unit) {
- Preconditions.checkArgument(duration > 0, "duration must be > 0");
+ checkArgument(duration > 0, "duration must be > 0");
this.expireStateAfterInactivityDuration = duration;
this.expireStateAfterInactivityUnit = unit;
return this;
* @return this Builder
*/
public Builder logContext(final String newLogContext) {
- this.logContext = Preconditions.checkNotNull(newLogContext);
+ this.logContext = requireNonNull(newLogContext);
return this;
}