@Override public List<T> multiGet(List<List<Object>> keys) { return _backing.multiGet(keys); }
@Override public List<T> multiUpdate(List<List<Object>> keys, List<ValueUpdater> updaters) { List<T> curr = _backing.multiGet(keys); List<T> ret = new ArrayList<T>(curr.size()); for (int i = 0; i < curr.size(); i++) { T currVal = curr.get(i); ValueUpdater<T> updater = updaters.get(i); ret.add(updater.update(currVal)); } _backing.multiPut(keys, ret); return ret; }
@Override public void multiPut(List<List<Object>> keys, List<T> vals) { _backing.multiPut(keys, vals); }
@Override public void multiPut(List<List<Object>> keys, List<T> values) { cache(keys, values); _delegate.multiPut(keys, values); }
public List<RetVal<T>> multiGet(List<List<Object>> keys) { // TODO: can optimize further by only querying backing map for keys not in the cache List<T> vals = _delegate.multiGet(keys); List<RetVal<T>> ret = new ArrayList(vals.size()); for (int i = 0; i < keys.size(); i++) { List<Object> key = keys.get(i); if (_cached.containsKey(key)) { ret.add(new RetVal(_cached.get(key), true)); } else { ret.add(new RetVal(vals.get(i), false)); } } return ret; }
@Override public List<T> multiUpdate(List<List<Object>> keys, List<ValueUpdater> updaters) { List<T> curr = _backing.multiGet(keys); List<T> ret = new ArrayList<T>(curr.size()); for(int i=0; i<curr.size(); i++) { T currVal = curr.get(i); ValueUpdater<T> updater = updaters.get(i); ret.add(updater.update(currVal)); } _backing.multiPut(keys, ret); return ret; }
public void multiPut(List<List<Object>> keys, List<T> vals) { _delegate.multiPut(keys, vals); cache(keys, vals); }
@Override public List<T> multiGet(final List<List<Object>> keys) { int thisBatchSize; if (_options.maxMultiGetBatchSize == 0) { thisBatchSize = keys.size(); } else { thisBatchSize = _options.maxMultiGetBatchSize; } LinkedList<List<Object>> keysTodo = new LinkedList<List<Object>>(keys); List<T> ret = new ArrayList<T>(keys.size()); while (!keysTodo.isEmpty()) { List<List<Object>> keysBatch = new ArrayList<List<Object>>(thisBatchSize); for (int i = 0; i < thisBatchSize && !keysTodo.isEmpty(); i++) { keysBatch.add(keysTodo.removeFirst()); } List<T> retSubset = _delegate.multiGet(keysBatch); ret.addAll(retSubset); } return ret; }
@Override public void multiPut(final List<List<Object>> keys, final List<T> values) { int thisBatchSize; if (_options.maxMultiPutBatchSize == 0) { thisBatchSize = keys.size(); } else { thisBatchSize = _options.maxMultiPutBatchSize; } LinkedList<List<Object>> keysTodo = new LinkedList<List<Object>>(keys); LinkedList<T> valuesTodo = new LinkedList<T>(values); while (!keysTodo.isEmpty()) { List<List<Object>> keysBatch = new ArrayList<List<Object>>(thisBatchSize); List<T> valuesBatch = new ArrayList<T>(thisBatchSize); for (int i = 0; i < thisBatchSize && !keysTodo.isEmpty(); i++) { keysBatch.add(keysTodo.removeFirst()); valuesBatch.add(valuesTodo.removeFirst()); } _delegate.multiPut(keysBatch, valuesBatch); } }
@Override public List<T> multiGet(List<List<Object>> keys) { Map<List<Object>, T> results = new HashMap<List<Object>, T>(); List<List<Object>> toGet = new ArrayList<List<Object>>(); for (List<Object> key : keys) { if (_cache.containsKey(key)) { results.put(key, _cache.get(key)); } else { toGet.add(key); } } List<T> fetchedVals = _delegate.multiGet(toGet); for (int i = 0; i < toGet.size(); i++) { List<Object> key = toGet.get(i); T val = fetchedVals.get(i); _cache.put(key, val); results.put(key, val); } List<T> ret = new ArrayList<T>(keys.size()); for (List<Object> key : keys) { ret.add(results.get(key)); } return ret; }
@Override public void multiPut(List<List<Object>> keys, List<T> vals) { _backing.multiPut(keys, vals); }
@Override public List<T> multiGet(List<List<Object>> keys) { return _backing.multiGet(keys); }
@Override public void multiPut(List<List<Object>> keys, List<T> values) { cache(keys, values); _delegate.multiPut(keys, values); }
@Override public List<T> multiGet(final List<List<Object>> keys) { int thisBatchSize; if(_options.maxMultiGetBatchSize == 0) { thisBatchSize = keys.size(); } else { thisBatchSize = _options.maxMultiGetBatchSize; } LinkedList<List<Object>> keysTodo = new LinkedList<List<Object>>(keys); List<T> ret = new ArrayList<T>(keys.size()); while(!keysTodo.isEmpty()) { List<List<Object>> keysBatch = new ArrayList<List<Object>>(thisBatchSize); for(int i=0; i<thisBatchSize && !keysTodo.isEmpty(); i++) { keysBatch.add(keysTodo.removeFirst()); } List<T> retSubset = _delegate.multiGet(keysBatch); ret.addAll(retSubset); } return ret; } }
public void multiPut(List<List<Object>> keys, List<T> vals) { _delegate.multiPut(keys, vals); cache(keys, vals); }
public List<RetVal<T>> multiGet(List<List<Object>> keys) { // TODO: can optimize further by only querying backing map for keys not in the cache List<T> vals = _delegate.multiGet(keys); List<RetVal<T>> ret = new ArrayList(vals.size()); for(int i=0; i<keys.size(); i++) { List<Object> key = keys.get(i); if(_cached.containsKey(key)) { ret.add(new RetVal(_cached.get(key), true)); } else { ret.add(new RetVal(vals.get(i), false)); } } return ret; }
@Override public void multiPut(final List<List<Object>> keys, final List<T> values) { int thisBatchSize; if(_options.maxMultiPutBatchSize == 0) { thisBatchSize = keys.size(); } else { thisBatchSize = _options.maxMultiPutBatchSize; } LinkedList<List<Object>> keysTodo = new LinkedList<List<Object>>(keys); LinkedList<T> valuesTodo = new LinkedList<T>(values); while(!keysTodo.isEmpty()) { List<List<Object>> keysBatch = new ArrayList<List<Object>>(thisBatchSize); List<T> valuesBatch = new ArrayList<T>(thisBatchSize); for(int i=0; i<thisBatchSize && !keysTodo.isEmpty(); i++) { keysBatch.add(keysTodo.removeFirst()); valuesBatch.add(valuesTodo.removeFirst()); } _delegate.multiPut(keysBatch, valuesBatch); } }
@Override public List<T> multiGet(List<List<Object>> keys) { Map<List<Object>, T> results = new HashMap<List<Object>, T>(); List<List<Object>> toGet = new ArrayList<List<Object>>(); for(List<Object> key: keys) { if(_cache.containsKey(key)) { results.put(key, _cache.get(key)); } else { toGet.add(key); } } List<T> fetchedVals = _delegate.multiGet(toGet); for(int i=0; i<toGet.size(); i++) { List<Object> key = toGet.get(i); T val = fetchedVals.get(i); _cache.put(key, val); results.put(key, val); } List<T> ret = new ArrayList<T>(keys.size()); for(List<Object> key: keys) { ret.add(results.get(key)); } return ret; }