Examples with MapEventTransformer com.tangosol.util.MapEventTransformer used on opensource projects

Example 1 with MapEventTransformer

use of com.tangosol.util.MapEventTransformer in project coherence-spring by coherence-community.

the class MapListenerRegistrationBean method registerMapListeners.

/**
 * Listen for {@link com.tangosol.net.events.partition.cache.CacheLifecycleEvent.Type#CREATED Created}
 * {@link com.tangosol.net.events.partition.cache.CacheLifecycleEvent CacheLifecycleEvents}
 * and register relevant map listeners when caches are created.
 * @param event the {@link com.tangosol.net.events.partition.cache.CacheLifecycleEvent}
 */
@CoherenceEventListener
@SuppressWarnings({ "rawtypes", "unchecked" })
void registerMapListeners(@Created CacheLifecycleEvent event) {
    String cacheName = event.getCacheName();
    String eventScope = event.getScopeName();
    String eventSession = event.getSessionName();
    String eventService = event.getServiceName();
    Set<AnnotatedMapListener<?, ?>> setListeners = getMapListeners(removeScope(eventService), cacheName);
    Session session = Coherence.findSession(eventSession).orElseThrow(() -> new IllegalStateException("Cannot find a Session with name " + eventSession));
    NamedCache cache = session.getCache(cacheName);
    for (AnnotatedMapListener<?, ?> listener : setListeners) {
        if (listener.hasFilterAnnotation()) {
            // ensure that the listener's filter has been resolved as this
            // was not possible as discovery time.
            listener.setFilter(this.filterService.resolve(listener.getFilterAnnotations()));
        }
        if (listener.hasTransformerAnnotation()) {
            // ensure that the listener's transformer has been resolved as this
            // was not possible at discovery time.
            listener.resolveTransformer(this.mapEventTransformerService);
        }
        String sScope = listener.getScopeName();
        boolean fScopeOK = sScope == null || sScope.equals(eventScope);
        String sSession = listener.getSession();
        boolean fSessionOK = sSession == null || sSession.equals(eventSession);
        if (fScopeOK && fSessionOK) {
            Filter filter = listener.getFilter();
            if (filter != null && !(filter instanceof MapEventFilter)) {
                filter = new MapEventFilter(MapEventFilter.E_ALL, filter);
            }
            MapEventTransformer transformer = listener.getTransformer();
            if (transformer != null) {
                filter = new MapEventTransformerFilter(filter, transformer);
            }
            try {
                boolean fLite = listener.isLiteEvent();
                if (listener.isSynchronous()) {
                    cache.addMapListener(listener.synchronous(), filter, fLite);
                } else {
                    cache.addMapListener(listener, filter, fLite);
                }
            } catch (Exception ex) {
                throw Exceptions.ensureRuntimeException(ex);
            }
        }
    }
}

Example 2 with MapEventTransformer

use of com.tangosol.util.MapEventTransformer in project coherence-spring by coherence-community.

the class MapEventTransformerService method resolve.

