Java tutorial
/* * KitchenSync-core Java Library Copyright (C) 2014 Burton Alexander * * This program is free software; you can redistribute it and/or modify it under * the terms of the GNU General Public License as published by the Free Software * Foundation; either version 2 of the License, or (at your option) any later * version. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more * details. * * You should have received a copy of the GNU General Public License along with * this program; if not, write to the Free Software Foundation, Inc., 51 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * */ package com.github.mrstampy.kitchensync.stream; import io.netty.channel.Channel; import io.netty.channel.ChannelFuture; import io.netty.util.concurrent.Future; import io.netty.util.concurrent.GenericFutureListener; import java.util.ArrayList; import java.util.List; import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutionException; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * The Class StreamerFuture used in the {@link AbstractStreamer} implementation. */ public class StreamerFuture implements ChannelFuture { private static final Logger log = LoggerFactory.getLogger(StreamerFuture.class); private boolean success; private boolean cancelled; private boolean done; private Throwable cause; /** The streamer. */ protected Streamer<?> streamer; /** The listeners. */ protected List<GenericFutureListener<ChannelFuture>> listeners = new ArrayList<GenericFutureListener<ChannelFuture>>(); /** The latch. */ protected CountDownLatch latch = new CountDownLatch(1); /** * The Constructor. * * @param streamer * the streamer */ public StreamerFuture(Streamer<?> streamer) { this.streamer = streamer; } /** * Finished. * * @param success * the success */ void finished(boolean success) { finished(success, null); } /** * Finished. * * @param success * the success * @param t * the t */ void finished(boolean success, Throwable t) { setDone(true); setSuccess(success); setCause(t); finish(); } /* * (non-Javadoc) * * @see io.netty.util.concurrent.Future#isSuccess() */ @Override public boolean isSuccess() { return success; } /* * (non-Javadoc) * * @see io.netty.util.concurrent.Future#isCancellable() */ @Override public boolean isCancellable() { return true; } /* * (non-Javadoc) * * @see io.netty.util.concurrent.Future#cause() */ @Override public Throwable cause() { return cause; } /* * (non-Javadoc) * * @see io.netty.util.concurrent.Future#await(long, * java.util.concurrent.TimeUnit) */ @Override public boolean await(long timeout, TimeUnit unit) throws InterruptedException { return latch.await(timeout, unit); } /* * (non-Javadoc) * * @see io.netty.util.concurrent.Future#await(long) */ @Override public boolean await(long timeoutMillis) throws InterruptedException { return await(timeoutMillis, TimeUnit.MILLISECONDS); } /* * (non-Javadoc) * * @see io.netty.util.concurrent.Future#awaitUninterruptibly(long, * java.util.concurrent.TimeUnit) */ @Override public boolean awaitUninterruptibly(long timeout, TimeUnit unit) { try { return await(timeout, unit); } catch (InterruptedException e) { setCause(e); setSuccess(false); } return false; } /* * (non-Javadoc) * * @see io.netty.util.concurrent.Future#awaitUninterruptibly(long) */ @Override public boolean awaitUninterruptibly(long timeoutMillis) { return awaitUninterruptibly(timeoutMillis, TimeUnit.MILLISECONDS); } /* * (non-Javadoc) * * @see io.netty.util.concurrent.Future#getNow() */ @Override public Void getNow() { return null; } /* * (non-Javadoc) * * @see io.netty.util.concurrent.Future#cancel(boolean) */ @Override public boolean cancel(boolean mayInterruptIfRunning) { streamer.cancel(); setCancelled(true); return true; } /* * (non-Javadoc) * * @see java.util.concurrent.Future#isCancelled() */ @Override public boolean isCancelled() { return cancelled; } /* * (non-Javadoc) * * @see java.util.concurrent.Future#isDone() */ @Override public boolean isDone() { return done; } /* * (non-Javadoc) * * @see java.util.concurrent.Future#get() */ @Override public Void get() throws InterruptedException, ExecutionException { return null; } /* * (non-Javadoc) * * @see java.util.concurrent.Future#get(long, java.util.concurrent.TimeUnit) */ @Override public Void get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { return null; } /* * (non-Javadoc) * * @see io.netty.channel.ChannelFuture#channel() */ @Override public Channel channel() { return streamer.getChannel().getChannel(); } /* * (non-Javadoc) * * @see io.netty.channel.ChannelFuture#addListener(io.netty.util.concurrent. * GenericFutureListener) */ @SuppressWarnings("unchecked") @Override public ChannelFuture addListener(GenericFutureListener<? extends Future<? super Void>> listener) { listeners.add((GenericFutureListener<ChannelFuture>) listener); return this; } /* * (non-Javadoc) * * @see io.netty.channel.ChannelFuture#addListeners(io.netty.util.concurrent. * GenericFutureListener[]) */ @SuppressWarnings("unchecked") @Override public ChannelFuture addListeners(GenericFutureListener<? extends Future<? super Void>>... listeners) { for (GenericFutureListener<? extends Future<? super Void>> l : listeners) { this.listeners.add((GenericFutureListener<ChannelFuture>) l); } return this; } /* * (non-Javadoc) * * @see * io.netty.channel.ChannelFuture#removeListener(io.netty.util.concurrent. * GenericFutureListener) */ @Override public ChannelFuture removeListener(GenericFutureListener<? extends Future<? super Void>> listener) { listeners.remove(listener); return this; } /* * (non-Javadoc) * * @see * io.netty.channel.ChannelFuture#removeListeners(io.netty.util.concurrent * .GenericFutureListener[]) */ @Override public ChannelFuture removeListeners(GenericFutureListener<? extends Future<? super Void>>... listeners) { for (GenericFutureListener<? extends Future<? super Void>> l : listeners) { this.listeners.remove(l); } return this; } /* * (non-Javadoc) * * @see io.netty.channel.ChannelFuture#sync() */ @Override public ChannelFuture sync() throws InterruptedException { latch.await(); return this; } /* * (non-Javadoc) * * @see io.netty.channel.ChannelFuture#syncUninterruptibly() */ @Override public ChannelFuture syncUninterruptibly() { try { return sync(); } catch (InterruptedException e) { setCause(e); setSuccess(false); } return this; } /* * (non-Javadoc) * * @see io.netty.channel.ChannelFuture#await() */ @Override public ChannelFuture await() throws InterruptedException { return sync(); } /* * (non-Javadoc) * * @see io.netty.channel.ChannelFuture#awaitUninterruptibly() */ @Override public ChannelFuture awaitUninterruptibly() { return syncUninterruptibly(); } /** * Notifies listeners and counts the latch down. */ protected void finish() { for (GenericFutureListener<ChannelFuture> l : listeners) { try { l.operationComplete(this); } catch (Exception e) { log.error("Error notifying listener of completion", e); } } latch.countDown(); } /** * Sets the cause. * * @param cause * the cause */ public void setCause(Throwable cause) { this.cause = cause; } /** * Sets the success. * * @param success * the success */ public void setSuccess(boolean success) { this.success = success; } /** * Sets the cancelled. * * @param cancelled * the cancelled */ public void setCancelled(boolean cancelled) { this.cancelled = cancelled; } /** * Sets the done. * * @param done * the done */ public void setDone(boolean done) { this.done = done; } }