A Processor implementation that takes a custom queue and allows
only a single subscriber. UnicastProcessor allows multiplexing of the events which
means that it supports multiple producers and only one consumer.
However, it should be noticed that multi-producer case is only valid if appropriate
Queue
is provided. Otherwise, it could break
Reactive Streams Spec if Publishers
publish on different threads.

Note: UnicastProcessor does not respect the actual subscriber's
demand as it is described in
Reactive Streams Spec. However,
UnicastProcessor embraces configurable Queue internally which allows enabling
backpressure support and preventing of consumer's overwhelming.
Hence, interaction model between producers and UnicastProcessor will be PUSH
only. In opposite, interaction model between UnicastProcessor and consumer will be
PUSH-PULL as defined in
Reactive Streams Spec.
In the case when upstream's signals overflow the bound of internal Queue,
UnicastProcessor will fail with signaling onError(
Exceptions.OverflowException).

Note: The implementation keeps the order of signals. That means that in
case of terminal signal (completion or error signals) it will be postponed
until all of the previous signals has been consumed.

scanUnsafe

This method is used internally by components to define their key-value mappings
in a single place. Although it is ignoring the generic type of the Scannable.Attr key,
implementors should take care to return values of the correct type, and return
null if no specific value is available.

For public consumption of attributes, prefer using Scannable.scan(Attr), which will
return a typed value and fall back to the key's default if the component didn't
define any mapping.

requestFusion

One should request either SYNC, ASYNC or ANY modes (never NONE)
and the implementor should return NONE, SYNC or ASYNC (never ANY).

For example, if a source supports only ASYNC fusion but
the intermediate operator supports only SYNC fuseable sources,
the operator may request SYNC fusion and the source can reject it via
NONE, thus the operator can return NONE as well to downstream and the
fusion doesn't happen.

isDisposed

Implementations are not required to track disposition and as such may never
return true even when disposed. However, they MUST only return true
when there's a guarantee the resource or task is disposed.