@Test public void testGet() throws Exception { expectPeerMessage(clusterCommunicator); CountDownLatch latch; assertNull(ecMap.get(KEY1)); ecMap.put(KEY1, VALUE1); assertEquals(VALUE1, ecMap.get(KEY1)); List<UpdateEntry<String, String>> message = ImmutableList.of(generatePutMessage(KEY2, VALUE2, clockService.getTimestamp(KEY2, VALUE2))); latch = new CountDownLatch(1); ecMap.addListener(new TestListener(latch)); assertNull(ecMap.get(KEY2)); updateHandler.accept(message); assertTrue("External listener never got notified of internal event", latch.await(100, TimeUnit.MILLISECONDS)); assertEquals(VALUE2, ecMap.get(KEY2)); ecMap.remove(KEY2); assertNull(ecMap.get(KEY2)); message = ImmutableList.of(generateRemoveMessage(KEY1, clockService.getTimestamp(KEY1, VALUE1))); latch = new CountDownLatch(1); ecMap.addListener(new TestListener(latch)); updateHandler.accept(message); assertTrue("External listener never got notified of internal event", latch.await(100, TimeUnit.MILLISECONDS)); assertNull(ecMap.get(KEY1)); }
@Override public V get(K key) { checkState(!destroyed, destroyedMessage); checkNotNull(key, ERROR_NULL_KEY); MapValue<V> value = items.get(key); return (value == null || value.isTombstone()) ? null : value.get(); }
EventuallyConsistentMapImpl implements EventuallyConsistentMap<K, V> { @Override public V get(K key) { checkState(!destroyed, destroyedMessage); checkNotNull(key, ERROR_NULL_KEY); MapValue<V> value = items.get(key); return (value == null || value.isTombstone()) ? null : value.get(); } }
EventuallyConsistentMapImpl implements EventuallyConsistentMap<K, V> { @Override public V get(K key) { checkState(!destroyed, destroyedMessage); checkNotNull(key, ERROR_NULL_KEY); MapValue<V> value = items.get(key); return (value == null || value.isTombstone()) ? null : value.get(); } EventuallyConsistentMapImpl(String mapName,
                                ClusterService clusterService,
                                ClusterCommunicationService clusterCommunicator,
                                KryoNamespace ns,
                                BiFunction<K, V, Timestamp> timestampProvider,
                                BiFunction<K, V, Collection<NodeId>> peerUpdateFunction,
                                ExecutorService eventExecutor,
                                ExecutorService communicationExecutor,
                                ScheduledExecutorService backgroundExecutor,
                                boolean tombstonesDisabled,
                                long antiEntropyPeriod,
                                TimeUnit antiEntropyTimeUnit,
                                boolean convergeFaster,
                                boolean persistent,
                                PersistenceService persistenceService); }
EventuallyConsistentMapImpl implements EventuallyConsistentMap<K, V> { @Override public V get(K key) { checkState(!destroyed, destroyedMessage); checkNotNull(key, ERROR_NULL_KEY); MapValue<V> value = items.get(key); return (value == null || value.isTombstone()) ? null : value.get(); } EventuallyConsistentMapImpl(String mapName,
                                ClusterService clusterService,
                                ClusterCommunicationService clusterCommunicator,
                                KryoNamespace ns,
                                BiFunction<K, V, Timestamp> timestampProvider,
                                BiFunction<K, V, Collection<NodeId>> peerUpdateFunction,
                                ExecutorService eventExecutor,
                                ExecutorService communicationExecutor,
                                ScheduledExecutorService backgroundExecutor,
                                boolean tombstonesDisabled,
                                long antiEntropyPeriod,
                                TimeUnit antiEntropyTimeUnit,
                                boolean convergeFaster,
                                boolean persistent,
                                PersistenceService persistenceService); @Override String name(); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(K key); @Override boolean containsValue(V value); @Override V get(K key); @Override void put(K key, V value); @Override V remove(K key); @Override void remove(K key, V value); @Override V compute(K key, BiFunction<K, V, V> recomputeFunction); @Override void putAll(Map<? extends K, ? extends V> m); @Override void clear(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Map.Entry<K, V>> entrySet(); @Override void addListener(EventuallyConsistentMapListener<K, V> listener); @Override void removeListener(EventuallyConsistentMapListener<K, V> listener); @Override CompletableFuture<Void> destroy(); }
EventuallyConsistentMapImpl implements EventuallyConsistentMap<K, V> { @Override public V get(K key) { checkState(!destroyed, destroyedMessage); checkNotNull(key, ERROR_NULL_KEY); MapValue<V> value = items.get(key); return (value == null || value.isTombstone()) ? null : value.get(); } EventuallyConsistentMapImpl(String mapName,
                                ClusterService clusterService,
                                ClusterCommunicationService clusterCommunicator,
                                KryoNamespace ns,
                                BiFunction<K, V, Timestamp> timestampProvider,
                                BiFunction<K, V, Collection<NodeId>> peerUpdateFunction,
                                ExecutorService eventExecutor,
                                ExecutorService communicationExecutor,
                                ScheduledExecutorService backgroundExecutor,
                                boolean tombstonesDisabled,
                                long antiEntropyPeriod,
                                TimeUnit antiEntropyTimeUnit,
                                boolean convergeFaster,
                                boolean persistent,
                                PersistenceService persistenceService); @Override String name(); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(K key); @Override boolean containsValue(V value); @Override V get(K key); @Override void put(K key, V value); @Override V remove(K key); @Override void remove(K key, V value); @Override V compute(K key, BiFunction<K, V, V> recomputeFunction); @Override void putAll(Map<? extends K, ? extends V> m); @Override void clear(); @Override Set<K> keySet(); @Override Collection<V> values(); @Override Set<Map.Entry<K, V>> entrySet(); @Override void addListener(EventuallyConsistentMapListener<K, V> listener); @Override void removeListener(EventuallyConsistentMapListener<K, V> listener); @Override CompletableFuture<Void> destroy();  }