public Object get(long id) { Object result; if (id >= 0 && id <= 0x00000000FFFFFFFFL) { result = this.ints.get((int) id); } else { result = this.longs.get(id); } return result; }
@Override public void record(long key) { policyStats.recordOperation(); Node node = data.get(key); if (node == null) { node = new Node(key); data.put(key,node); onMiss(node); } else if (node.status == Status.FILTER) { onFilterHit(node); } else if (node.status == Status.MAIN) { onMainHit(node); } else if (node.status == Status.NON_RESIDENT) { onNonResidentHit(node); } else { throw new IllegalStateException(); } }
@Override public void record(long key) { policyStats.recordOperation(); adapt(); Node node = data.get(key); if (node == null) { node = new Node(key); data.put(key, node); onMiss(node); } else if (node.status == Status.FILTER) { onFilterHit(node); } else if (node.status == Status.MAIN) { onMainHit(node); } else if (node.status == Status.NON_RESIDENT) { if (residentMain < maximumMainResidentSize) { checkState(residentFilter > maximumFilterSize); adaptFilterToMain(node); } else { onNonResidentHit(node); } } else { throw new IllegalStateException(); } }
@Override public void record(long key) { policyStats.recordOperation(); adapt(key); Node node = data.get(key); if (node == null) { node = new Node(key); data.put(key, node); onMiss(node); } else if (node.status == Status.FILTER) { onFilterHit(node); } else if (node.status == Status.MAIN) { onMainHit(node); } else if (node.status == Status.NON_RESIDENT) { if (residentMain < maximumMainResidentSize) { checkState(residentFilter > maximumFilterSize); adaptFilterToMain(node); } else { onNonResidentHit(node); } } else { throw new IllegalStateException(); } }
@Override public Result score(long user, long item) { KeyedObjectMap<Result> ur = userData.get(user); return ur != null ? ur.get(item) : null; }
@Nonnull @Override public ResultMap scoreWithDetails(long user, @Nonnull Collection<Long> items) { List<Result> rs = new ArrayList<>(items.size()); KeyedObjectMap<Result> userResults = userData.get(user); if (userResults != null) { LongIterator iter = LongIterators.asLongIterator(items.iterator()); while (iter.hasNext()) { long item = iter.nextLong(); Result r = userResults.get(item); if (r != null) { rs.add(r); } } } return Results.newResultMap(rs); }
/** * Find an order. * * @param orderId the order identifier * @return the order or {@code null} if the order identifier is unknown */ public Order find(long orderId) { return orders.get(orderId); }
/** * Get an order. * * @param orderId the order identifier * @return the order or <code>null</code> if the order identifier is unknown */ public Order get(long orderId) { return orders.get(orderId); }
/** * Find an order. * * @param orderId the order identifier * @return the order or {@code null} if the order identifier is unknown */ public Order find(long orderId) { return orders.get(orderId); }
SortedListAccumulator<Neighbor> heap = heaps.get(item); if (heap != null) { heap.add(nbr);
@Override public <T> T get(Class<T> entityType, long id) { return (T) map.get(entityType).get(id); }
public Object get(long id) { Object result; if (id >= 0 && id <= 0x00000000FFFFFFFFL) { result = this.ints.get((int) id); } else { result = this.longs.get(id); } return result; }
public void add(Read r) { long key = r.getSeq().getKmer(0, kmerSize); List<Read> entry = lookup.get(key); if (entry == null) { entry = new ArrayList<>(4); lookup.put(key, entry); } entry.add(r); } public void remove(Read r) {
private void lookupRemove(KmerNode node) { List<KmerNode> list = edgeLookup.get(node.lastKmer()); assert(list != null); boolean found = list.remove(node); assert(found); if (list.isEmpty()) { edgeLookup.remove(node.lastKmer()); } } private void firstKmerLookupAdd(KmerPathNode node) {
private void firstKmerLookupAdd(KmerPathNode node) { List<KmerPathNode> list = firstKmerEdgeLookup.get(node.firstKmer()); if (list == null) { list = new LinkedList<KmerPathNode>(); firstKmerEdgeLookup.put(node.firstKmer(), list); } list.add(node); } private void firstKmerLookupRemove(KmerNode node) {
private void firstKmerLookupRemove(KmerNode node) { List<KmerPathNode> list = firstKmerEdgeLookup.get(node.firstKmer()); assert(list != null); boolean found = list.remove(node); assert(found); if (list.isEmpty()) { firstKmerEdgeLookup.remove(node.firstKmer()); } } @Override
public void remove(Read r) { long key = r.getSeq().getKmer(0, kmerSize); List<Read> entry = lookup.get(key); assert(entry != null); if (entry.size() == 1) { lookup.remove(key); } else { // TODO: make this operation more efficient entry.remove(r); } } public List<Overlap> successors(Read r) {
@Override public Iterable<M> getVertexMessages( LongWritable vertexId) { DataInputOutput dataInputOutput = getPartitionMap(vertexId).get(vertexId.get()); if (dataInputOutput == null) { return EmptyIterable.get(); } else { return new MessagesIterable<M>(dataInputOutput, messageValueFactory); } }
private HashMap<String, GroupedValue> convert(MapResult mapResult) { HashMap<String, GroupedValue> ret = new HashMap<String, GroupedValue>(mapResult.results.size()); String[] temp = new String[mapResult.dictionaries.length]; int[] numBits = new int[columns.length]; for (int i = 0; i < columns.length; i++) { numBits[i] = BitHacks.findLogBase2(mapResult.dictionaries[i].size()) + 1; } for (long key : mapResult.results.keySet()) { ret.put(decodeKey(temp, mapResult.dictionaries, numBits, key), mapResult.results.get(key)); } return ret; }
private void addToLookup(int offset, long kmer, int start, int end, Long2ObjectOpenHashMap<RangeMap<Integer, Integer>> lookup) { RangeMap<Integer, Integer> rm = lookup.get(kmer); if (rm == null) { rm = TreeRangeMap.create(); lookup.put(kmer, rm); } rm.put(Range.closedOpen(start, end + 1), offset); } }