下面列出了com.google.common.collect.PeekingIterator#hasNext ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
/**
* Converts a set of integers into a set of contiguous closed ranges that equally represent the
* input integers.
* <p>
* The resulting ranges will be in ascending order.
* <p>
* TODO(wfarner): Change this to return a canonicalized RangeSet.
*
* @param values Values to transform to ranges.
* @return Closed ranges with identical members to the input set.
*/
public static Set<Range<Integer>> toRanges(Iterable<Integer> values) {
ImmutableSet.Builder<Range<Integer>> builder = ImmutableSet.builder();
PeekingIterator<Integer> iterator =
Iterators.peekingIterator(Sets.newTreeSet(values).iterator());
// Build ranges until there are no numbers left.
while (iterator.hasNext()) {
// Start a new range.
int start = iterator.next();
int end = start;
// Increment the end until the range is non-contiguous.
while (iterator.hasNext() && iterator.peek() == end + 1) {
end++;
iterator.next();
}
builder.add(Range.closed(start, end));
}
return builder.build();
}
/**
* Attempt to match the desired properties to a sequence of known properties.
* <p>
* Returns a list of the same length as the original. Entries are:
* - Optional.empty(): the property was satisfied completely
* - non-empty: the (simplified) property that was not satisfied
*/
public static <T> List<Optional<LocalProperty<T>>> match(List<LocalProperty<T>> actuals, List<LocalProperty<T>> desired)
{
// After normalizing actuals, each symbol should only appear once
PeekingIterator<LocalProperty<T>> actualIterator = peekingIterator(normalizeAndPrune(actuals).iterator());
Set<T> constants = new HashSet<>();
boolean consumeMoreActuals = true;
List<Optional<LocalProperty<T>>> result = new ArrayList<>(desired.size());
for (LocalProperty<T> desiredProperty : desired) {
while (consumeMoreActuals && actualIterator.hasNext() && desiredProperty.isSimplifiedBy(actualIterator.peek())) {
constants.addAll(actualIterator.next().getColumns());
}
Optional<LocalProperty<T>> simplifiedDesired = desiredProperty.withConstants(constants);
consumeMoreActuals &= simplifiedDesired.isEmpty(); // Only continue processing actuals if all previous desired properties were fully satisfied
result.add(simplifiedDesired);
}
return result;
}
void readAll(String channel, SlabFilter filter, EventSink sink, boolean weak) {
// PeekingIterator is needed so that we can look ahead and see the next slab Id
PeekingIterator<Column<ByteBuffer>> manifestColumns = Iterators.peekingIterator(readManifestForChannel(channel, weak));
while (manifestColumns.hasNext()) {
Column<ByteBuffer> manifestColumn = manifestColumns.next();
ByteBuffer slabId = manifestColumn.getName();
ByteBuffer nextSlabId = manifestColumns.hasNext() ? manifestColumns.peek().getName() : null;
boolean open = manifestColumn.getBooleanValue();
if (filter != null && !filter.accept(slabId, open, nextSlabId)) {
continue;
}
if (!readSlab(channel, slabId, new SlabCursor(), open, sink)) {
break;
}
}
}
private static void writeEntries(JsonGenerator jg, List<Trace.Entry> entries)
throws IOException {
jg.writeStartArray();
PeekingIterator<Trace.Entry> i = Iterators.peekingIterator(entries.iterator());
while (i.hasNext()) {
Trace.Entry entry = i.next();
int depth = entry.getDepth();
jg.writeStartObject();
writeJson(entry, jg);
int nextDepth = i.hasNext() ? i.peek().getDepth() : 0;
if (nextDepth > depth) {
jg.writeArrayFieldStart("childEntries");
} else if (nextDepth < depth) {
jg.writeEndObject();
for (int j = depth; j > nextDepth; j--) {
jg.writeEndArray();
jg.writeEndObject();
}
} else {
jg.writeEndObject();
}
}
jg.writeEndArray();
}
@Override
protected Generation.Entry<K, V> computeNext() {
if (heap.isEmpty()) {
return endOfData();
}
PeekingIterator<EntryAndGenerationId<K,V>> first = heap.poll();
EntryAndGenerationId<K,V> ret = first.next();
if (first.hasNext()) {
temp.add(first);
}
while (!heap.isEmpty() && keyComparator.compare(ret.entry.getKey(), heap.peek().peek().entry.getKey()) == 0) {
PeekingIterator<EntryAndGenerationId<K, V>> iter = heap.poll();
iter.next();
if (iter.hasNext()) {
temp.add(iter);
}
}
heap.addAll(temp);
temp.clear();
return ret.entry;
}
private void visitStatements(List<? extends StatementTree> statements) {
boolean first = true;
PeekingIterator<StatementTree> it =
Iterators.<StatementTree>peekingIterator(statements.iterator());
dropEmptyDeclarations();
while (it.hasNext()) {
StatementTree tree = it.next();
builder.forcedBreak();
if (!first) {
builder.blankLineWanted(BlankLineWanted.PRESERVE);
}
markForPartialFormat();
first = false;
List<VariableTree> fragments = variableFragments(it, tree);
if (!fragments.isEmpty()) {
visitVariables(
fragments,
DeclarationKind.NONE,
canLocalHaveHorizontalAnnotations(fragments.get(0).getModifiers()));
} else {
scan(tree, null);
}
}
}
/** Compute how many slots in a slab will be used to do a default (new slab) allocation, and how many bytes it will consume
*
* @param slabSlotsUsed - number of available slots in a slab that have been used prior to this allocation
* @param slabBytesUsed - number of bytes in a slab that have been used prior to this allocation
* @param eventSizes - list of the size in bytes of all events that we want to insert into the slab
*
* @return a pair of integers, the left value is the number of slots that will be used by this allocation and the
* right value is the numb er of bytes that will be used by this allocation
*/
static Pair<Integer, Integer> defaultAllocationCount(int slabSlotsUsed, int slabBytesUsed, PeekingIterator<Integer> eventSizes) {
int slabTotalSlotCount = slabSlotsUsed;
int allocationSlotCount = 0;
int slabTotalBytesUsed = slabBytesUsed;
int allocationBytes = 0;
while (eventSizes.hasNext()) {
checkArgument(eventSizes.peek() <= Constants.MAX_EVENT_SIZE_IN_BYTES, "Event size (" + eventSizes.peek() + ") is greater than the maximum allowed (" + Constants.MAX_EVENT_SIZE_IN_BYTES + ") event size");
if (slabTotalSlotCount + 1 <= Constants.MAX_SLAB_SIZE && slabTotalBytesUsed + eventSizes.peek() <= Constants.MAX_SLAB_SIZE_IN_BYTES) {
slabTotalSlotCount++;
allocationSlotCount++;
int eventSize = eventSizes.next();
slabTotalBytesUsed += eventSize;
allocationBytes += eventSize;
} else {
break;
}
}
return new ImmutablePair<>(allocationSlotCount, allocationBytes);
}
public static <T> Set<T> extractLeadingConstants(List<? extends LocalProperty<T>> properties)
{
ImmutableSet.Builder<T> builder = ImmutableSet.builder();
PeekingIterator<? extends LocalProperty<T>> iterator = peekingIterator(properties.iterator());
while (iterator.hasNext() && iterator.peek() instanceof ConstantProperty) {
builder.add(((ConstantProperty<T>) iterator.next()).getColumn());
}
return builder.build();
}
/**
* Advance an iterator until the next value is larger than the reference.
* @return the last value polled if it is equal to reference, or null otherwise.
*/
@Nullable
private <T extends URNIdentified> T advanceUntilLargerThan(PeekingIterator<T> it, String reference) {
if (reference == null) {
return null;
}
int comparisonResult = -1;
while (it.hasNext() && (comparisonResult = lexicographicalComparator.compare(it.peek(), reference)) < 0) {
it.next();
}
return comparisonResult == 0 ? it.next() : null;
}
/**
* Gather {@link MonitoredItemNotification}s and send them using {@code service}, if present.
*
* @param iterator a {@link PeekingIterator} over the current {@link BaseMonitoredItem}s.
* @param service a {@link ServiceRequest}, if available.
*/
private void gatherAndSend(PeekingIterator<BaseMonitoredItem<?>> iterator,
Optional<ServiceRequest<PublishRequest, PublishResponse>> service) {
if (service.isPresent()) {
List<UaStructure> notifications = Lists.newArrayList();
while (notifications.size() < maxNotificationsPerPublish && iterator.hasNext()) {
BaseMonitoredItem<?> item = iterator.peek();
boolean gatheredAllForItem = gather(item, notifications, maxNotificationsPerPublish);
if (gatheredAllForItem && iterator.hasNext()) {
iterator.next();
}
}
moreNotifications = iterator.hasNext();
sendNotifications(service.get(), notifications);
if (moreNotifications) {
gatherAndSend(iterator, Optional.ofNullable(publishQueue().poll()));
}
} else {
if (moreNotifications) {
publishQueue().addSubscription(this);
}
}
}
/**
* The parser expands multi-variable declarations into separate single-variable declarations. All
* of the fragments in the original declaration have the same start position, so we use that as a
* signal to collect them and preserve the multi-variable declaration in the output.
* <p>
* <p>e.g. {@code int x, y;} is parsed as {@code int x; int y;}.
*/
private List<VariableTree> variableFragments(PeekingIterator<? extends Tree> it, Tree first) {
List<VariableTree> fragments = new ArrayList<>();
if (first.getKind() == VARIABLE) {
int start = getStartPosition(first);
fragments.add((VariableTree) first);
while (it.hasNext()
&& it.peek().getKind() == VARIABLE
&& getStartPosition(it.peek()) == start) {
fragments.add((VariableTree) it.next());
}
}
return fragments;
}
private static <T> Iterator<T> streamingIterator(Iterator<T> iterator) {
// Force the calculation of at least the first item in the iterator so that, if an exception occurs, we find
// out before writing the HTTP response code & headers. Otherwise we will at best report a 500 error instead
// of applying Jersey exception mappings and maybe returning a 400 error etc.
PeekingIterator<T> peekingIterator = Iterators.peekingIterator(iterator);
if (peekingIterator.hasNext()) {
peekingIterator.peek();
}
return new LoggingIterator<>(peekingIterator, _log);
}
private static Qualifiers getQualifiers(Iterable<String> dirNameAndQualifiers) {
PeekingIterator<String> rawQualifiers =
Iterators.peekingIterator(dirNameAndQualifiers.iterator());
// Remove directory name
final ResourceFolderType folderType = ResourceFolderType.getTypeByName(rawQualifiers.next());
// If there is no folder type, there are no qualifiers to parse.
if (folderType == null) {
return EMPTY_QUALIFIERS;
}
List<String> handledQualifiers = new ArrayList<>();
// Do some substitution of language/region qualifiers.
while (rawQualifiers.hasNext()) {
handledQualifiers.add(rawQualifiers.next());
}
// Create a configuration
FolderConfiguration config = FolderConfiguration.getConfigFromQualifiers(handledQualifiers);
// FolderConfiguration returns an unhelpful null when it considers the qualifiers to be
// invalid.
if (config == null) {
throw new IllegalArgumentException(
String.format(INVALID_QUALIFIERS, DASH_JOINER.join(dirNameAndQualifiers)));
}
config.normalize();
ImmutableList.Builder<String> builder = ImmutableList.<String>builder();
// index 3 is past the country code, network code, and locale indices.
for (int i = 0; i < FolderConfiguration.getQualifierCount(); ++i) {
addIfNotNull(config.getQualifier(i), builder);
}
return new Qualifiers(folderType, builder.build(), config.getLocaleQualifier() == null);
}
/***
* Convert a list of annotations into annotation groups
*
* @param annotationList
* Annotations
* @param longestOnly
* If shorter entities from annotation groups should be removed
* @return annotation groups
*/
static List<EntityAnnotationGroup> getAnnotationGroups(List<EntityAnnotation> annotationList,
boolean longestOnly) {
List<EntityAnnotationGroup> groups = new ArrayList<>();
Collections.sort(annotationList, Collections.reverseOrder());
PeekingIterator<EntityAnnotation> iter = Iterators.peekingIterator(annotationList.iterator());
while (iter.hasNext()) {
EntityAnnotationGroup group = new EntityAnnotationGroup();
group.add(iter.next());
Set<Entity> entitiesInGroup = new HashSet<>();
while (iter.hasNext() && group.intersects(iter.peek())) {
if (!entitiesInGroup.contains(iter.peek().getToken())) {
entitiesInGroup.add(iter.peek().getToken());
group.add(iter.next());
} else {
iter.next();
}
}
if (longestOnly) {
// Remove any entries that aren't as long as the first one
Iterator<EntityAnnotation> groupIter = group.iterator();
int longest = group.peek().length();
while (groupIter.hasNext()) {
EntityAnnotation annot = groupIter.next();
if (annot.length() < longest) {
groupIter.remove();
}
}
}
groups.add(group);
}
return groups;
}
/** Add a list of declarations. */
protected void addBodyDeclarations(
List<? extends Tree> bodyDeclarations, BracesOrNot braces, FirstDeclarationsOrNot first0) {
if (bodyDeclarations.isEmpty()) {
if (braces.isYes()) {
builder.space();
tokenBreakTrailingComment("{", plusTwo);
builder.blankLineWanted(BlankLineWanted.NO);
builder.open(ZERO);
token("}", plusTwo);
builder.close();
}
} else {
if (braces.isYes()) {
builder.space();
tokenBreakTrailingComment("{", plusTwo);
builder.open(ZERO);
}
builder.open(plusTwo);
boolean first = first0.isYes();
boolean lastOneGotBlankLineBefore = false;
PeekingIterator<Tree> it = Iterators.peekingIterator(bodyDeclarations.iterator());
while (it.hasNext()) {
Tree bodyDeclaration = it.next();
dropEmptyDeclarations();
builder.forcedBreak();
boolean thisOneGetsBlankLineBefore =
bodyDeclaration.getKind() != VARIABLE || hasJavaDoc(bodyDeclaration);
if (first) {
builder.blankLineWanted(PRESERVE);
} else if (!first && (thisOneGetsBlankLineBefore || lastOneGotBlankLineBefore)) {
builder.blankLineWanted(YES);
}
markForPartialFormat();
if (bodyDeclaration.getKind() == VARIABLE) {
visitVariables(
variableFragments(it, bodyDeclaration),
DeclarationKind.FIELD,
fieldAnnotationDirection(((VariableTree) bodyDeclaration).getModifiers()));
} else {
scan(bodyDeclaration, null);
}
first = false;
lastOneGotBlankLineBefore = thisOneGetsBlankLineBefore;
}
dropEmptyDeclarations();
builder.forcedBreak();
builder.close();
builder.forcedBreak();
markForPartialFormat();
if (braces.isYes()) {
builder.blankLineWanted(BlankLineWanted.NO);
token("}", plusTwo);
builder.close();
}
}
}
public List<TaggingTokenCluster> cluster() {
List<TaggingTokenCluster> result = new ArrayList<>();
PeekingIterator<LabeledTokensContainer> it = Iterators.peekingIterator(taggingTokenSynchronizer);
if (!it.hasNext() || (it.peek() == null)) {
return Collections.emptyList();
}
// a boolean is introduced to indicate the start of the sequence in the case the label
// has no beginning indicator (e.g. I-)
boolean begin = true;
TaggingTokenCluster curCluster = new TaggingTokenCluster(it.peek().getTaggingLabel());
BoundingBox curBox=null;
while (it.hasNext()) {
LabeledTokensContainer cont = it.next();
BoundingBox b = BoundingBox.fromLayoutToken(cont.getLayoutTokens().get(0));
if(!curCluster.concatTokens().isEmpty()){
curBox = BoundingBox.fromLayoutToken(curCluster.concatTokens().get(0));
if(b.distanceTo(curBox)>600){
curCluster = new TaggingTokenCluster(cont.getTaggingLabel());
result.add(curCluster);
}
}
if (begin || cont.isBeginning() || cont.getTaggingLabel() != curCluster.getTaggingLabel()) {
curCluster = new TaggingTokenCluster(cont.getTaggingLabel());
result.add(curCluster);
}
//for table, seperate caption and content
if(curCluster!=null){
String tableStr = LayoutTokensUtil.normalizeText(curCluster.concatTokens());
if(tableStr.matches(".*?(Table|TABLE) \\d+(:|\\.| [A-Z]).*?")){
// if(tableStr.matches(".*?(Table|TABLE|Figure|FIGURE) \\d+(:|\\.).*?")){
if(toText(curCluster.getLastContainer().getLayoutTokens()).equalsIgnoreCase(". \n\n")){
curCluster = new TaggingTokenCluster(cont.getTaggingLabel());
result.add(curCluster);
}
}
}
curCluster.addLabeledTokensContainer(cont);
if (begin)
begin = false;
}
return result;
}
@Override
public void run() {
checkArgument(
RegistryEnvironment.get() == RegistryEnvironment.ALPHA
|| RegistryEnvironment.get() == RegistryEnvironment.CRASH
|| RegistryEnvironment.get() == RegistryEnvironment.UNITTEST,
"DO NOT RUN ANYWHERE ELSE EXCEPT ALPHA, CRASH OR TESTS.");
if (dryRun) {
logger.atInfo().log("Running in dryRun mode");
}
List<GcsFileMetadata> diffFiles = diffLister.listDiffFiles(fromTime, toTime);
if (diffFiles.isEmpty()) {
logger.atInfo().log("Nothing to restore");
return;
}
Map<Integer, DateTime> bucketTimestamps = new HashMap<>();
CommitLogCheckpoint lastCheckpoint = null;
for (GcsFileMetadata metadata : diffFiles) {
logger.atInfo().log("Restoring: %s", metadata.getFilename().getObjectName());
try (InputStream input = Channels.newInputStream(
gcsService.openPrefetchingReadChannel(metadata.getFilename(), 0, BLOCK_SIZE))) {
PeekingIterator<ImmutableObject> commitLogs =
peekingIterator(createDeserializingIterator(input));
lastCheckpoint = (CommitLogCheckpoint) commitLogs.next();
saveOfy(ImmutableList.of(lastCheckpoint)); // Save the checkpoint itself.
while (commitLogs.hasNext()) {
CommitLogManifest manifest = restoreOneTransaction(commitLogs);
bucketTimestamps.put(manifest.getBucketId(), manifest.getCommitTime());
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
// Restore the CommitLogCheckpointRoot and CommitLogBuckets.
saveOfy(
Streams.concat(
bucketTimestamps
.entrySet()
.stream()
.map(
entry ->
new CommitLogBucket.Builder()
.setBucketNum(entry.getKey())
.setLastWrittenTime(entry.getValue())
.build()),
Stream.of(CommitLogCheckpointRoot.create(lastCheckpoint.getCheckpointTime())))
.collect(toImmutableList()));
logger.atInfo().log("Restore complete");
}
/**
* Add a list of declarations.
*/
void addBodyDeclarations(
List<? extends Tree> bodyDeclarations, BracesOrNot braces, FirstDeclarationsOrNot first0) {
if (bodyDeclarations.isEmpty()) {
if (braces.isYes()) {
builder.space();
tokenBreakTrailingComment("{", plusTwo);
builder.blankLineWanted(BlankLineWanted.NO);
builder.open(ZERO);
token("}", plusTwo);
builder.close();
}
} else {
if (braces.isYes()) {
builder.space();
tokenBreakTrailingComment("{", plusTwo);
builder.open(ZERO);
}
builder.open(plusTwo);
boolean first = first0.isYes();
boolean lastOneGotBlankLineBefore = false;
PeekingIterator<Tree> it = Iterators.<Tree>peekingIterator(bodyDeclarations.iterator());
while (it.hasNext()) {
Tree bodyDeclaration = it.next();
dropEmptyDeclarations();
builder.forcedBreak();
boolean thisOneGetsBlankLineBefore =
bodyDeclaration.getKind() != VARIABLE || hasJavaDoc(bodyDeclaration);
if (first) {
builder.blankLineWanted(PRESERVE);
} else if (!first && (thisOneGetsBlankLineBefore || lastOneGotBlankLineBefore)) {
builder.blankLineWanted(YES);
}
markForPartialFormat();
if (bodyDeclaration.getKind() == VARIABLE) {
visitVariables(
variableFragments(it, bodyDeclaration),
DeclarationKind.FIELD,
fieldAnnotationDirection(((VariableTree) bodyDeclaration).getModifiers()));
} else {
scan(bodyDeclaration, null);
}
first = false;
lastOneGotBlankLineBefore = thisOneGetsBlankLineBefore;
}
dropEmptyDeclarations();
builder.forcedBreak();
builder.close();
builder.forcedBreak();
markForPartialFormat();
if (braces.isYes()) {
builder.blankLineWanted(BlankLineWanted.NO);
token("}", plusTwo);
builder.close();
}
}
}
protected INode findBestEndToken(INode root, INode candidate, int completionColumn, boolean candidateIsEndToken) {
LinkedList<ILeafNode> sameGrammarElement = Lists.newLinkedList();
PeekingIterator<ILeafNode> iterator = createReversedLeafIterator(root, candidate, sameGrammarElement);
if (!iterator.hasNext()) {
return candidate;
}
// collect all candidates that belong to the same offset
LinkedList<ILeafNode> sameOffset = candidateIsEndToken ? collectLeafsWithSameOffset((ILeafNode)candidate, iterator) : Lists.newLinkedList();
// continue until we find a paired leaf with length 0 that is at the correct offset
EObject grammarElement = tryGetGrammarElementAsRule(candidateIsEndToken || sameGrammarElement.isEmpty() ? candidate : sameGrammarElement.getLast());
ILeafNode result = candidateIsEndToken ? null : (ILeafNode) candidate;
int sameOffsetSize = sameOffset.size();
while(iterator.hasNext()) {
ILeafNode next = iterator.next();
if (result == null || result.isHidden()) {
result = next;
}
if (next.getTotalLength() == 0) {
// potential indentation token
EObject rule = tryGetGrammarElementAsRule(next);
if (rule != grammarElement) {
LineAndColumn lineAndColumn = NodeModelUtils.getLineAndColumn(root, next.getTotalOffset());
if (lineAndColumn.getColumn() <= completionColumn) {
return result;
} else {
if (sameOffset.isEmpty()) {
if (sameGrammarElement.isEmpty()) {
result = null;
} else {
result = sameGrammarElement.removeLast();
}
} else {
if (sameOffsetSize >= sameOffset.size()) {
result = sameOffset.removeLast();
} else {
sameOffset.removeLast();
}
}
}
} else {
sameOffset.add(next);
}
}
}
return candidate;
}
private void returnNotifications(ServiceRequest<PublishRequest, PublishResponse> service) {
LinkedHashSet<BaseMonitoredItem<?>> items = new LinkedHashSet<>();
lastIterator.forEachRemaining(items::add);
itemsById.values().stream()
.filter(item -> item.hasNotifications() || item.isTriggered())
.forEach(items::add);
PeekingIterator<BaseMonitoredItem<?>> iterator = Iterators.peekingIterator(items.iterator());
gatherAndSend(iterator, Optional.of(service));
lastIterator = iterator.hasNext() ? iterator : Collections.emptyIterator();
}