@Override public Publisher<IN> decode(final Publisher<? extends Buffer> publisherToDecode) { if (true) { return super.decode(publisherToDecode); } return PublisherFactory.intercept(publisherToDecode, new Function<Subscriber<? super IN>, SubscriberBarrier<Buffer, IN>>() { @Override public SubscriberBarrier<Buffer, IN> apply(final Subscriber<? super IN> subscriber) { return new AggregatingDecoderBarrier<IN>(BufferCodec.this, subscriber); } }); }
@Override public Publisher<Buffer> encode(Publisher<? extends OUT> publisherToEncode) { if (true) { return super.encode(publisherToEncode); } return PublisherFactory.intercept(publisherToEncode, new Function<Subscriber<? super Buffer>, SubscriberBarrier<OUT, Buffer>>() { @Override public SubscriberBarrier<OUT, Buffer> apply(final Subscriber<? super Buffer> subscriber) { return new AggregatingEncoderBarrier(subscriber); } }); }
@Override public Buffer apply(OUT out) { return encoder.apply(out); }
/** * Helper method to scan for delimiting byte the codec might benefit from, e.g. JSON codec. * A DelimitedCodec or alike will obviously not require to make use of that helper as it is already delimiting. * * @param decoderCallback * @param buffer * @return a value if no callback is supplied and there is only one delimited buffer */ protected IN doDelimitedBufferDecode(Consumer<IN> decoderCallback, Buffer buffer) { //split using the delimiter if (delimiter != null) { List<Buffer.View> views = buffer.split(delimiter); int viewCount = views.size(); if (viewCount == 0) return invokeCallbackOrReturn(decoderCallback, doBufferDecode(buffer)); for (Buffer.View view : views) { IN in = invokeCallbackOrReturn(decoderCallback, doBufferDecode(view.get())); if (in != null) return in; } return null; } else { return invokeCallbackOrReturn(decoderCallback, doBufferDecode(buffer)); } }
/** * Provide the caller with a decoder to turn a source object into an instance of the input * type. * * @return The decoded object. */ public Function<SRC, IN> decoder() { return decoder(null); }
protected ChannelStream(final Environment env, Codec<Buffer, IN, OUT> codec, long prefetch, Dispatcher eventsDispatcher) { Assert.notNull(eventsDispatcher, "Events Reactor cannot be null"); this.env = env; this.prefetch = prefetch; this.eventsDispatcher = eventsDispatcher; if (null != codec) { this.decoder = codec.decoder(new Consumer<IN>() { @Override public void accept(IN in) { doDecoded(in); } }); this.encoder = codec.encoder(); } else { this.decoder = null; this.encoder = null; } }
@Override public String apply(Buffer buffer) { //split using the delimiter if(delimiter != null) { List<Buffer.View> views = buffer.split(delimiter); int viewCount = views.size(); if (viewCount == 0) return invokeCallbackOrReturn(next, doBufferDecode(buffer)); for (Buffer.View view : views) { String in = invokeCallbackOrReturn(next, decode(view.get(), decoder)); if(in != null) return in; } return null; }else{ return invokeCallbackOrReturn(next, decode(buffer, decoder)); } } }
@SuppressWarnings("unchecked") private T read(ExcerptCommon ex) { try { int len = ex.readInt(); ByteBuffer bb = ByteBuffer.allocate(len); ex.read(bb); bb.flip(); return codec.decoder(null).apply(new Buffer(bb)); } finally { ex.finish(); } }
@Override public void subscribe(Subscriber<? super V> s) { codec.decode(Stream.this).subscribe(s); }
@Override public void subscribe(Subscriber<? super V> s) { codec.encode(Stream.this).subscribe(s); }
@Override public Buffer apply(OUT out) { Buffer buff = delegate.apply(out); try { ByteArrayOutputStream bout = new ByteArrayOutputStream(); OutputStream zout = createOutputStream(bout); zout.write(buff.asBytes()); zout.flush(); bout.flush(); zout.close(); return Buffer.wrap(bout.toByteArray()); } catch (IOException e) { throw new IllegalStateException(e.getMessage(), e); } }
@Override public IN apply(Buffer buffer) { try { ByteArrayInputStream bin = new ByteArrayInputStream(buffer.asBytes()); InputStream zin = createInputStream(bin); Buffer newBuff = new Buffer(); while (zin.available() > 0) { newBuff.append((byte) zin.read()); } zin.close(); IN in = delegate.decoder(null).apply(newBuff.flip()); if (null != next) { next.accept(in); return null; } else { return in; } } catch (IOException e) { throw new IllegalStateException(e.getMessage(), e); } } };
/** * * Use the given {@link Codec} to decode any {@code SRC} data published by the {@code publisher} reference. * Some codec might result into N signals for one SRC data. * * @param codec the codec decoder is going to be used to scan the incoming {@code SRC} data * @param publisher The data stream publisher we want to decode * @param <SRC> The type of the origin value * @param <IN> The type of the decoded value * @return a Stream of decoded values */ public static <SRC, IN> Stream<IN> decode(Codec<SRC, IN, ?> codec, Publisher<? extends SRC> publisher){ return Streams.wrap(codec.decode(publisher)); }
/** * * @return */ public Function<? super Flux<? extends OUT>, ? extends Publisher<ByteBuf>> encoder() { return flux -> codec.encode(flux).map(b -> Unpooled.wrappedBuffer(b.byteBuffer())); } }
@Override public Buffer apply(OUT out) { if (null == out) { return null; } Buffer encoded = delegate.apply(out); if (null != encoded && encoded.remaining() > 0) { int len = encoded.remaining(); ByteBuffer bb = null; if (lengthFieldLength == 4) { bb = ByteBuffer.allocate(len + 4); bb.putInt(len); } else if (lengthFieldLength == 2) { bb = ByteBuffer.allocate(len + 2); bb.putShort((short) len); } else if (lengthFieldLength == 8) { bb = ByteBuffer.allocate(len + 8); bb.putLong((long) len); } if (null != bb) { bb.put(encoded.byteBuffer()).flip(); return new Buffer(bb); } } return encoded; }
@Override public void subscribe(Subscriber<? super V> s) { codec.decode(Stream.this).subscribe(s); }
@Override public void subscribe(Subscriber<? super V> s) { codec.encode(Stream.this).subscribe(s); }
@Override public Long offer(@Nonnull T t) { synchronized (monitor) { Buffer buff = codec.apply(t); int len = buff.remaining(); exAppender.startExcerpt(4 + len); exAppender.writeInt(len); exAppender.write(buff.byteBuffer()); exAppender.finish(); size.incrementAndGet(); lastId.set(exAppender.lastWrittenIndex()); } if (LOG.isTraceEnabled()) { LOG.trace("Offered {} to Chronicle at index {}, size {}", t, lastId(), size()); } return lastId(); }
/** * * Use the given {@link Codec} to decode any {@code SRC} data published by the {@code publisher} reference. * Some codec might result into N signals for one SRC data. * * @param codec the codec decoder is going to be used to scan the incoming {@code SRC} data * @param publisher The data stream publisher we want to decode * @param <SRC> The type of the origin value * @param <IN> The type of the decoded value * @return a Stream of decoded values */ public static <SRC, IN> Stream<IN> decode(Codec<SRC, IN, ?> codec, Publisher<? extends SRC> publisher){ return Streams.wrap(codec.decode(publisher)); }
@Override public Buffer apply(OUT out) { Buffer buffer = new Buffer(); Buffer encoded = delegate.apply(out); if (null != encoded && encoded.remaining() > 0) { buffer.append(encoded).append(delimiter); } return buffer.flip(); }