@Override public int nextInt() { return conversionBuffer.get(baseIterator.nextInt()); }
@Override public LocalTime next() { return PackedLocalTime.asLocalTime(intIterator.nextInt()); } };
@Override public LocalDate next() { return PackedLocalDate.asLocalDate(intIterator.nextInt()); } };
MergeIntIterator(List<IntIterator> iterators) { this.iterators = iterators.toArray(new IntIterator[0]); pQueue = new long[iterators.size()]; pQueueSize = 0; for (int iterIndex = 0; iterIndex < this.iterators.length; iterIndex++) { IntIterator iter = this.iterators[iterIndex]; if (iter != null && iter.hasNext()) { pQueue[pQueueSize] = makeQueueElement(iter.nextInt(), iterIndex); pQueueSize++; LongHeaps.upHeap(pQueue, pQueueSize, pQueueSize - 1, null); } } }
/** * Implements {@link IntIterator#skip(int)}. */ public static int skip(IntIterator it, int n) { if (n < 0) { throw new IAE("n: " + n); } int skipped = 0; while (skipped < n && it.hasNext()) { it.nextInt(); skipped++; } return skipped; }
@Override public byte[] serialize(IntSet intSet) { int size = intSet.size(); byte[] bytes = new byte[Integer.BYTES + size * Integer.BYTES]; ByteBuffer byteBuffer = ByteBuffer.wrap(bytes); byteBuffer.putInt(size); IntIterator iterator = intSet.iterator(); while (iterator.hasNext()) { byteBuffer.putInt(iterator.nextInt()); } return bytes; }
@Override public AbstractInt2ObjectMap.BasicEntry<IntArrayList> next() { int key = setIerator.nextInt(); IntArrayList value = dataTable.get(key); return new AbstractInt2ObjectMap.BasicEntry<>(key, value); } }
public static IntList toIntList(IntIterator iterator) { final IntList integers = new IntArrayList(); while (iterator.hasNext()) { integers.add(iterator.nextInt()); } return IntLists.unmodifiable(integers); }
public SortedDimensionDictionary(List<String> idToValue, int length) { Object2IntSortedMap<String> sortedMap = new Object2IntRBTreeMap<>(Comparators.naturalNullsFirst()); for (int id = 0; id < length; id++) { String value = idToValue.get(id); sortedMap.put(value, id); } this.sortedVals = Lists.newArrayList(sortedMap.keySet()); this.idToIndex = new int[length]; this.indexToId = new int[length]; int index = 0; for (IntIterator iterator = sortedMap.values().iterator(); iterator.hasNext(); ) { int id = iterator.nextInt(); idToIndex[id] = index; indexToId[index] = id; index++; } }
default Selection isBefore(DateColumn column) { Selection results = new BitmapBackedSelection(); int i = 0; IntIterator intIterator = column.intIterator(); for (long next : data()) { if (next < intIterator.nextInt()) { results.add(i); } i++; } return results; }
default Selection isAfter(DateColumn column) { Selection results = new BitmapBackedSelection(); int i = 0; IntIterator intIterator = column.intIterator(); for (long next : data()) { if (next > intIterator.nextInt()) { results.add(i); } i++; } return results; }
@Override public int nextInt() { if (!hasNext()) { throw new NoSuchElementException(); } long queueHead = pQueue[0]; int retVal = value(queueHead); int iterIndex = iterIndex(queueHead); IntIterator retIt = iterators[iterIndex]; if (retIt.hasNext()) { // stay in the head, likely no elements will be moved in the heap pQueue[0] = makeQueueElement(retIt.nextInt(), iterIndex); LongHeaps.downHeap(pQueue, pQueueSize, 0, null); } else { pQueueSize--; if (pQueueSize != 0) { pQueue[0] = pQueue[pQueueSize]; LongHeaps.downHeap(pQueue, pQueueSize, 0, null); } } return retVal; }
private void checkBitmapIndex(List<Integer> expected, BitmapValues real) { Assert.assertEquals("bitmap size", expected.size(), real.size()); int i = 0; for (IntIterator iterator = real.iterator(); iterator.hasNext(); ) { int index = iterator.nextInt(); Assert.assertEquals(expected.get(i++), (Integer) index); } }
@Override public DateColumn removeMissing() { DateColumn noMissing = emptyCopy(); IntIterator iterator = intIterator(); while(iterator.hasNext()) { int i = iterator.nextInt(); if (!valueIsMissing(i)) { noMissing.appendInternal(i); } } return noMissing; }
@Override public Table first(int nRows) { Selection newMap = new BitmapBackedSelection(); int count = 0; IntIterator it = intIterator(); while (it.hasNext() && count < nRows) { int row = it.nextInt(); newMap.add(row); count++; } return table.where(newMap); }
@Override public TimeColumn removeMissing() { TimeColumn noMissing = emptyCopy(); IntIterator iterator = intIterator(); while(iterator.hasNext()) { int i = iterator.nextInt(); if (!valueIsMissing(i)) { noMissing.appendInternal(i); } } return noMissing; }
private WorkProcessor<Page> buildResult(IntIterator groupIds) { final PageBuilder pageBuilder = new PageBuilder(buildTypes()); return WorkProcessor.create(() -> { if (!groupIds.hasNext()) { return ProcessState.finished(); } pageBuilder.reset(); List<Type> types = groupByHash.getTypes(); while (!pageBuilder.isFull() && groupIds.hasNext()) { int groupId = groupIds.nextInt(); groupByHash.appendValuesTo(groupId, pageBuilder, 0); pageBuilder.declarePosition(); for (int i = 0; i < aggregators.size(); i++) { Aggregator aggregator = aggregators.get(i); BlockBuilder output = pageBuilder.getBlockBuilder(types.size() + i); aggregator.evaluate(groupId, output); } } return ProcessState.ofResult(pageBuilder.build()); }); }
/** {@inheritDoc} */ @Override public int nonZeroElements() { int res = 0; IntIterator rowIter = indexesMap().keySet().iterator(); while (rowIter.hasNext()) { int row = rowIter.nextInt(); res += indexesMap().get(row).size(); } return res; }
private static void assertEmpty(IntIterator it) { assertFalse(it.hasNext()); try { it.next(); fail("expected NoSuchElementException on it.next() after it.hasNext() = false"); } catch (NoSuchElementException ignore) { // expected } // expected to fail with NoSuchElementException it.nextInt(); }