// NewTTLWithCallback creates a new cache with a time-based eviction model that will invoke the supplied
// callback on all evictions. See also: NewTTL.
func NewTTLWithCallback(defaultExpiration time.Duration, evictionInterval time.Duration, callback EvictionCallback) ExpiringCache {
	c := &ttlCache{
		defaultExpiration: defaultExpiration,
		callback:          callback,
	}

	c.baseTimeNanos = time.Now().UnixNano()
	if evictionInterval > 0 {

#include <stdio.h>

#ifndef STACK_SIZE_PARAM_IS_A_RESERVATION
#define STACK_SIZE_PARAM_IS_A_RESERVATION 0x00010000
#endif

typedef void callback(char*);

// Allocate a stack that's much larger than the default.
static const int STACK_SIZE = 16<<20;

static callback *bigStackCallback;

static void useStack(int bytes) {
	// Windows doesn't like huge frames, so we grow the stack 64k at a time.
	char x[64<<10];

 * under the License.
 */
package org.apache.maven;

import org.apache.maven.execution.MavenSession;

/**
 * Allows core extensions to participate in Maven build session lifecycle.
 *
 * All callback methods (will) follow beforeXXX/afterXXX naming pattern to
 * indicate at what lifecycle point it is being called.
 *
 * @see <a href="https://maven.apache.org/examples/maven-3-lifecycle-extensions.html">example</a>

        cleanup:
        latch.countDown()
    }

    @FailsWithMessage(type = IllegalStateException, message = 'Expected action to register a callback action, but it did not.')
    def "blocking action fails when blocking action never registers callback action"() {
        Runnable action = Mock()
        def latch = new CountDownLatch(1)
        def operation = waitsForAsyncCallback()

        when:

    * Send a notification back to the API user (the external developer), as a callback.
        * At this point is that the API will somehow send a POST request to the
            external API with the notification of the invoice event
            (e.g. "payment successful").
    """
    # Send the invoice, collect the money, send the notification (the callback)
    return {"msg": "Invoice received"}

                                    ],
                                    "title": "Callback Url",
                                }
                            )
                            | IsDict(
                                # TODO: remove when deprecating Pydantic v1
                                {
                                    "title": "Callback Url",
                                    "maxLength": 2083,

    def ansiExecutor = new DefaultAnsiExecutor(target, colorMap, factory, consoleMetaData, writeCursor, newLineListener)

    def "writing a long line that wraps will callback the listener"() {
        given:
        consoleMetaData.cols >> TERMINAL_WIDTH
        Cursor writePos = Cursor.at(3, 0)
        int startRow = writePos.row
        String text = "A" * TERMINAL_WIDTH +

 */
package org.codelibs.fess.ds;

import org.codelibs.fess.ds.callback.IndexUpdateCallback;
import org.codelibs.fess.entity.DataStoreParams;
import org.codelibs.fess.es.config.exentity.DataConfig;

public interface DataStore {

    void store(DataConfig config, IndexUpdateCallback callback, DataStoreParams initParamMap);

    void stop();

        void callback(CQ query, CF filter);
    }

    @FunctionalInterface
    public interface OperatorCall<CQ extends EsAbstractConditionQuery> {

        void callback(CQ query);
    }

    @FunctionalInterface
    public interface ScoreFunctionCall<CC extends ScoreFunctionCreator<?>> {

        void callback(CC creator);
    }

    @FunctionalInterface

                    throw new IllegalStateException("beforeAll callback");
                }
            }

            class ThrowingAfterAllCallback implements AfterAllCallback {
                @Override
                public void afterAll(ExtensionContext context) {
                    throw new CustomException("afterAll callback");
                }
            }