/**
         * Message should be delivered to a single handler, and queued until a handler is available.
         */
        SingleHandler,
        /**
         * Message should be delivered to all current handlers. Discarded if no handler is available.
         */
        AllHandlers,
        /**
         * Message should be delivered to all handlers. Most recent stateful message is queued and also delivered to each new handler.
         */

    }

    private static class TraceDiscardedVariants implements AttributeMatchingExplanationBuilder {

        private final Set<HasAttributes> discarded = new HashSet<>();

        @Override
        public boolean canSkipExplanation() {
            return false;
        }

        @Override

// StreamWriter wraps a [Stream] into an io.Writer. It calls XORKeyStream
// to process each slice of data which passes through. If any [StreamWriter.Write]
// call returns short then the StreamWriter is out of sync and must be discarded.
// A StreamWriter has no internal buffering; [StreamWriter.Close] does not need
// to be called to flush write data.
type StreamWriter struct {
	S   Stream
	W   io.Writer
	Err error // unused
}

// license that can be found in the LICENSE file.

package errors

import (
	"unsafe"
)

// Join returns an error that wraps the given errors.
// Any nil error values are discarded.
// Join returns nil if every value in errs is nil.
// The error formats as the concatenation of the strings obtained
// by calling the Error method of each element of errs, with a newline
// between each string.
//

        hub.addHandler("channel", new Object())
        hub.getOutgoing("channel", String).dispatch("discarded")

        when:
        hub.stop()

        then:
        1 * listener1.messageDiscarded("discarded")
        1 * listener2.messageDiscarded("discarded")
        0 * _._
    }

/**
 * Marker interface for exception handling.
 */
internal
interface ConfigurationCacheThrowable


/**
 * State might be corrupted and should be discarded.
 */
@Contextual
class ConfigurationCacheError internal constructor(
    error: String,
    cause: Throwable? = null
) : ConfigurationCacheThrowable, Exception(error, cause)


@Contextual

     * after this configuration's resolution are not reversed or invalidated.  Note that calling this method
     * will discard the resolution <i>results</i> but will prevent any state required to resolve the
     * configuration again from being discarded.
     * <p>
     * <strong>This method should be avoided if at all possible, and should only be used as a last resort.</strong>

import java.util.function.Function;
import java.util.function.Supplier;

public interface Cache<K, V>  {
    /**
     * Locates the given entry, using the supplied factory when the entry is not present or has been discarded, to recreate the entry in the cache.
     *
     * <p>Implementations may prevent more than one thread calculating the same key at the same time or not.
     */
    V get(K key, Function<? super K, ? extends V> factory);

     */
    InternalOperationFinishedProgressEvent createFinishedEvent(TO descriptor, DETAILS details, OperationFinishEvent finishEvent);

    /**
     * Maps the given progress event. Returns {@code null} of the event should be discarded and not forwarded to the client.
     */
    @Nullable
    default InternalProgressEvent createProgressEvent(TO descriptor, OperationProgressEvent progressEvent) {
        return null;
    }

 *
 * Listeners will not receive progress notifications for events before they have received
 * the corresponding start notification or after they have received the corresponding finished notification.
 * Such notifications are just discarded for the listener.
 *
 * @since 3.5
 */
@ServiceScope(Scope.Global.class)
public interface BuildOperationListenerManager {

    void addListener(BuildOperationListener listener);