@Override public void accept(NetChannel<IN, OUT> channel) { channel.consume(inputConsumer); } });
@Override public void accept(OUT out) { send(out, null); } });
@Override public NetChannel<IN, OUT> receive(final Function<IN, OUT> fn) { consume(new Consumer<IN>() { @Override public void accept(IN in) { send(fn.apply(in)); } }); return this; }
@Override protected void doStart() { server.start(); }
@Override protected void doStop() { server.shutdown(); }
@Override public BatchConsumer<OUT> out() { return new WriteConsumer(null); }
/** * Subclasses should implement this method to perform the actual IO channel close. * * @param onClose */ protected void doClose(@Nullable Consumer<Boolean> onClose) { getReactor().schedule(onClose, true); }
/** * Close the given channel. * * @param channel */ protected void doCloseChannel(NetChannel<IN, OUT> channel) { channel.close(); }
/** * Subclasses must implement this method to perform the actual IO of writing data to the connection. * * @param data * The data to write, as a {@link Buffer}. * @param onComplete * The callback to invoke when the write is complete. */ protected void write(Buffer data, Deferred<Void, Promise<Void>> onComplete, boolean flush) { write(data.byteBuffer(), onComplete, flush); }
private void passToConnection(ByteBuf data) { Buffer b = new Buffer(data.nioBuffer()); int start = b.position(); netChannel.read(b); data.skipBytes(b.position() - start); }
public Iterator<NetChannel<IN, OUT>> iterator() { FastList<NetChannel<IN, OUT>> channels = FastList.newList(); for (Registration<? extends NetChannel<IN, OUT>> reg : getChannels()) { channels.add(reg.getObject()); } return channels.iterator(); }
@Override public void accept(NetChannel<IN, OUT> netChannel) { for(Consumer<IN> consumer : consumers) { netChannel.consume(consumer); } } });
@Override public void start() { startLock.lock(); try { server.start(); started = true; } finally { startLock.unlock(); } }
@Override public NetChannel<IN, OUT> sendAndForget(OUT data) { send(data, null); return this; }
@Override public Stream<IN> in() { final Deferred<IN, Stream<IN>> d = new Deferred<IN, Stream<IN>>(new Stream<IN>(eventsReactor, -1, null, env)); consume(new Consumer<IN>() { @Override public void accept(IN in) { d.accept(in); } }); return d.compose(); }
/** * Send data on this connection. The current codec (if any) will be used to encode the data to a {@link * reactor.io.Buffer}. The given callback will be invoked when the write has completed. * * @param data * The outgoing data. * @param onComplete * The callback to invoke when the write is complete. */ protected void send(OUT data, final Deferred<Void, Promise<Void>> onComplete) { ioReactor.schedule(new WriteConsumer(onComplete), data); }
/** * Notify this server's consumers that the server has stopped. */ protected void notifyShutdown() { getReactor().notify(shutdown.getObject(), selfEvent); }
@Override public void accept(NetChannel<Buffer, Buffer> conn) { // consume lines and delegate to codec conn.consume(new Consumer<Buffer>() { @Override public void accept(Buffer b) { decoder.apply(b); } }); } });
@Override public void accept(IN in) { send(fn.apply(in)); } });
@Override public void accept(NetChannel ch) { ch.consume(new Consumer() { @Override public void accept(Object o) { if(null == messageHandler) { return; } Message<?> msg = new GenericMessage<Object>(o); messageHandler.handleMessage(msg); } }); } };