*/
package org.opendaylight.openflowjava.protocol.impl.core.connection;
-import com.google.common.base.Preconditions;
+import static com.google.common.base.Preconditions.checkState;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.GenericFutureListener;
+import org.opendaylight.yangtools.yang.common.ErrorTag;
+import org.opendaylight.yangtools.yang.common.ErrorType;
import org.opendaylight.yangtools.yang.common.RpcError;
-import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
import org.slf4j.Logger;
* A MessageHolder (used in queue) and the actual listener. It is not a thing of beauty,
* but it keeps us from allocating unnecessary objects in the egress path.
*/
-abstract class AbstractRpcListener<T> implements GenericFutureListener<Future<Void>>, ChannelOutboundQueue.MessageHolder<Object> {
+abstract class AbstractRpcListener<T> implements GenericFutureListener<Future<Void>>,
+ ChannelOutboundQueue.MessageHolder<Object> {
private static final Logger LOG = LoggerFactory.getLogger(AbstractRpcListener.class);
private static final String APPLICATION_TAG = "OPENFLOW_LIBRARY";
- private static final String TAG = "OPENFLOW";
+ private static final ErrorTag TAG = new ErrorTag("OPENFLOW");
private final SettableFuture<RpcResult<T>> result = SettableFuture.create();
private final String failureInfo;
private Object message;
/**
- * Create RcpError object
- * @param info
- * @param severity - error severity
- * @param message
+ * Create RcpError object.
+ *
+ * @param info error info
+ * @param message error message
* @param cause - details of reason
- * @return
+ * @return RpcError
*/
static RpcError buildRpcError(final String info, final String message, final Throwable cause) {
return RpcResultBuilder.newError(ErrorType.RPC, TAG, message, APPLICATION_TAG, info, cause);
}
AbstractRpcListener(final Object message, final String failureInfo) {
- this.failureInfo = Preconditions.checkNotNull(failureInfo);
- this.message = Preconditions.checkNotNull(message);
+ this.failureInfo = requireNonNull(failureInfo);
+ this.message = requireNonNull(message);
}
public final ListenableFuture<RpcResult<T>> getResult() {
@Override
public final Object takeMessage() {
final Object ret = message;
- Preconditions.checkState(ret != null, "Message has already been taken");
+ checkState(ret != null, "Message has already been taken");
message = null;
return ret;
}