java类com.google.common.collect.ImmutableSortedSet的实例源码

@Nonnull
public ImmutableSortedSet<ImmutableItem> toSortedSet(@Nonnull Comparator<? super ImmutableItem> comparator,
                                                     @Nullable final Iterable<? extends Item> iterable) {
    if (iterable == null) {
        return ImmutableSortedSet.of();
    }

    boolean needsCopy = false;
    if (iterable instanceof ImmutableSortedSet &&
            ((ImmutableSortedSet)iterable).comparator().equals(comparator)) {
        for (Item element: iterable) {
            if (!isImmutable(element)) {
                needsCopy = true;
                break;
            }
        }
    } else {
        needsCopy = true;
    }

    if (!needsCopy) {
        return (ImmutableSortedSet<ImmutableItem>)iterable;
    }

    final Iterator<? extends Item> iter = iterable.iterator();


    return ImmutableSortedSet.copyOf(comparator, new Iterator<ImmutableItem>() {
        @Override public boolean hasNext() { return iter.hasNext(); }
        @Override public ImmutableItem next() { return makeImmutable(iter.next()); }
        @Override public void remove() { iter.remove(); }
    });
}

@Override
protected List<String> create(String[] elements) {
  Comparator<String> comparator = createExplicitComparator(elements).reverse();
  return ImmutableSortedSet.orderedBy(comparator)
      .add(elements)
      .build()
      .descendingSet()
      .asList();
}

public static <E> Collector<E, ?, ImmutableSortedSet<E>> toSortedSet(Comparator<? super E> comparator) {
    return Collector.of(
            () -> new ImmutableSortedSet.Builder<E>(comparator),
            ImmutableSortedSet.Builder::add,
            (l, r) -> l.addAll(r.build()),
            ImmutableSortedSet.Builder::build
    );
}

@Nonnull
private static <T> SortedSet<? extends T> toSortedSet(@Nonnull Comparator<? super T> elementComparator,
                                                      @Nonnull Collection<? extends T> collection) {
    if (collection instanceof SortedSet) {
        SortedSet<? extends T> sortedSet = (SortedSet<? extends T>)collection;
        Comparator<?> comparator = sortedSet.comparator();
        if (comparator != null && comparator.equals(elementComparator)) {
            return sortedSet;
        }
    }
    return ImmutableSortedSet.copyOf(elementComparator, collection);
}

private <T extends PresortedComparable<T>> SortedSet<T> toDescriptorSet(
    Set<? extends KeyedDexItem<T>> set) {
  ImmutableSortedSet.Builder<T> builder =
      new ImmutableSortedSet.Builder<>(PresortedComparable::slowCompareTo);
  for (KeyedDexItem<T> item : set) {
    builder.add(item.getKey());
  }
  return builder.build();
}

private static <T extends PresortedComparable<T>> ImmutableSortedSet<T> rewriteItems(
    Set<T> original, BiFunction<T, DexEncodedMethod, T> rewrite) {
  ImmutableSortedSet.Builder<T> builder =
      new ImmutableSortedSet.Builder<>(PresortedComparable::slowCompare);
  for (T item : original) {
    builder.add(rewrite.apply(item, null));
  }
  return builder.build();
}

public final CorpusQueryAssessments loadFrom(final CharSource source) throws IOException {
  final List<String> lines = source.readLines();
  final List<QueryResponse2016> queries = Lists.newArrayList();
  final Map<QueryResponse2016, String> metadata = Maps.newHashMap();
  final ImmutableMultimap.Builder<QueryResponse2016, Symbol> responsesToSystems =
      ImmutableMultimap.builder();
  final Map<QueryResponse2016, QueryAssessment2016> assessments = Maps.newHashMap();
  Optional<String> lastMetadata = Optional.absent();
  for (final String line : lines) {
    if (line.startsWith("#")) {
      lastMetadata = Optional.of(line.trim().substring(1));
    } else {
      final String[] parts = line.trim().split("\t");
      checkArgument(parts.length == 5, "expected five columns, but got " + parts.length);
      final Symbol queryID = Symbol.from(parts[0]);
      final Symbol docID = Symbol.from(parts[1]);
      final String[] systemIDs = parts[2].split(",");
      final ImmutableSortedSet<CharOffsetSpan> spans = extractPJSpans(parts[3]);
      final QueryAssessment2016 assessment = QueryAssessment2016.valueOf(parts[4]);
      final QueryResponse2016 query =
          QueryResponse2016.builder().queryID(queryID).docID(docID)
              .addAllPredicateJustifications(spans).build();
      queries.add(query);
      for(final String systemID: systemIDs) {
        responsesToSystems.put(query, Symbol.from(systemID));
      }
      if (!assessment.equals(QueryAssessment2016.UNASSESSED)) {
        assessments.put(query, assessment);
      }
      if (lastMetadata.isPresent()) {
        metadata.put(query, lastMetadata.get());
        lastMetadata = Optional.absent();
      }
    }
  }
  return CorpusQueryAssessments.builder().addAllQueryReponses(queries).assessments(assessments)
      .queryResponsesToSystemIDs(responsesToSystems.build())
      .metadata(metadata).build();
}

private static ImmutableSortedSet<CharOffsetSpan> extractPJSpans(final String part) {
  final ImmutableSortedSet.Builder<CharOffsetSpan> spans = ImmutableSortedSet.naturalOrder();
  for (final String spanString : commaSplitter.split(part.trim())) {
    final List<String> spanParts = ImmutableList.copyOf(dashSplitter.split(spanString));
    checkState(spanParts.size() == 2,
        "Expected two components to the span, but got " + spanParts.size());
    final int start = Integer.parseInt(spanParts.get(0));
    final int end = Integer.parseInt(spanParts.get(1));
    spans.add(CharOffsetSpan.fromOffsetsOnly(start, end));
  }
  return spans.build();
}

PrecomputedScores(Collection<TermId> termIds) {
  termIdCount = termIds.size();
  data = new float[termIdCount * termIdCount];
  termIdToIdx = new HashMap<>(termIdCount);

  int i = 0;
  for (TermId termId : ImmutableSortedSet.copyOf(termIds)) {
    termIdToIdx.put(termId, i++);
  }
}

@Test
public void test() {
  Set<TermId> inputIds = Sets.newHashSet(id1);
  Set<TermId> outputIds =
      ImmutableSortedSet.copyOf(TermIds.augmentWithAncestors(ontology, inputIds, true));
  assertEquals(
      "[ImmutableTermId [prefix=ImmutableTermPrefix [value=HP], id=0000001], ImmutableTermId [prefix=ImmutableTermPrefix [value=HP], id=0000002], ImmutableTermId [prefix=ImmutableTermPrefix [value=HP], id=0000003], ImmutableTermId [prefix=ImmutableTermPrefix [value=HP], id=0000004], ImmutableTermId [prefix=ImmutableTermPrefix [value=HP], id=0000005]]",
      outputIds.toString());
}