@CacheEntryModified
public void updated(CacheEntryModifiedEvent<String, Property<?>> event) {
    if (event.isPre()) {
        return;
    }

    Property<?> oldValue = (Property<?>) ((EventImpl) event).getOldValue();
    Property<?> newValue = event.getValue();

    if (!newValue.equals(oldValue)) {
        List<Observer> observers = this.observersMap.get(event.getKey());
        if (observers != null) {
            observers.forEach(observer -> observer.updated(newValue));
        }
    }
}
 

@CacheEntryModified
public void onModifiedNotifyTrigger(CacheEntryModifiedEvent cacheEvent) {
    if (cacheEvent.isPre()) {
        if (log.isDebugEnabled()) {
            log.debug("Discarding pre onModifiedNotifyTrigger(@CacheEntryModified) event");
        }
        return;
    }
    NotifyTrigger notifyTrigger = (NotifyTrigger)triggersCache.get(cacheEvent.getKey());
    if (log.isDebugEnabled()) {
        log.debugf("onModifiedNotifyTrigger(@CacheEntryModified) received on %s", currentNode);
        log.debugf("CacheEvent: %s", cacheEvent);
        log.debugf("NotifyTrigger: %s", notifyTrigger);
    }
    processNotifyTrigger(notifyTrigger);
}
 

@CacheEntryModified
public synchronized void eventReceived(CacheEntryModifiedEvent event) {
    Object key = event.getKey();
    Object value = event.getValue();

    if (LOGGER.isDebugEnabled()) LOGGER.debug("Received Suspend Event key=[{}] value=[{}]", key, value);

    if (Router.SUSPEND.equals(key)) {
        router.suspend();
    }

    if (Router.RESUME.equals(key)) {
        router.resume();
    }
}
 

@CacheEntryModified
public synchronized void eventReceived(CacheEntryModifiedEvent event) {
    Object key = event.getKey();
    Object value = event.getValue();
    if (LOGGER.isDebugEnabled()) LOGGER.debug("Received MODIFIED key on INFOS key=[{}] value=[{}]", key, value);
    if ((RulesManager.RULES_ARTIFACT_ID.equals(key) && !rulesManager.getReleaseId().getArtifactId().equals(key))
            || (RulesManager.RULES_GROUP_ID.equals(key) && !rulesManager.getReleaseId().getGroupId().equals(key))) {
        throw new IllegalStateException("Cannot change rules artifact or group id to [" + key + "].");
    }
    if (RulesManager.RULES_VERSION.equals(key)) {
        updateVersion((String) value);
    }
}
 

@CacheEntryModified
public synchronized void eventReceived(CacheEntryModifiedEvent event) {
    Object key = event.getKey();
    Object value = event.getValue();
    if (LOGGER.isDebugEnabled()) LOGGER.debug("Received MODIFIED key on INFOS key=[{}] value=[{}]", key, value);
    if (RulesManager.RULES_ARTIFACT_ID.equals(key) || RulesManager.RULES_GROUP_ID.equals(key)) {
        throw new IllegalStateException("Cannot change rules artifact or group id.");
    }
    if ( RulesManager.RULES_VERSION.equals(key) && !value.equals("1.0.0") ) {
        throw new RuntimeException( "Upgrade rules version failed!!!" );
    } else if ( RulesManager.RULES_VERSION.equals(key) ){
        updateVersion((String) value);
    }
}
 

public SubsCacheHelper(DefaultCacheManager cacheManager, NodeSelector nodeSelector) {
  @SuppressWarnings("unchecked")
  MultimapCacheManager<String, byte[]> multimapCacheManager = EmbeddedMultimapCacheManagerFactory.from(cacheManager);
  subsCache = (EmbeddedMultimapCache<String, byte[]>) multimapCacheManager.get("__vertx.subs");
  this.nodeSelector = nodeSelector;
  entryListener = new EntryListener();
  Set<Class<? extends Annotation>> filterAnnotations = Stream.<Class<? extends Annotation>>builder()
    .add(CacheEntryCreated.class)
    .add(CacheEntryModified.class)
    .add(CacheEntryRemoved.class)
    .build()
    .collect(toSet());
  subsCache.getCache()
    .addFilteredListener(entryListener, new EventFilter(), new EventConverter(), filterAnnotations);
}
 

@CacheEntryModified
public void onModifiedNotifyData(CacheEntryModifiedEvent cacheEvent) {
    if (cacheEvent.isPre()) {
        log.debug("Discarding pre onModifiedNotifyData(@CacheEntryModified) event");
        return;
    }
    NotifyData notifyData = (NotifyData)dataCache.get(cacheEvent.getKey());
    if (log.isDebugEnabled()) {
        log.debug("onModifiedNotifyData(@CacheEntryModified) received.");
        log.debugf("NotifyData: %s", notifyData);
    }
    processNotifyData(notifyData);
}
 

@CacheEntryModified
public void modified(CacheEntryModifiedEvent<Long, XOffering> event) {
	if (event.isPre()) {
		if (event.getValue() != null)
			removeCourses(event.getValue());
	} else {
		if (event.getValue() != null)
			addCourses(event.getValue());
	}
}
 

@CacheEntryModified
public void modified(CacheEntryModifiedEvent<Long, XStudent> event) {
	if (event.isPre()) {
		if (event.getValue() != null)
			removeRequests(event.getValue());
	} else {
		if (event.getValue() != null)
			addRequests(event.getValue());
	}
}
 

@CacheEntryModified
public void entryModified(CacheEntryModifiedEvent<String, Void> event) {
  fireRegistrationUpdateEvent(event.getKey());
}
 

@CacheEntryCreated
@CacheEntryModified
public void handle(CacheEntryEvent<String, EventAction> event) {
    String designId = event.getKey();
    EventAction action = event.getValue();
    ActionType type = action.getType();
    String id = action.getId();

    IEditingSessionExt session = sessions.get(designId);
    if (session != null && type != ActionType.CLOSE) {
        switch (type) {
            case SEND_TO_OTHERS:
                session.sendToOthers(action.toBaseOperation(), id);
                return;
            case SEND_TO_LIST:
                session.sendTo(id);
                return;
            case SEND_TO_EXECUTE:
                session.sendTo(action.getOps(), id);
                return;
            case CLOSE:
            case ROLLUP:
            default:
                break;
        }
    }

    // only do rollup once - on the event origin node
    if (type == ActionType.CLOSE && event.isOriginLocal()) {
        Map<String, Integer> map = counterCache.get(designId);
        int count = 0;
        // only count live nodes
        for (Address member : manager.getMembers()) {
            count += map.getOrDefault(member.toString(), 0);
        }
        if (count == 0) {
            try {
                rollup(designId);
            } finally {
                counterCache.remove(designId);
                eventActionCache.remove(designId);
            }
        }
    }
}
 

@CacheEntryModified
public void entryModified(CacheEntryModifiedEvent<String, String> event) {
   // We are only interested in the pre event
   if (event.isPre())
      System.out.printf("About to modify %s\n", event.getKey());
}
 

@CacheEntryModified
public void cacheEntryModified(CacheEntryModifiedEvent<String, Serializable> event) {
    eventReceived(event.getKey(), event.getValue());
}