Package io.micronaut.http.body

Class ConcatenatingSubscriber

java.lang.Object
io.micronaut.http.body.ConcatenatingSubscriber
All Implemented Interfaces:
BufferConsumer, BufferConsumer.Upstream, Subscriber<ByteBody>, reactor.core.CoreSubscriber<ByteBody>
Direct Known Subclasses:
ConcatenatingSubscriber.ByteBufferConcatenatingSubscriber
@Internal public abstract class ConcatenatingSubscriber extends Object implements BufferConsumer.Upstream, reactor.core.CoreSubscriber<ByteBody>, BufferConsumer
This is a reactive subscriber that accepts ByteBodys and concatenates them into a single BaseSharedBuffer, optionally with separators.
Since:
4.8.0
Author:
Jonas Konrad

  • Constructor Details

    • ConcatenatingSubscriber

      public ConcatenatingSubscriber()

  • Method Details

    • onSubscribe

      public final void onSubscribe(Subscription s)
      Specified by:
      onSubscribe in interface reactor.core.CoreSubscriber<ByteBody>
      Specified by:
      onSubscribe in interface Subscriber<ByteBody>

    • emitLeadingSeparator

      protected long emitLeadingSeparator(boolean first)
      Called before any new ByteBody component to emit an additional separator.
      Parameters:
      first - true iff this is the first element (i.e. the start of the output)
      Returns:
      The number of bytes written for onBytesConsumed(long) accounting

    • emitFinalSeparator

      protected long emitFinalSeparator(boolean first)
      Called before after all ByteBody components to emit additional trailing bytes.
      Parameters:
      first - true iff this is the first element, i.e. there were no component ByteBodys
      Returns:
      The number of bytes written for onBytesConsumed(long) accounting

    • onComplete

      public final void onComplete()
      Specified by:
      onComplete in interface Subscriber<ByteBody>

    • onError

      public final void onError(Throwable t)
      Specified by:
      onError in interface Subscriber<ByteBody>

    • forward

      @Nullable protected abstract BufferConsumer.Upstream forward(ByteBody body)
      Forward the given body to the shared buffer.
      Parameters:
      body - The body
      Returns:
      The BufferConsumer.Upstream to control component backpressure, or null if all bytes were written immediately (as is the case for an AvailableByteBody)

    • onForward

      protected final void onForward(long n)
      Should be called by the subclass when bytes are sent to the sharedBuffer, for onBytesConsumed(long) accounting.
      Parameters:
      n - The number of bytes forwarded

    • onNext

      public final void onNext(ByteBody body)
      Specified by:
      onNext in interface Subscriber<ByteBody>

    • start

      public final void start()
      Description copied from interface: BufferConsumer.Upstream
      Signal that we want to start consuming bytes. This is an optional hint to the upstream, the upstream may ignore it and send bytes immediately. This is used for CONTINUE support.
      Specified by:
      start in interface BufferConsumer.Upstream

    • onBytesConsumed

      public final void onBytesConsumed(long bytesConsumed)
      Description copied from interface: BufferConsumer.Upstream
      Called when a number of bytes has been consumed by the downstream. Note that this can exceed the actual number of bytes written so far, if the downstream wants to signal it is ready consume much more data.
      Specified by:
      onBytesConsumed in interface BufferConsumer.Upstream
      Parameters:
      bytesConsumed - The number of bytes that were consumed

    • allowDiscard

      public final void allowDiscard()
      Description copied from interface: BufferConsumer.Upstream
      Allow the upstream to discard any further messages. Note that this does not actually mean the messages must be discarded: If another consumer still needs the body data, it may continue to be read and continue to be forwarded to this consumer.
      Specified by:
      allowDiscard in interface BufferConsumer.Upstream

    • disregardBackpressure

      public final void disregardBackpressure()
      Description copied from interface: BufferConsumer.Upstream
      Instruct the upstream to ignore backpressure from this consumer. This is slightly different from onBytesConsumed(Long.MAX_VALUE): If there are two consumers in ByteBody.SplitBackpressureMode.FASTEST mode, a MAX_VALUE requests all data from the common upstream, while a disregardBackpressure removes this downstream from consideration.
      Specified by:
      disregardBackpressure in interface BufferConsumer.Upstream

    • complete

      public final void complete()
      Description copied from interface: BufferConsumer
      Signal normal completion of the stream.
      Specified by:
      complete in interface BufferConsumer

    • error

      public final void error(Throwable e)
      Description copied from interface: BufferConsumer
      Signal an upstream error.
      Specified by:
      error in interface BufferConsumer
      Parameters:
      e - The error

    • forwardComplete

      protected abstract void forwardComplete()
      Forward completion to the shared buffer.

    • forwardError

      protected abstract void forwardError(Throwable t)
      Forward an error to the shared buffer.
      Parameters:
      t - The error