@Override public Collection<ActiveRule> findByRepository(String repository) { return activeRulesByRepository.get(repository); }
@Override public Collection<ActiveRule> findByLanguage(String language) { return activeRulesByLanguage.get(language); }
@Override public Collection<Rule> findByRepository(String repository) { return rulesByRepository.get(repository); }
/** * Returns an optional charset for the value of the charset parameter if it is specified. * * @throws IllegalStateException if multiple charset values have been set for this media type * @throws IllegalCharsetNameException if a charset value is present, but illegal * @throws UnsupportedCharsetException if a charset value is present, but no support is available * in this instance of the Java virtual machine */ public Optional<Charset> charset() { // racy single-check idiom, this is safe because Optional is immutable. Optional<Charset> local = parsedCharset; if (local == null) { String value = null; local = Optional.absent(); for (String currentValue : parameters.get(CHARSET_ATTRIBUTE)) { if (value == null) { value = currentValue; local = Optional.of(Charset.forName(value)); } else if (!value.equals(currentValue)) { throw new IllegalStateException( "Multiple charset values defined: " + value + ", " + currentValue); } } parsedCharset = local; } return local; }
/** * Returns an optional charset for the value of the charset parameter if it is specified. * * @throws IllegalStateException if multiple charset values have been set for this media type * @throws IllegalCharsetNameException if a charset value is present, but illegal * @throws UnsupportedCharsetException if a charset value is present, but no support is available * in this instance of the Java virtual machine */ public Optional<Charset> charset() { // racy single-check idiom, this is safe because Optional is immutable. Optional<Charset> local = parsedCharset; if (local == null) { String value = null; local = Optional.absent(); for (String currentValue : parameters.get(CHARSET_ATTRIBUTE)) { if (value == null) { value = currentValue; local = Optional.of(Charset.forName(value)); } else if (!value.equals(currentValue)) { throw new IllegalStateException( "Multiple charset values defined: " + value + ", " + currentValue); } } parsedCharset = local; } return local; }
/** * Returns an optional charset for the value of the charset parameter if it is specified. * * @throws IllegalStateException if multiple charset values have been set for this media type * @throws IllegalCharsetNameException if a charset value is present, but illegal * @throws UnsupportedCharsetException if a charset value is present, but no support is available * in this instance of the Java virtual machine */ public Optional<Charset> charset() { // racy single-check idiom, this is safe because Optional is immutable. Optional<Charset> local = parsedCharset; if (local == null) { String value = null; local = Optional.absent(); for (String currentValue : parameters.get(CHARSET_ATTRIBUTE)) { if (value == null) { value = currentValue; local = Optional.of(Charset.forName(value)); } else if (!value.equals(currentValue)) { throw new IllegalStateException( "Multiple charset values defined: " + value + ", " + currentValue); } } parsedCharset = local; } return local; }
@Override public Description matchMethodInvocation(MethodInvocationTree tree, VisitorState state) { for (ImmutableMap.Entry<Matcher<ExpressionTree>, Class<?>> entry : MATCHER_MAP.entrySet()) { if (entry.getKey().matches(tree, state)) { return isDefinitelyInvalidChronoField(tree, UNSUPPORTED.get(entry.getValue())) ? describeMatch(tree) : Description.NO_MATCH; } } return Description.NO_MATCH; }
private Collection<org.sonar.api.rules.Rule> convertToRuleApi(DbSession dbSession, List<RuleDto> ruleDtos) { List<org.sonar.api.rules.Rule> rules = new ArrayList<>(); List<RuleKey> ruleKeys = FluentIterable.from(ruleDtos).transform(RuleDtoToKey.INSTANCE).toList(); List<RuleParamDto> ruleParamDtos = ruleDao.selectRuleParamsByRuleKeys(dbSession, ruleKeys); ImmutableListMultimap<Integer, RuleParamDto> ruleParamByRuleId = FluentIterable.from(ruleParamDtos).index(RuleParamDtoToRuleId.INSTANCE); for (RuleDto rule : ruleDtos) { rules.add(toRule(rule, ruleParamByRuleId.get(rule.getId()))); } return rules; }
@Override public String getHeaderField(String name) { try { connect(); } catch (IOException e) { return null; } // no header should have more than one value return Iterables.getFirst(headers.get(Ascii.toLowerCase(name)), null); } }
public void testBuilder_withImmutableEntry() { ImmutableListMultimap<String, Integer> multimap = new Builder<String, Integer>().put(Maps.immutableEntry("one", 1)).build(); assertEquals(Arrays.asList(1), multimap.get("one")); }
@Memoized @Override Iterable<? extends RecursableDiffEntity> childEntities() { // Assemble the diffs in field number order so it most closely matches the schema. ImmutableList.Builder<RecursableDiffEntity> builder = ImmutableList.builderWithExpectedSize( singularFields().size() + repeatedFields().size() + unknownFields().asSet().size()); Set<Integer> fieldNumbers = Sets.union(singularFields().keySet(), repeatedFields().keySet()); for (int fieldNumber : Ordering.natural().sortedCopy(fieldNumbers)) { builder.addAll(singularFields().get(fieldNumber)); builder.addAll(repeatedFields().get(fieldNumber)); } builder.addAll(unknownFields().asSet()); return builder.build(); }
public void testBuilderPutWithDuplicates() { ImmutableListMultimap.Builder<String, Integer> builder = ImmutableListMultimap.builder(); builder.putAll("foo", 1, 2, 3); builder.putAll("bar", 4, 5); builder.put("foo", 1); ImmutableListMultimap<String, Integer> multimap = builder.build(); assertEquals(Arrays.asList(1, 2, 3, 1), multimap.get("foo")); assertEquals(Arrays.asList(4, 5), multimap.get("bar")); assertEquals(6, multimap.size()); }
public void testBuilderPutAllWithDuplicates() { ImmutableListMultimap.Builder<String, Integer> builder = ImmutableListMultimap.builder(); builder.putAll("foo", 1, 2, 3); builder.putAll("bar", 4, 5); builder.putAll("foo", 1, 6, 7); ImmutableListMultimap<String, Integer> multimap = builder.build(); assertEquals(Arrays.asList(1, 2, 3, 1, 6, 7), multimap.get("foo")); assertEquals(Arrays.asList(4, 5), multimap.get("bar")); assertEquals(8, multimap.size()); }
@Override final void printContents(boolean includeMatches, String fieldPrefix, StringBuilder sb) { if (!includeMatches && isMatched()) { return; } for (int fieldNumber : singularFields().keySet()) { for (SingularField singularField : singularFields().get(fieldNumber)) { singularField.printContents(includeMatches, fieldPrefix, sb); } } }
public void testBuilder_withMutableEntry() { ImmutableListMultimap.Builder<String, Integer> builder = new Builder<>(); final StringHolder holder = new StringHolder(); holder.string = "one"; Entry<String, Integer> entry = new AbstractMapEntry<String, Integer>() { @Override public String getKey() { return holder.string; } @Override public Integer getValue() { return 1; } }; builder.put(entry); holder.string = "two"; assertEquals(Arrays.asList(1), builder.build().get("one")); }
public void testBuilderOrderKeysBy() { ImmutableListMultimap.Builder<String, Integer> builder = ImmutableListMultimap.builder(); builder.put("b", 3); builder.put("d", 2); builder.put("a", 5); builder.orderKeysBy(Collections.reverseOrder()); builder.put("c", 4); builder.put("a", 2); builder.put("b", 6); ImmutableListMultimap<String, Integer> multimap = builder.build(); assertThat(multimap.keySet()).containsExactly("d", "c", "b", "a").inOrder(); assertThat(multimap.values()).containsExactly(2, 4, 3, 6, 5, 2).inOrder(); assertThat(multimap.get("a")).containsExactly(5, 2).inOrder(); assertThat(multimap.get("b")).containsExactly(3, 6).inOrder(); }
public void testBuilderOrderValuesBy() { ImmutableListMultimap.Builder<String, Integer> builder = ImmutableListMultimap.builder(); builder.put("b", 3); builder.put("d", 2); builder.put("a", 5); builder.orderValuesBy(Collections.reverseOrder()); builder.put("c", 4); builder.put("a", 2); builder.put("b", 6); ImmutableListMultimap<String, Integer> multimap = builder.build(); assertThat(multimap.keySet()).containsExactly("b", "d", "a", "c").inOrder(); assertThat(multimap.values()).containsExactly(6, 3, 2, 5, 2, 4).inOrder(); assertThat(multimap.get("a")).containsExactly(5, 2).inOrder(); assertThat(multimap.get("b")).containsExactly(6, 3).inOrder(); }
public void testBuilderOrderKeysAndValuesBy() { ImmutableListMultimap.Builder<String, Integer> builder = ImmutableListMultimap.builder(); builder.put("b", 3); builder.put("d", 2); builder.put("a", 5); builder.orderKeysBy(Collections.reverseOrder()); builder.orderValuesBy(Collections.reverseOrder()); builder.put("c", 4); builder.put("a", 2); builder.put("b", 6); ImmutableListMultimap<String, Integer> multimap = builder.build(); assertThat(multimap.keySet()).containsExactly("d", "c", "b", "a").inOrder(); assertThat(multimap.values()).containsExactly(2, 4, 6, 3, 5, 2).inOrder(); assertThat(multimap.get("a")).containsExactly(5, 2).inOrder(); assertThat(multimap.get("b")).containsExactly(6, 3).inOrder(); }
@SuppressWarnings("CheckReturnValue") default void use() { ImmutableExtraCollection.of( ImmutableList.<String>of(), ImmutableMultimap.<Integer, String>of(), ImmutableMultimap.<Integer, String>of(), ImmutableMultimap.<Integer, String>of(), ImmutableBiMap.<Integer, String>of()); ImmutableExtraCollection.of(); ImmutableExtraCollection collection = ImmutableExtraCollection.builder() .addBag("2", "2") .putIndex(1, "2", "3", "4") .putAllIndex(1, Arrays.asList("2", "3", "4")) .putIndex(2, "5") .putIndexList(1, "") .putIndexSet(2, "2") .putAllIndexSet(2, Arrays.asList("3", "4")) .putBiMap(1, "a") .putBiMap(2, "b") .putAllBiMap(Collections.singletonMap(3, "c")) .build(); collection.bag().count("2"); collection.index().get(1); collection.indexList().get(1); collection.indexSet().get(2); } }
public void testBuilderOrderKeysByDuplicates() { ImmutableListMultimap.Builder<String, Integer> builder = ImmutableListMultimap.builder(); builder.put("bb", 3); builder.put("d", 2); builder.put("a", 5); builder.orderKeysBy( new Ordering<String>() { @Override public int compare(String left, String right) { return left.length() - right.length(); } }); builder.put("cc", 4); builder.put("a", 2); builder.put("bb", 6); ImmutableListMultimap<String, Integer> multimap = builder.build(); assertThat(multimap.keySet()).containsExactly("d", "a", "bb", "cc").inOrder(); assertThat(multimap.values()).containsExactly(2, 5, 2, 3, 6, 4).inOrder(); assertThat(multimap.get("a")).containsExactly(5, 2).inOrder(); assertThat(multimap.get("bb")).containsExactly(3, 6).inOrder(); }