Class AbstractListenerImpl<T,​L extends ListenerInvocation<T>>

    • Constructor Detail

      • AbstractListenerImpl

        public AbstractListenerImpl()
    • Method Detail

      • stop

        public void stop()
        Removes all listeners from the notifier
      • getLog

        protected abstract org.infinispan.util.logging.Log getLog()
      • hasListener

        public boolean hasListener​(Class<? extends Annotation> annotationClass)
      • getListenerCollectionForAnnotation

        protected List<L> getListenerCollectionForAnnotation​(Class<? extends Annotation> annotation)
      • composeStageIfNeeded

        protected static AggregateCompletionStage<Void> composeStageIfNeeded​(AggregateCompletionStage<Void> aggregateCompletionStage,
                                                                             CompletionStage<Void> stage)
        If the given stage is null or normally completed returns the provided aggregateCompletionStage as is. Otherwise the stage is used as a dependant for the provided aggregateCompletionStage if provided or a new one is created that depends upon the provided stage. The existing or new aggregateCompletionStage is then returned to the caller.
        Parameters:
        aggregateCompletionStage - the existing composed stage or null
        stage - the stage to rely upon
        Returns:
        null or a composed stage that relies upon the provided stage
      • removeListenerFromMaps

        protected void removeListenerFromMaps​(Object listener)
      • removeListenerInvocation

        protected Set<L> removeListenerInvocation​(Class<? extends Annotation> annotation,
                                                  Object listener)
      • getListeners

        public Set<Object> getListeners()
      • validateAndAddListenerInvocations

        protected boolean validateAndAddListenerInvocations​(Object listener,
                                                            AbstractListenerImpl.AbstractInvocationBuilder builder)
        Loops through all valid methods on the object passed in, and caches the relevant methods as ListenerInvocation for invocation by reflection. The builder provided will be used to create the listener invocations. This method will set the target, subject sync, and methods as needed. If other values are needed to be set they should be invoked before passing to this method.
        Parameters:
        listener - object to be considered as a listener.
        builder - The builder to use to build the invocation
        Returns:
        true if annotated listener methods were found or false otherwise
      • testListenerClassValidity

        protected static Listener testListenerClassValidity​(Class<?> listenerClass)
        Tests if a class is properly annotated as a CacheListener and returns the Listener annotation.
        Parameters:
        listenerClass - class to inspect
        Returns:
        the Listener annotation
      • testListenerMethodValidity

        protected static void testListenerMethodValidity​(Method m,
                                                         Class<?> allowedParameter,
                                                         String annotationName)
        Tests that a method is a valid listener method, that is that it has a single argument that is assignable to allowedParameter. The method must also return either void or a CompletionStage, meaning the method promises not block.
        Parameters:
        m - method to test
        allowedParameter - what parameter is allowed for the method argument
        annotationName - name of the annotation
        Throws:
        IncorrectListenerException - if the listener is not a valid target
      • handleException

        protected void handleException​(Throwable t)
      • suspendIfNeeded

        protected abstract javax.transaction.Transaction suspendIfNeeded()
      • resumeIfNeeded

        protected abstract void resumeIfNeeded​(javax.transaction.Transaction transaction)