org.infinispan.interceptors.AsyncInterceptorChain Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of infinispan-embedded
Infinispan Embedded All-in-One module
There is a newer version: 9.1.7.Final
package org.infinispan.interceptors;

import java.util.List;
import java.util.concurrent.CompletableFuture;

import org.infinispan.commands.VisitableCommand;
import org.infinispan.commons.util.Experimental;
import org.infinispan.context.InvocationContext;

/**
 * Interceptor chain using {@link AsyncInterceptor}s.
 *
 * Experimental: The ability to modify the interceptors at runtime may be removed in future versions.
 *
 * @author Dan Berindei
 * @since 9.0
 */
@Experimental
public interface AsyncInterceptorChain {
   /**
    * @return An immutable list of the current interceptors.
    */
   List getInterceptors();

   /**
    * Inserts the given interceptor at the specified position in the chain (0 based indexing).
    *
    * @throws IllegalArgumentException if the position is invalid (e.g. 5 and there are only 2 interceptors
    *       in the chain)
    */
   void addInterceptor(AsyncInterceptor interceptor, int position);

   /**
    * Removes the interceptor at the given position.
    *
    * @throws IllegalArgumentException if the position is invalid (e.g. 5 and there are only 2 interceptors
    *       in the chain)
    */
   void removeInterceptor(int position);

   /**
    * Returns the number of interceptors in the chain.
    */
   int size();

   /**
    * Removes all the occurrences of supplied interceptor type from the chain.
    */
   void removeInterceptor(Class clazz);

   /**
    * Adds a new interceptor in list after an interceptor of a given type.
    *
    * @return true if the interceptor was added; i.e. the {@code afterInterceptor} exists
    */
   boolean addInterceptorAfter(AsyncInterceptor toAdd, Class afterInterceptor);

   /**
    * Adds a new interceptor in list before an interceptor of a given type.
    *
    * @return true if the interceptor was added; i.e. the {@code beforeInterceptor} exists
    */
   boolean addInterceptorBefore(AsyncInterceptor toAdd, Class beforeInterceptor);

   /**
    * Replaces an existing interceptor of the given type in the interceptor chain with a new interceptor
    * instance passed as parameter.
    *
    * @param replacingInterceptor        the interceptor to add to the interceptor chain
    * @param toBeReplacedInterceptorType the type of interceptor that should be swapped with the new one
    * @return true if the interceptor was replaced
    */
   boolean replaceInterceptor(AsyncInterceptor replacingInterceptor,
         Class toBeReplacedInterceptorType);

   /**
    * Appends at the end.
    */
   void appendInterceptor(AsyncInterceptor ci, boolean isCustom);

   /**
    * Walks the command through the interceptor chain. The received ctx is being passed in.
    *
    * Note: Reusing the context for multiple invocations is allowed, however most context implementations are not
    * thread-safe.
    */
   Object invoke(InvocationContext ctx, VisitableCommand command);

   /**
    * Walks the command through the interceptor chain. The received ctx is being passed in.
    */
   CompletableFuture