@Override public Iterator<T> iterator() { return Iterators.limit(iterable.iterator(), limitSize); }
@Override public Iterator<T> iterator() { return Iterators.limit(iterable.iterator(), limitSize); } };
@Override public Iterator<T> iterator() { return Iterators.limit(iterable.iterator(), limitSize); }
@Override protected Iterator<Integer> newTargetIterator() { return Iterators.limit(Lists.newArrayList(list).iterator(), 3); } }.test();
public static ImmutableConciseSet union(Iterator<ImmutableConciseSet> sets) { ImmutableConciseSet partialResults = doUnion(Iterators.limit(sets, CHUNK_SIZE)); while (sets.hasNext()) { final UnmodifiableIterator<ImmutableConciseSet> partialIter = Iterators.singletonIterator(partialResults); partialResults = doUnion(Iterators.concat(partialIter, Iterators.limit(sets, CHUNK_SIZE))); } return partialResults; }
public static ImmutableConciseSet intersection(Iterator<ImmutableConciseSet> sets) { ImmutableConciseSet partialResults = doIntersection(Iterators.limit(sets, CHUNK_SIZE)); while (sets.hasNext()) { final UnmodifiableIterator<ImmutableConciseSet> partialIter = Iterators.singletonIterator(partialResults); partialResults = doIntersection( Iterators.concat(Iterators.limit(sets, CHUNK_SIZE), partialIter) ); } return partialResults; }
public static <T> CloseableIterator<T> limit(final Iterator<T> iterator, int maxElements) { Iterator<T> limitedNotCloseable = Iterators.limit(iterator, maxElements); Closeable closeable = iterator instanceof Closeable ? (Closeable) iterator : null; return new CloseableIteratorAdapter<T>(limitedNotCloseable, closeable); }
public void testLimitRemove() { List<String> list = newArrayList(); list.add("cool"); list.add("pants"); Iterator<String> iterator = Iterators.limit(list.iterator(), 1); iterator.next(); iterator.remove(); assertFalse(iterator.hasNext()); assertEquals(1, list.size()); assertEquals("pants", list.get(0)); }
public void testLimit() { List<String> list = newArrayList(); try { Iterators.limit(list.iterator(), -1); fail("expected exception"); } catch (IllegalArgumentException expected) { } assertFalse(Iterators.limit(list.iterator(), 0).hasNext()); assertFalse(Iterators.limit(list.iterator(), 1).hasNext()); list.add("cool"); assertFalse(Iterators.limit(list.iterator(), 0).hasNext()); assertEquals(list, newArrayList(Iterators.limit(list.iterator(), 1))); assertEquals(list, newArrayList(Iterators.limit(list.iterator(), 2))); list.add("pants"); assertFalse(Iterators.limit(list.iterator(), 0).hasNext()); assertEquals(ImmutableList.of("cool"), newArrayList(Iterators.limit(list.iterator(), 1))); assertEquals(list, newArrayList(Iterators.limit(list.iterator(), 2))); assertEquals(list, newArrayList(Iterators.limit(list.iterator(), 3))); }
Iterator<String> pathsIt = allPaths.iterator(); while (pathsIt.hasNext()) { Iterator<String> limitedIterator = Iterators.limit(pathsIt, numTasksPerMapper); splits.add(new GobblinSplit(Lists.newArrayList(limitedIterator)));
@Override public ListBlobsResult listBlobs(String session) throws TException { Iterator<String> keysIter; if (StringUtils.isBlank(session)) { keysIter = data.getBlobStore().listKeys(); } else { keysIter = (Iterator) data.getBlobListers().get(session); } if (keysIter == null) { throw new TException("Blob list for session " + session + " not exist (or time out)"); } // Create a new session id if the user gave an empty session string. // This is the use case when the user wishes to list blobs // starting from the beginning. if (StringUtils.isBlank(session)) { session = UUID.randomUUID().toString(); LOG.info("Creating new session for downloading list {}", session); } if (!keysIter.hasNext()) { data.getBlobListers().remove(session); LOG.info("No more blobs to list for session {}", session); return new ListBlobsResult(new ArrayList<String>(0), session); } else { List<String> listChunk = Lists.newArrayList(Iterators.limit(keysIter, 100)); LOG.info("{} downloading {} entries", session, listChunk.size()); data.getBlobListers().put(session, keysIter); return new ListBlobsResult(listChunk, session); } }
@Override protected Iterator<E> flatMap(final Traverser.Admin<Element> traverser) { if (useMultiQuery) { //it is guaranteed that all elements are vertices assert multiQueryResults != null; return convertIterator(multiQueryResults.get(traverser.get())); } else if (traverser.get() instanceof Vertex) { TitanVertexQuery query = makeQuery((TitanTraversalUtil.getTitanVertex(traverser)).query()); return convertIterator(query.properties()); } else { //It is some other element (edge or vertex property) Iterator<E> iter; if (getReturnType().forValues()) { assert orders.isEmpty() && hasContainers.isEmpty(); iter = traverser.get().values(getPropertyKeys()); } else { //this asks for properties assert orders.isEmpty(); //HasContainers don't apply => empty result set if (!hasContainers.isEmpty()) return Collections.emptyIterator(); iter = (Iterator<E>) traverser.get().properties(getPropertyKeys()); } if (limit!=Query.NO_LIMIT) iter = Iterators.limit(iter,limit); return iter; } }
@Override protected Iterator<E> flatMap(final Traverser.Admin<Element> traverser) { if (useMultiQuery) { //it is guaranteed that all elements are vertices assert multiQueryResults != null; return convertIterator(multiQueryResults.get(traverser.get())); } else if (traverser.get() instanceof JanusGraphVertex || traverser.get() instanceof WrappedVertex) { final JanusGraphVertexQuery query = makeQuery((JanusGraphTraversalUtil.getJanusGraphVertex(traverser)).query()); return convertIterator(query.properties()); } else { //It is some other element (edge or vertex property) Iterator<E> iterator; if (getReturnType().forValues()) { assert orders.isEmpty() && hasContainers.isEmpty(); iterator = traverser.get().values(getPropertyKeys()); } else { //this asks for properties assert orders.isEmpty(); //HasContainers don't apply => empty result set if (!hasContainers.isEmpty()) return Collections.emptyIterator(); iterator = (Iterator<E>) traverser.get().properties(getPropertyKeys()); } if (limit!=Query.NO_LIMIT) iterator = Iterators.limit(iterator,limit); return iterator; } }
private Map<Cell, Value> getValuesForRow(Map<byte[], RowColumnRangeIterator> values, byte[] row, int number) { Map<Cell, Value> results = Maps.newHashMap(); Iterator<Entry<Cell, Value>> it = values.entrySet().stream() .filter(entry -> Arrays.equals(row, entry.getKey())) .findFirst() .map(Entry::getValue) .map(value -> Iterators.limit(value, number)) .orElse(Collections.emptyIterator()); while (it.hasNext()) { Entry<Cell, Value> result = it.next(); results.put(result.getKey(), result.getValue()); } return results; }
public List<T> getBatch() { updateResultsIfNeeded(); Preconditions.checkState(lastBatchSize > 0); ImmutableList<T> list = ImmutableList.copyOf(Iterators.limit(currentResults, lastBatchSize)); numReturned += list.size(); if (!list.isEmpty()) { lastToken = batchProvider.getLastToken(list); } return list; }
public static <T> boolean isEqual(BatchingVisitable<T> v, final Iterator<T> it) { boolean ret = v.batchAccept(DEFAULT_BATCH_SIZE, batch -> { Iterator<T> toMatch = Iterators.limit(it, batch.size()); return Iterators.elementsEqual(toMatch, batch.iterator()); }); if (it.hasNext()) { return false; } return ret; }
@Override public int getNumberRemainingScrubCells(int maxCellsToScan) { try (ClosableIterator<RowResult<Value>> iterator = getIteratorToScrub(maxCellsToScan, Long.MAX_VALUE, null, null)) { return Iterators.size(Iterators.limit(iterator, maxCellsToScan)); } } }
try { int batchSize = requestWithHint.getBatchHint(); final Iterator<RowResult<Value>> withLimit = Iterators.limit(range, batchSize); ImmutableList<RowResult<Value>> results = ImmutableList.copyOf(withLimit); if (results.size() != batchSize) {
@Override public Iterator<T> iterator() { return Iterators.limit(iterable.iterator(), limitSize); } };
public static ImmutableConciseSet union(Iterator<ImmutableConciseSet> sets) { ImmutableConciseSet partialResults = doUnion(Iterators.limit(sets, CHUNK_SIZE)); while (sets.hasNext()) { final UnmodifiableIterator<ImmutableConciseSet> partialIter = Iterators.singletonIterator(partialResults); partialResults = doUnion(Iterators.<ImmutableConciseSet>concat(partialIter, Iterators.limit(sets, CHUNK_SIZE))); } return partialResults; }