@Override public Flowable<Entry<K, V>> call() throws Exception { Flowable<Entry<K, V>> result = base.apply(keys); return result; } }
@Override public Flowable<Entry<K, O>> apply(Iterable<K> keys) { Flowable<Entry<K, I>> base = delegate.apply(keys); Flowable<Entry<K, O>> result = transform.apply(base); return result; } }
/** * Requests a map. * * The 'Single' result type can be seen as representing the request. * * @param keys * @return */ default Single<Map<K, V>> requestMap(Iterable<K> keys) { Single<Map<K, V>> result = apply(keys) .toMap(Entry::getKey, Entry::getValue); return result; }
@Override public Flowable<Entry<K, V>> apply(Iterable<K> t) { List<K> keys = Streams.stream(t) .filter(key -> filter.test(key)) .collect(Collectors.toList()); return delegate.apply(keys); } }
@Override public Flowable<Entry<K, W>> apply(Iterable<K> keys) { Flowable<Entry<K, V>> tmp = base.apply(keys); Flowable<Entry<K, W>> result = tmp.map(e-> Maps.immutableEntry(e.getKey(), fn.apply(e.getKey(), e.getValue()))); // Map<K, W> result = tmp.entrySet().stream() // .collect(Collectors.toMap( // e -> e.getKey(), // e -> fn.apply(e.getKey(), e.getValue()), // (u, v) -> { throw new IllegalStateException(String.format("Duplicate key %s", u)); }, // LinkedHashMap::new)); // // // //Maps.transformValues(tmp, GuavaFunctionWrapper.wrap(fn)); return result; }
@Override public Flowable<Entry<K, V>> apply(Iterable<K> keys) { Map<K, V> cachedEntries = cache.getAllPresent(keys); Set<K> remaining = Sets.difference(Sets.newHashSet(keys), cachedEntries.keySet()); Flowable<Entry<K, V>> result = Flowable .fromIterable(cachedEntries.entrySet()) .concatWith(base.apply(remaining)); return result; }
@Override public Flowable<Entry<KI, V>> apply(Iterable<KI> keys) { Iterable<KO> kos = Iterables.transform(keys, to); Flowable<Entry<KO, V>> tmp = delegate.apply(kos); Flowable<Entry<KI, V>> result = tmp.map(entry -> { KI ki = from.apply(entry); V v = entry.getValue(); return Maps.immutableEntry(ki, v); }); // Map<KI, V> result = new LinkedHashMap<KI, V>(); // for(Entry<KO, V> entry : tmp.entrySet()) { // KI ki = from.apply(entry); // V v = entry.getValue(); // result.put(ki, v); // } return result; }
default Single<List<V>> requestList(Iterable<K> keys) { Single<List<V>> result = apply(keys) .map(Entry::getValue) .toList(); return result; }
Flowable<Entry<KO, V>> tmp = delegate.apply(keyMap.keySet());
@Override public Flowable<O> apply(Range<Long> range) { Flowable<I> baseInStream = base.apply(range); Flowable<O> result = baseInStream.buffer(batchSize).flatMap(batch -> { // Map<I, O> map Flowable<O> r = lookup.apply(batch).map(Entry::getValue); return r; }); // Stream<O> result = StreamUtils.mapToBatch(baseInStream, batchSize) // .flatMap(batch -> { // Map<I, O> map = lookup.apply(batch); // Collection<O> values = map.values(); // // return values.stream(); // }); return result; }