/**
 * Resolve a {@link MapEventTransformer} from the
 * specified qualifier annotations.
 * @param annotations  the qualifier annotations to use to create the transformer
 * @param <K>          the type of the keys of the entry to be transformed
 * @param <V>          the type of the values of the entry to be transformed
 * @param <U>          the type of the transformed values
 * @return a {@link MapEventTransformer} from the specified qualifier annotations
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
public <K, V, U> MapEventTransformer<K, V, U> resolve(Set<Annotation> annotations) {
    Optional<Annotation> optionalTransformer = annotations.stream().filter((annotation) -> annotation.annotationType().isAnnotationPresent(MapEventTransformerBinding.class)).findFirst();
    Optional<Annotation> optionalExtractor = annotations.stream().filter((annotation) -> annotation.annotationType().isAnnotationPresent(ExtractorBinding.class)).findFirst();
    if (optionalTransformer.isPresent()) {
        final Annotation annotation = optionalTransformer.get();
        final Class<? extends Annotation> annotationType = annotation.annotationType();
        final MapEventTransformerFactory factory = CoherenceAnnotationUtils.getSingleBeanWithAnnotation(this.applicationContext, annotationType);
        return factory.create(annotation);
    } else if (optionalExtractor.isPresent()) {
        // there is one or more ExtractorBinding annotations
        ValueExtractor<Object, Object> extractor = this.extractorFactory.resolve(annotations);
        return new ExtractorEventTransformer(extractor);
    }
    // there are no transformer or extractor annotations.
    return null;
}

Example 3 with MapEventTransformer

use of com.tangosol.util.MapEventTransformer in project micronaut-coherence by micronaut-projects.

the class MapEventTransformerFactories method resolve.

/**
 * Resolve a {@link com.tangosol.util.MapEventTransformer} from the
 * specified qualifier annotations.
 *
 * @param annotations  the qualifier annotations to use to create the transformer
 * @param <K>          the type of the keys of the entry to be transformed
 * @param <V>          the type of the values of the entry to be transformed
 * @param <U>          the type of the transformed values
 *
 * @return a {@link com.tangosol.util.MapEventTransformer} from the
 *         specified qualifier annotations
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
public <K, V, U> MapEventTransformer<K, V, U> resolve(Set<Annotation> annotations) {
    Optional<Annotation> optionalTransformer = annotations.stream().filter(a -> a.annotationType().isAnnotationPresent(MapEventTransformerBinding.class)).findFirst();
    Optional<Annotation> optionalExtractor = annotations.stream().filter(a -> a.annotationType().isAnnotationPresent(ExtractorBinding.class)).findFirst();
    if (optionalTransformer.isPresent()) {
        Annotation annotation = optionalTransformer.get();
        Class<? extends Annotation> type = annotation.annotationType();
        MapEventTransformerFactory factory = ctx.findBean(MapEventTransformerFactory.class, new FactoryQualifier<>(type)).orElse(null);
        if (factory != null) {
            return factory.create(annotation);
        } else {
            throw new IllegalStateException("Unsatisfied dependency - no MapEventTransformerFactory bean found annotated with " + annotation);
        }
    } else if (optionalExtractor.isPresent()) {
        // there is one or more ExtractorBinding annotations
        ValueExtractor<Object, Object> extractor = extractorFactory.resolve(annotations);
        return new ExtractorEventTransformer(extractor);
    }
    // there are no transformer or extractor annotations.
    return null;
}

Example 4 with MapEventTransformer

use of com.tangosol.util.MapEventTransformer in project micronaut-coherence by micronaut-projects.

the class CoherenceEventListenerProcessor method registerMapListeners.

/**
 * Listen for {@link com.tangosol.net.events.partition.cache.CacheLifecycleEvent.Type#CREATED Created}
 * {@link com.tangosol.net.events.partition.cache.CacheLifecycleEvent CacheLifecycleEvents}
 * and register relevant map listeners when caches are created.
 *
 * @param event the {@link com.tangosol.net.events.partition.cache.CacheLifecycleEvent}
 */
@CoherenceEventListener
@SuppressWarnings({ "rawtypes", "unchecked" })
void registerMapListeners(@Created CacheLifecycleEvent event) {
    String cacheName = event.getCacheName();
    String eventScope = event.getScopeName();
    String eventSession = event.getSessionName();
    String eventService = event.getServiceName();
    Set<AnnotatedMapListener<?, ?>> setListeners = getMapListeners(removeScope(eventService), cacheName);
    Session session = Coherence.findSession(eventSession).orElseThrow(() -> new IllegalStateException("Cannot find a Session with name " + eventSession));
    NamedCache cache = session.getCache(cacheName);
    for (AnnotatedMapListener<?, ?> listener : setListeners) {
        if (listener.hasFilterAnnotation()) {
            // ensure that the listener's filter has been resolved as this
            // was not possible as discovery time.
            listener.resolveFilter(filterProducer);
        }
        if (listener.hasTransformerAnnotation()) {
            // ensure that the listener's transformer has been resolved as this
            // was not possible as discovery time.
            listener.resolveTransformer(transformerProducer);
        }
        String sScope = listener.getScopeName();
        boolean fScopeOK = sScope == null || sScope.equals(eventScope);
        String sSession = listener.getSessionName();
        boolean fSessionOK = sSession == null || sSession.equals(eventSession);
        if (fScopeOK && fSessionOK) {
            Filter filter = listener.getFilter();
            if (filter != null && !(filter instanceof MapEventFilter)) {
                filter = new MapEventFilter(MapEventFilter.E_ALL, filter);
            }
            MapEventTransformer transformer = listener.getTransformer();
            if (transformer != null) {
                filter = new MapEventTransformerFilter(filter, transformer);
            }
            try {
                boolean fLite = listener.isLite();
                if (listener.isSynchronous()) {
                    cache.addMapListener(listener.synchronous(), filter, fLite);
                } else {
                    cache.addMapListener(listener, filter, fLite);
                }
            } catch (Exception e) {
                throw Exceptions.ensureRuntimeException(e);
            }
        }
    }
}