private void initializeHeaderOutLong() throws IOException { headerOutLong = new LongArrayList(); DataInput headerOutAsIntInput = new DataInputStream(headerOut.asInputStream()); for (int i = 0; i < numWritten; i++) { int count = headerOutAsIntInput.readInt(); headerOutLong.add(count); } }
private static long[] filterLongs(LongSet longSet, long[] source) { LongList longList = new LongArrayList(); for (long value : source) { if (longSet.contains(value)) { longList.add(value); } } if (longList.size() == source.length) { return source; } else { return longList.toLongArray(); } }
private long getOffset(int index) throws IOException { if (!requireMultipleFiles) { getOffsetBuffer.clear(); headerOut.readFully(index * (long) Integer.BYTES, getOffsetBuffer); return getOffsetBuffer.getInt(0); } else { return headerOutLong.getLong(index); } }
@Test public void testAddAndPrependUpgrade() { LongList list = new CompactableLongArrayList(); long val = Integer.MAX_VALUE + 42L; list.add(42); list.add(0, val); assertThat(list.size(), equalTo(2)); assertThat(list, contains(val, 42L)); assertThat(list.get(0), equalTo(val)); assertThat(list.get(1), equalTo(42L)); }
@Test(dataProvider = "cascade") public void cascade(long nanos, long timeout, int span) { timerWheel.schedule(new Timer(timeout)); timerWheel.advance(nanos); int count = 0; for (int i = 0; i < span; i++) { for (int j = 0; j < timerWheel.wheel[i].length; j++) { count += getTimers(timerWheel.wheel[i][j]).size(); } } assertThat("\n" + timerWheel.toString(), count, is(1)); }
tweetIds.add(rightNode); socialProofByType.put(leftNodes[i], tweetIds); || (tweetIds == null || !tweetIds.contains(rightNode))) { socialProofByType.put(leftNodes[i], tweetIds); if (tweetIds.size() < maxTweetSocialProofSize) { tweetIds.add(rightNode); if (tweetIds != null && tweetIds.size() < maxTweetSocialProofSize) { tweetIds.add(rightNode);
if(curPointer < numDocs) { frequency++; docPointers.add(curPointer); counts.add(iter.count()); IntArrayList thisDocPositions = new IntArrayList(iter.count()); for(int i = 0; i < frequency; i++) { OutputBitStream obs = indexWriter.newDocumentRecord(); indexWriter.writeDocumentPointer(obs, docPointers.get(i)); indexWriter.writePositionCount(obs, counts.get(i)); indexWriter.writeDocumentPositions(obs, positions.get(i)
@Nonnull @Override public ResultMap scoreWithDetails(long user, @Nonnull Collection<Long> items) { ResultMap results = primaryScorer.scoreWithDetails(user, items); List<Result> allResults = new ArrayList<>(items.size()); LongList toFetch = new LongArrayList(items.size() - results.size()); LongIterator iter = LongIterators.asLongIterator(items.iterator()); while (iter.hasNext()) { final long item = iter.nextLong(); Result r = results.get(item); if (r == null) { toFetch.add(item); } else { allResults.add(new FallbackResult(r, true)); } } if (!toFetch.isEmpty()) { for (Result r: baselineScorer.scoreWithDetails(user, toFetch)) { allResults.add(new FallbackResult(r, false)); } } return new BasicResultMap(allResults); }
/** * Shuffles the specified list using the specified pseudorandom number * generator. * * @param l * the list to be shuffled. * @param random * a pseudorandom number generator. * @return {@code l}. */ public static LongList shuffle(final LongList l, final Random random) { for (int i = l.size(); i-- != 0;) { final int p = random.nextInt(i + 1); final long t = l.getLong(i); l.set(i, l.getLong(p)); l.set(p, t); } return l; } /**
@Override public void pop() { if (DEBUG) { LOGGER.info("pop " + types.get(types.size() - 1) + " " + slots.getLong(slots.size() - 1)); } types.remove(types.size() - 1); slots.removeLong(slots.size() - 1); }
/** * Compute the ranks for a list of longs. * @param results The list of longs. * @return The map of ranks; its default return value will be -1. */ public static Long2IntMap itemRanks(LongList results) { Long2IntMap ranks = new Long2IntOpenHashMap(results.size()); ranks.defaultReturnValue(-1); LongListIterator iter = results.listIterator(); while (iter.hasNext()) { int i = iter.nextIndex(); long val = iter.nextLong(); ranks.put(val, i); } return ranks; }
/** * Finds the largest event file position recorded in the index that has timestamp smaller than or equal to the given * timestamp. * * @param timestamp Stream event timestamp to search for. * @return The file position or {@code -1} if no record satisfied the requirement can be found. */ long floorPositionByTime(long timestamp) { if (timestamps.isEmpty()) { return -1; } // Binary search for a timestamp that is larger than or equals to the given timestamp. int idx = binarySearch(timestamps, timestamp); if (idx >= 0) { return positions.getLong(idx); } // Return the position that has smaller timestamp than the one to search for. // If every timestamp in the index is larger than the given one, return -1. return idx == -1 ? -1 : positions.getLong(-idx - 2); }