public boolean isEmpty() { return m_pipeline.isEmpty(); } }
private String reorderedImportsString(ImmutableSortedSet<Import> imports) { Preconditions.checkArgument(!imports.isEmpty(), "imports"); Import firstImport = imports.iterator().next(); // Pretend that the first import was preceded by another import of the same kind // (static or non-static), so we don't insert a newline there. boolean lastWasStatic = firstImport.isStatic; StringBuilder sb = new StringBuilder(); for (Import thisImport : imports) { if (lastWasStatic && !thisImport.isStatic) { // Blank line between static and non-static imports. sb.append(lineSeparator); } lastWasStatic = thisImport.isStatic; sb.append(thisImport); } return sb.toString(); }
public boolean containsColumn(byte[] col) { return columns.isEmpty() || columns.contains(col); }
@Override public String toString() { ToStringHelper helper = MoreObjects.toStringHelper(getClass()).omitNullValues(); PtBytes.addIfNotEmpty(helper, "startInclusive", startInclusive); PtBytes.addIfNotEmpty(helper, "endExclusive", endExclusive); if (columns != null && !columns.isEmpty()) { helper.add("columns", FluentIterable.from(columns) .filter(Predicates.notNull()) .transform(PtBytes.BYTES_TO_HEX_STRING)); } helper.add("batchHint", batchHint); helper.add("reverse", reverse); return helper.toString(); }
.map(Map.Entry::getKey) .collect(ImmutableSortedSet.toImmutableSortedSet(Ordering.natural())); if (!nullKeys.isEmpty()) { throw new IllegalArgumentException( "Null values found in w3c capabilities. Keys are: " + nullKeys); .map(Map.Entry::getKey) .collect(ImmutableSortedSet.toImmutableSortedSet(Ordering.natural())); if (!illegalKeys.isEmpty()) { throw new IllegalArgumentException( "Illegal key values seen in w3c capabilities: " + illegalKeys);
@Override public boolean useInnerSwitchingProvider() { return !binding.injectionSites().isEmpty(); } }
private JsType(Builder builder) { // Sort for determinism, order doesn't matter. this.typeExpressions = builder.typeExpressions.build(); checkArgument(!typeExpressions.isEmpty()); this.coercionStrategies = Sets.immutableEnumSet(builder.coercionStrategies); this.extraRequires = builder.extraRequires.build(); this.predicate = checkNotNull(builder.predicate); }
private JsType(Builder builder) { // Sort for determinism, order doesn't matter. this.typeExpressions = builder.typeExpressions.build(); checkArgument(!typeExpressions.isEmpty()); this.coercionStrategies = Sets.immutableEnumSet(builder.coercionStrategies); this.extraRequires = builder.extraRequires.build(); this.predicate = checkNotNull(builder.predicate); }
private boolean typeHasInjectionSites(Key key) { return injectBindingRegistry .getOrFindMembersInjectionBinding(key) .map(binding -> !binding.injectionSites().isEmpty()) .orElse(false); } }
private Optional<Integer> getMaxSizeOfOversizedItems(List<MailboxAnnotation> mailboxAnnotations, final Integer maxsize) { Predicate<MailboxAnnotation> filterOverSizedAnnotation = annotation -> annotation.size() > maxsize; ImmutableSortedSet<Integer> overLimitSizes = mailboxAnnotations.stream() .filter(filterOverSizedAnnotation) .map(MailboxAnnotation::size) .collect(Guavate.toImmutableSortedSet(Comparator.reverseOrder())); if (overLimitSizes.isEmpty()) { return Optional.empty(); } return Optional.of(overLimitSizes.first()); }
private List<Step<?>> getTraceSteps() { return _flowDiffs.entrySet().stream() .map( entry -> { ImmutableSortedSet<FlowDiff> flowDiffs = entry.getValue().build(); TransformationStepDetail detail = new TransformationStepDetail(entry.getKey(), flowDiffs); StepAction action = flowDiffs.isEmpty() ? StepAction.PERMITTED : StepAction.TRANSFORMED; return new org.batfish.datamodel.flow.TransformationStep(detail, action); }) .collect(ImmutableList.toImmutableList()); }
@Nullable @Override public List<String> getOutputPropertyNames() { // Copy should be a NOOP as this is an immutable sorted set upstream. ImmutableSortedSet<String> outputPropertyNames = key.getInputs().getOutputPropertyNames(); if (outputPropertyNames == null || outputPropertyNames.isEmpty()) { return null; } else { return ImmutableSortedSet.copyOf(outputPropertyNames).asList(); } }
static <K, V> ImmutableSortedMap<K, V> from( ImmutableSortedSet<K> keySet, ImmutableList<V> valueList) { if (keySet.isEmpty()) { return emptyMap(keySet.comparator()); } else { return new RegularImmutableSortedMap<K, V>( (RegularImmutableSortedSet<K>) keySet, valueList); } }
static <K, V> ImmutableSortedMap<K, V> from( ImmutableSortedSet<K> keySet, ImmutableList<V> valueList) { if (keySet.isEmpty()) { return emptyMap(keySet.comparator()); } else { return new RegularImmutableSortedMap<K, V>( (RegularImmutableSortedSet<K>) keySet, valueList); } }
static <K, V> ImmutableSortedMap<K, V> from( ImmutableSortedSet<K> keySet, ImmutableList<V> valueList) { if (keySet.isEmpty()) { return emptyMap(keySet.comparator()); } else { return new RegularImmutableSortedMap<K, V>( (RegularImmutableSortedSet<K>) keySet, valueList); } }
static <K, V> ImmutableSortedMap<K, V> from( ImmutableSortedSet<K> keySet, ImmutableList<V> valueList) { if (keySet.isEmpty()) { return emptyMap(keySet.comparator()); } else { return new RegularImmutableSortedMap<K, V>( (RegularImmutableSortedSet<K>) keySet, valueList); } }
static <K, V> ImmutableSortedMap<K, V> from( ImmutableSortedSet<K> keySet, ImmutableList<V> valueList) { if (keySet.isEmpty()) { return emptyMap(keySet.comparator()); } else { return new RegularImmutableSortedMap<K, V>( (RegularImmutableSortedSet<K>) keySet, valueList); } }
static <K, V> ImmutableSortedMap<K, V> from( ImmutableSortedSet<K> keySet, ImmutableList<V> valueList) { if (keySet.isEmpty()) { return emptyMap(keySet.comparator()); } else { return new RegularImmutableSortedMap<K, V>( (RegularImmutableSortedSet<K>) keySet, valueList); } }
static <K, V> ImmutableSortedMap<K, V> from( ImmutableSortedSet<K> keySet, ImmutableList<V> valueList) { if (keySet.isEmpty()) { return emptyMap(keySet.comparator()); } else { return new RegularImmutableSortedMap<K, V>( (RegularImmutableSortedSet<K>) keySet, valueList); } }
/** * @return highest {@link PutativeImpact} of all {@link #getEffects}. */ public PutativeImpact getPutativeImpact() { if (effects.isEmpty()) return null; VariantEffect worst = effects.first(); for (VariantEffect vt : effects) if (worst.getImpact().compareTo(vt.getImpact()) > 0) worst = vt; return worst.getImpact(); }