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

CombinedFutureRunningState(
    ImmutableCollection<? extends ListenableFuture<? extends Object>> futures,
    boolean allMustSucceed,
    CombinedFutureInterruptibleTask task) {
  super(futures, allMustSucceed, false);
  this.task = task;
}

/**
 * Return a copy of the given collection in whatever subclass of {@link ImmutableCollection} fits best
 */
public static <E> ImmutableCollection<E> immutableCopyOf(Collection<E> things) {
    if(things instanceof List) {
        return ImmutableList.copyOf(things);
    } else {
        return ImmutableSet.copyOf(things);
    }
}

public static <T> ImmutableCollection<T> copyOf(Iterable<T> iterable) {
    if(iterable instanceof Set) {
        return ImmutableSet.copyOf(iterable);
    } else if(iterable instanceof Multiset) {
        return ImmutableMultiset.copyOf(iterable);
    } else {
        return ImmutableList.copyOf(iterable);
    }
}

@Nullable
private static Symbol.MethodSymbol methodInSet(
    Symbol.MethodSymbol symbol, Types types, ImmutableCollection<MethodRef> memberNames) {
  if (memberNames.contains(MethodRef.fromSymbol(symbol))) {
    return symbol;
  }
  for (Symbol.MethodSymbol superSymbol : ASTHelpers.findSuperMethods(symbol, types)) {
    if (memberNames.contains(MethodRef.fromSymbol(superSymbol))) {
      return superSymbol;
    }
  }
  return null;
}

protected ImmutableCollection<Object> evaluateRule(final String ldPath, IRI context)
    throws ParseException {
  final LdPathParser<Value> parser = createParserFromString(ldPath);
  final FieldMapping<Object, Value> rule = parser.parseRule(NAMESPACES);

  return ImmutableList.copyOf(rule.getValues(backend, context));
}

@Test
public void testKeepAfterLastFunction() throws ParseException {
  final String id = "baz";
  final String ldPath =
      String.format("fn:keepAfterLast(<%s>, \"%s\") :: xsd:string", predicate.stringValue(), "/");
  addStatement(repository.getValueFactory().createStatement(subject, predicate, iri("ex", id)));

  final ImmutableCollection<Object> values = evaluateRule(ldPath, subject);

  assertThat(values.size(), Matchers.equalTo(1));
  assertThat(values, Matchers.contains("example.com#baz"));
}

@Test
public void testNoOccurrence() throws ParseException {
  final String value = "stringLiteral";
  final String ldPath =
      String.format("fn:keepAfterLast(<%s>, \"%s\") :: xsd:string", predicate.stringValue(), "/");
  addStatement(repository.getValueFactory().createStatement(subject, predicate,
      repository.getValueFactory().createLiteral(value)));

  final ImmutableCollection<Object> values = evaluateRule(ldPath, subject);

  assertThat(values.size(), Matchers.equalTo(1));
  assertThat(values, Matchers.contains(value));
}

public ImmutableCollection<String> getValues()
{
    synchronized( valuesLock )
    {
        return ImmutableList.copyOf(values);
    }
}

/**
 * Convert from an offset and length flag pair to a token range.
 *
 * @param offset the {@code 0}-based offset in characters
 * @param length the length in characters
 * @return the {@code 0}-based {@link Range} of tokens
 * @throws FormatterException
 */
Range<Integer> characterRangeToTokenRange(int offset, int length) throws FormatterException {
    int requiredLength = offset + length;
    if (requiredLength > text.length()) {
        throw new FormatterException(
                String.format(
                        "error: invalid length %d, offset + length (%d) is outside the file",
                        length, requiredLength));
    }
    if (length < 0) {
        return EMPTY_RANGE;
    }
    if (length == 0) {
        // 0 stands for "format the line under the cursor"
        length = 1;
    }
    ImmutableCollection<Token> enclosed =
            getPositionTokenMap()
                    .subRangeMap(Range.closedOpen(offset, offset + length))
                    .asMapOfRanges()
                    .values();
    if (enclosed.isEmpty()) {
        return EMPTY_RANGE;
    }
    return Range.closedOpen(
            enclosed.iterator().next().getTok().getIndex(), getLast(enclosed).getTok().getIndex() + 1);
}

RunningState(
    ImmutableCollection<? extends ListenableFuture<? extends InputT>> futures,
    boolean allMustSucceed,
    boolean collectsValues) {
  super(futures.size());
  this.futures = checkNotNull(futures);
  this.allMustSucceed = allMustSucceed;
  this.collectsValues = collectsValues;
}