@NamedFactory(name = "key-value-with-previous-converter-factory") public class KeyValueWithPreviousEventConverterFactory<K, V> implements CacheEventConverterFactory { private final KeyValueWithPreviousEventConverter<K, V> converter = new KeyValueWithPreviousEventConverter<K, V>(); @Override public CacheEventConverter<K, V, KeyValueWithPrevious<K, V>> getConverter(Object[] params) { return converter; } }
@Override public boolean accept(K key, V value, Metadata metadata) { return filter.accept(key, value, metadata); } }
private KeyValueFilter getFilter() { return primaryOwner ? new PrimaryOwnersKeyValueFilter() : AcceptAllKeyValueFilter.getInstance(); }
private KeyValuePair<KeyValueFilterConverter, Boolean> buildFilter(KeyValueFilterConverterFactory factory, byte[][] params, Function<Object, Object> unmarshallParam) { if (factory instanceof ParamKeyValueFilterConverterFactory) { ParamKeyValueFilterConverterFactory paramFactory = (ParamKeyValueFilterConverterFactory) factory; Object[] unmarshallParams; if (paramFactory.binaryParam()) { unmarshallParams = params; } else { unmarshallParams = Arrays.stream(params).map(unmarshallParam).toArray(); } return new KeyValuePair<>(paramFactory.getFilterConverter(unmarshallParams), paramFactory.binaryParam()); } else { return new KeyValuePair<>(factory.getFilterConverter(), false); } }
@Override public C convert(K key, V value, Metadata metadata) { return converter.convert(key, value, metadata); }
@NamedFactory(name = "static-converter-factory") public class StaticCacheEventConverterFactory implements CacheEventConverterFactory { @Override public CacheEventConverter<Integer, String, CustomEvent> getConverter(Object[] params) { return new StaticCacheEventConverter(); } static class StaticCacheEventConverter implements CacheEventConverter<Integer, String, CustomEvent>, Serializable { @Override public CustomEvent<Integer, String> convert(Integer key, String oldValue, Metadata oldMetadata, String newValue, Metadata newMetadata, EventType eventType) { return new CustomEvent<>(key, newValue); } } }
public static <K, V> MapCollectableCloseableIterable<K, V> entrySet(AdvancedCache<K, V> cache) { return entrySet(cache, (KeyValueFilter<K, V>) AcceptAllKeyValueFilter.getInstance()); }
@Override public Object filterAndConvert(K key, V value, Metadata metadata) { if ( filter.accept( key, value, metadata ) ) { return NullValue.getInstance(); } return null; }
@NamedFactory(name = TO_STRING_FILTER_CONVERTER_FACTORY_NAME) public static class CustomFilterFactory implements KeyValueFilterConverterFactory<Integer, User, String> { @Override public KeyValueFilterConverter<Integer, User, String> getFilterConverter() { return new CustomFilter(); } public static class CustomFilter extends AbstractKeyValueFilterConverter<Integer, User, String> implements Serializable { @Override public String filterAndConvert(Integer key, User value, Metadata metadata) { return value.toString(); } } }
private KeyValueFilter getFilter() { return primaryOwner ? new PrimaryOwnersKeyValueFilter() : AcceptAllKeyValueFilter.getInstance(); }
@NamedFactory(name = "static-filter-factory") public class StaticCacheEventFilterFactory implements CacheEventFilterFactory { @Override public CacheEventFilter<Integer, String> getFilter(final Object[] params) { return new StaticCacheEventFilter(); } static class StaticCacheEventFilter implements CacheEventFilter<Integer, String>, Serializable { final Integer staticKey = 2; @Override public boolean accept(Integer key, String oldValue, Metadata oldMetadata, String newValue, Metadata newMetadata, EventType eventType) { return staticKey.equals(key); } } }
@NamedFactory(name = "dynamic-filter-factory") public class DynamicCacheEventFilterFactory implements CacheEventFilterFactory { @Override public CacheEventFilter<Integer, String> getFilter(final Object[] params) { return new DynamicCacheEventFilter(params); } static class DynamicCacheEventFilter implements CacheEventFilter<Integer, String>, Serializable { private final Object[] params; public DynamicCacheEventFilter(Object[] params) { this.params = params; } @Override public boolean accept(Integer key, String oldValue, Metadata oldMetadata, String newValue, Metadata newMetadata, EventType eventType) { return params[0].equals(key); // dynamic } } }
@NamedFactory(name = PARAM_FILTER_CONVERTER_FACTORY_NAME) public static class ParamCustomFilterFactory implements ParamKeyValueFilterConverterFactory<Integer, User, String> { @Override public KeyValueFilterConverter<Integer, User, String> getFilterConverter(Object[] params) { return new ParamCustomFilter((Integer) params[0]); } public static class ParamCustomFilter extends AbstractKeyValueFilterConverter<Integer, User, String> implements Serializable { private final int maxLength; public ParamCustomFilter(int maxLength) { this.maxLength = maxLength; } @Override public String filterAndConvert(Integer key, User value, Metadata metadata) { return value.toString().substring(0, maxLength); } } } }
@NamedFactory(name = "dynamic-converter-factory") public class DynamicCacheEventConverterFactory implements CacheEventConverterFactory { @Override public CacheEventConverter<Integer, String, CustomEvent> getConverter(final Object[] params) { return new DynamicCacheEventConverter(params); } static class DynamicCacheEventConverter implements CacheEventConverter<Integer, String, CustomEvent>, Serializable { private final Object[] params; public DynamicCacheEventConverter(Object[] params) { this.params = params; } @Override public CustomEvent convert(Integer key, String oldValue, Metadata oldMetadata, String newValue, Metadata newMetadata, EventType eventType) { if (params[0].equals(key)) return new CustomEvent(key, null); return new CustomEvent(key, newValue); } } }
/** * @author gustavonalle * @since 8.0 */ @NamedFactory(name = "csv-key-value-filter-converter-factory") public class TestKeyValueFilterConverterFactory implements KeyValueFilterConverterFactory { @Override public KeyValueFilterConverter<String, SampleEntity, Summary> getFilterConverter() { return new SampleKeyValueFilterConverter(); } static class SampleKeyValueFilterConverter extends AbstractKeyValueFilterConverter<String, SampleEntity, Summary> implements Serializable { @Override public Summary filterAndConvert(String key, SampleEntity entity, Metadata metadata) { if ("ignore".equals(key)) { return null; } return new Summary(Arrays.asList(entity.getCsvAttributes().split(","))); } } }
@NamedFactory(name = "pojo-filter-factory") public class CustomPojoEventFilterFactory implements CacheEventFilterFactory { @Override public CacheEventFilter<Integer, Person> getFilter(Object[] params) { return new CustomPojoCacheEventFilter(params); } private static class CustomPojoCacheEventFilter implements CacheEventFilter<Integer, Person>, Serializable { private final Object[] params; private CustomPojoCacheEventFilter(Object[] params) { this.params = params; } @Override public boolean accept(Integer key, Person oldValue, Metadata oldMetadata, Person newValue, Metadata newMetadata, EventType eventType) { return newValue == null ? oldValue.getName().equals(params[0]) : newValue.getName().equals(params[0]); } } }
@NamedFactory(name = "pojo-converter-factory") public class CustomPojoEventConverterFactory implements CacheEventConverterFactory { @Override public CacheEventConverter<Integer, Person, CustomEvent> getConverter(final Object[] params) { return new DynamicCacheEventConverter(params); } static class DynamicCacheEventConverter implements CacheEventConverter<Integer, Person, CustomEvent>, Serializable { private final Object[] params; public DynamicCacheEventConverter(Object[] params) { this.params = params; } @Override public CustomEvent convert(Integer key, Person oldValue, Metadata oldMetadata, Person newValue, Metadata newMetadata, EventType eventType) { if (newValue == null || newValue.equals(params[0])) return new CustomEvent<Integer, Person>(key, null); return new CustomEvent<Integer, Person>(key, newValue); } } }
@NamedFactory(name = "pojo-filter-converter-factory") public class CustomPojoFilterConverterFactory implements CacheEventFilterConverterFactory { @Override public CacheEventFilterConverter<Id, Person, CustomEvent> getFilterConverter(Object[] params) { return new FilterConverter(params); } static class FilterConverter extends AbstractCacheEventFilterConverter<Id, Person, CustomEvent> implements Serializable { private final Object[] params; public FilterConverter(Object[] params) { this.params = params; } @Override public CustomEvent filterAndConvert(Id key, Person oldValue, Metadata oldMetadata, Person newValue, Metadata newMetadata, EventType eventType) { if (params[0].equals(key)) return new CustomEvent<Id, Person>(key, null); return new CustomEvent<Id, Person>(key, newValue); } } }
@NamedFactory(name = "filter-converter-factory") public class FilterConverterFactory implements CacheEventFilterConverterFactory { @Override public CacheEventFilterConverter<Integer, String, CustomEvent> getFilterConverter(Object[] params) { return new FilterConverter(params); } static class FilterConverter extends AbstractCacheEventFilterConverter<Integer, String, CustomEvent> implements Serializable { private final Object[] params; public FilterConverter(Object[] params) { this.params = params; } @Override public CustomEvent filterAndConvert(Integer key, String oldValue, Metadata oldMetadata, String newValue, Metadata newMetadata, EventType eventType) { if (params[0].equals(key)) return new CustomEvent(key, null); return new CustomEvent(key, newValue); } } }