Interface Scannable

reactor-core/src/main/java/reactor/core/Scannable.java:54–634

A Scannable component exposes state in a non strictly memory consistent way and results should be understood as best-effort hint of the underlying state. This is useful to retro-engineer a component graph such as a flux operator chain via Stream queries from #actuals(), {@link #paren

 * @author Stephane Maldini
 */
@FunctionalInterface
public interface Scannable {

	/**
	 * The pattern for matching words unrelated to operator name.
	 * Used to strip an operator name of various prefixes and suffixes.
	 */
	Pattern OPERATOR_NAME_UNRELATED_WORDS_PATTERN =
		Pattern.compile("Parallel|Flux|Mono|Publisher|Subscriber|Fuseable|Operator|Conditional");

	/**
	 * Base class for {@link Scannable} attributes, which all can define a meaningful
	 * default.
	 *
	 * @param <T> the type of data associated with an attribute
	 */
	class Attr<T> {

		/* IMPLEMENTATION NOTE
		Note that some attributes define a object-to-T converter, which means their
		private {@link #tryConvert(Object)} method can safely be used by
		{@link Scannable#scan(Attr)}, making them resilient to class cast exceptions.
		 */

		/**
		 * The direct dependent component downstream reference if any. Operators in
		 * Flux/Mono for instance delegate to a target Subscriber, which is going to be
		 * the actual chain navigated with this reference key. Subscribers are not always
		 * {@link Scannable}, but this attribute will convert these raw results to an
		 * {@link Scannable#isScanAvailable() unavailable scan} object in this case.
		 * <p>
		 *  A reference chain downstream can be navigated via {@link Scannable#actuals()}.
		 */
		public static final Attr<Scannable> ACTUAL = new Attr<>(null,
				Scannable::from);

		/**
		 * Indicate that for some purposes a {@link Scannable} should be used as additional
		 * source of information about a contiguous {@link Scannable} in the chain.
		 * <p>
		 * For example {@link Scannable#steps()} uses this to collate the
		 * {@link Scannable#stepName() stepName} of an assembly trace to its
		 * wrapped operator (the one before it in the assembly chain).
		 */
		public static final Attr<Boolean> ACTUAL_METADATA = new Attr<>(false);

		/**
		 * A {@link Integer} attribute implemented by components with a backlog
		 * capacity. It will expose current queue size or similar related to
		 * user-provided held data. Note that some operators and processors CAN keep
		 * a backlog larger than {@code Integer.MAX_VALUE}, in which case
		 * the {@link Attr#LARGE_BUFFERED Attr} {@literal LARGE_BUFFERED}
		 * should be used instead. Such operators will attempt to serve a BUFFERED
		 * query but will return {@link Integer#MIN_VALUE} when actual buffer size is
		 * oversized for int.
		 */
		public static final Attr<Integer> BUFFERED = new Attr<>(0);