PeekingIterator<Map.Entry<KeyExtent,Bulk.Files>> lmi = new PeekingIterator<>(loadMapIter); Map.Entry<KeyExtent,Bulk.Files> loadMapEntry = lmi.peek(); while (lmi.hasNext()) { loadMapEntry = lmi.next(); List<TabletMetadata> tablets = findOverlappingTablets(loadMapEntry.getKey(), tabletIter); loader.load(tablets, loadMapEntry.getValue());
@Override public boolean next(Text key, PeekingIterator<Entry<Key,Value>> value) throws IOException { if (!rowIterator.hasNext()) return false; value.initialize(rowIterator.next()); numKeysRead = rowIterator.getKVCount(); key.set((currentKey = value.peek().getKey()).getRow()); return true; }
/** * SingleRowIter must be passed a PeekingIterator so that it can peek at the next entry to see * if it belongs in the current row or not. */ public SingleRowIter(PeekingIterator<Entry<Key,Value>> source) { this.source = source; if (source.hasNext()) currentRow = source.peek().getKey().getRow(); }
@Override public boolean nextKeyValue() throws IOException, InterruptedException { if (!rowIterator.hasNext()) return false; currentV = new PeekingIterator<>(rowIterator.next()); numKeysRead = rowIterator.getKVCount(); currentKey = currentV.peek().getKey(); currentK = new Text(currentKey.getRow()); return true; } };
@Override public void next() throws IOException { inner.next(); }
@Override protected void safeMap(Text row, PeekingIterator<Map.Entry<Key, Value>> value, Context context) throws IOException, InterruptedException { context.setStatus(row.toString()); String propertyVisibility = null; while (value.hasNext()) { Map.Entry<Key, Value> column = value.next(); if (column.getKey().getColumnFamily().toString().equals("PROP")) { propertyVisibility = AccumuloGraph.accumuloVisibilityToVisibility(column.getKey().getColumnVisibilityParsed()).getVisibilityString(); } else if (column.getKey().getColumnFamily().toString().equals("PROPMETA")) { updateMetadata(column.getKey(), column.getValue(), propertyVisibility, context); } } }
@Override public Vertex next(PeekingIterator<Entry<Key, Value>> iterator) { // TODO could also check local cache before creating a new instance? String rowId = iterator.peek().getKey().getRow().toString(); List<Entry<Key, Value>> entries = new ArrayList<Entry<Key, Value>>(); while (iterator.peek() != null && rowId.equals(iterator .peek().getKey().getRow().toString())) { entries.add(iterator.next()); } AccumuloVertex vertex = parser.parse(rowId, entries); globals.getCaches().cache(vertex, Vertex.class); return vertex; } };
/** * Create an iterator from an (ordered) sequence of KeyValue pairs. */ public RowIterator(Iterator<Entry<Key,Value>> iterator) { this.iter = new PeekingIterator<>(iterator); }
byte[] b = new byte[20]; int read; PeekingIterator<Entry<Key,Value>> pi = new PeekingIterator<>(scan.iterator()); cis.close(); assertFalse(pi.hasNext());
/** * Returns true if there is at least one more row to get. * * If the last row hasn't been fully read, this method will read through the end of the last row * so it can determine if the underlying iterator has a next row. The last row is disabled from * future use. */ @Override public boolean hasNext() { if (lastIter != null) { lastIter.consume(); count += lastIter.getCount(); lastIter = null; } return iter.hasNext(); }
@Override public Value getTopValue() { return hasTop() ? inner.peek().getValue() : null; } }
@Override public SortedKeyValueIterator<Key,Value> deepCopy(IteratorEnvironment env) { HardListIterator newInstance; try { newInstance = HardListIterator.class.newInstance(); } catch (Exception e) { throw new RuntimeException(e); } newInstance.inner = new PeekingIterator<>( allEntriesToInject.tailMap(inner.peek().getKey()).entrySet().iterator()); return newInstance; }
@Override public T next(PeekingIterator<Entry<Key,Value>> iterator) { return (T) parser.parse(Arrays.asList(iterator.next())); } };
@Override public boolean next(Text rowKey, AccumuloHiveRow row) throws IOException { Text key = recordReader.createKey(); PeekingIterator<Map.Entry<Key,Value>> iter = recordReader.createValue(); if (recordReader.next(key, iter)) { row.clear(); row.setRowId(key.toString()); List<Key> keys = Lists.newArrayList(); List<Value> values = Lists.newArrayList(); while (iter.hasNext()) { // collect key/values for this row. Map.Entry<Key,Value> kv = iter.next(); keys.add(kv.getKey()); values.add(kv.getValue()); } if (iteratorCount == 0) { // no encoded values, we can push directly to row. pushToValue(keys, values, row); } else { for (int i = 0; i < iteratorCount; i++) { // each iterator creates a level of encoding. SortedMap<Key,Value> decoded = PrimitiveComparisonFilter.decodeRow(keys.get(0), values.get(0)); keys = Lists.newArrayList(decoded.keySet()); values = Lists.newArrayList(decoded.values()); } pushToValue(keys, values, row); // after decoding we can push to value. } return true; } else { return false; } }
@Override public Edge next(PeekingIterator<Entry<Key, Value>> iterator) { // TODO could also check local cache before creating a new instance? String rowId = iterator.peek().getKey().getRow().toString(); List<Entry<Key, Value>> entries = new ArrayList<Entry<Key, Value>>(); // MDL 05 Jan 2014: Why is this equalsIgnoreCase?? while (iterator.peek() != null && rowId.equalsIgnoreCase(iterator .peek().getKey().getRow().toString())) { entries.add(iterator.next()); } AccumuloEdge edge = parser.parse(rowId, entries); globals.getCaches().cache(edge, Edge.class); return edge; } };
@Override public PeekingIterator<Entry<Key,Value>> createValue() { return new PeekingIterator<>(); } };
/** * Returns true if there is at least one more row to get. * * If the last row hasn't been fully read, this method will read through the end of the last row * so it can determine if the underlying iterator has a next row. The last row is disabled from * future use. */ @Override public boolean hasNext() { if (lastIter != null) { lastIter.consume(); count += lastIter.getCount(); lastIter = null; } return iter.hasNext(); }
@Override public Key getTopKey() { return hasTop() ? inner.peek().getKey() : null; }