@Override public Function<Buffer, IN> decoder(Consumer<IN> next) { if (lengthFieldFraming) { return new LengthFieldCodec<IN, OUT>(new DelegateCodec()).decoder(next); } else { return new DelegateCodec().decoder(next); } }
@Override public Buffer apply(String s) { return encode(s, encoder); } }
public FrameCodec(int prefixLength, LengthField lengthField) { this.prefixLength = prefixLength; this.lengthField = lengthField; this.minRequiredLen = lengthFieldLength(lengthField) + prefixLength; }
@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 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); } }); }
/** * 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); }
@Override public Buffer apply(OUT out) { return encoder.apply(out); }
/** * Create a {@code SerializationCodec} using the given engine and specifying whether or not to prepend a length field * to frame the message. * * @param engine the engine which will perform the serialization * @param lengthFieldFraming {@code true} to prepend a length field, or {@code false} to skip */ protected SerializationCodec(E engine, boolean lengthFieldFraming) { this.engine = engine; this.lengthFieldFraming = lengthFieldFraming; if (lengthFieldFraming) { this.encoder = new LengthFieldCodec<IN, OUT>(new DelegateCodec()); } else { this.encoder = new DelegateCodec(); } }
@Override public SubscriberBarrier<OUT, SRC> apply(final Subscriber<? super SRC> subscriber) { return new EncoderBarrier(subscriber); } });
@Override public SubscriberBarrier<Buffer, IN> apply(final Subscriber<? super IN> subscriber) { return new AggregatingDecoderBarrier<IN>(BufferCodec.this, subscriber); } });
@Override public SubscriberBarrier<SRC, IN> apply(final Subscriber<? super IN> subscriber) { return new DecoderBarrier(subscriber); } });
@Override public SubscriberBarrier<OUT, Buffer> apply(final Subscriber<? super Buffer> subscriber) { return new AggregatingEncoderBarrier(subscriber); } });
public AggregatingDecoderBarrier(BufferCodec<IN, ?> codec, Subscriber<? super IN> subscriber) { super(subscriber); this.codec = codec.decoder(); this.delimiter = codec.delimiter; if (delimiter != null) { aggregate = null; } else { aggregate = null; } }
@Override public Function<Buffer, IN> decoder(Consumer<IN> next) { return new DelimitedDecoder(next); }
@Override public Function<Buffer, T> decoder(Consumer<T> next) { return new Decoder(next); }
@Override public SRC apply(SRC src) { return beforeApply(src); }
@Override public Function<Buffer, Frame> decoder(Consumer<Frame> next) { return new FrameDecoder(next); }
@Override public Function<String, Buffer> encoder() { return new StringEncoder(); }
@Override public Function<Buffer, String> decoder(Consumer<String> next) { return new StringDecoder(next); }
@Override public Function<Buffer, IN> decoder(Consumer<IN> next) { return new LengthFieldDecoder(next); }