@SuppressWarnings("unchecked") <K1 extends K, V1 extends V> Weigher<K1, V1> getWeigher() { return (Weigher<K1, V1>) MoreObjects.firstNonNull(weigher, OneWeigher.INSTANCE); }
@SuppressWarnings("unchecked") <K1 extends K, V1 extends V> RemovalListener<K1, V1> getRemovalListener() { return (RemovalListener<K1, V1>) MoreObjects.firstNonNull(removalListener, NullListener.INSTANCE); }
Strength getKeyStrength() { return MoreObjects.firstNonNull(keyStrength, Strength.STRONG); }
Strength getKeyStrength() { return MoreObjects.firstNonNull(keyStrength, Strength.STRONG); }
Strength getValueStrength() { return MoreObjects.firstNonNull(valueStrength, Strength.STRONG); }
Strength getValueStrength() { return MoreObjects.firstNonNull(valueStrength, Strength.STRONG); }
private static Map<? extends Enum, LockGraphNode> getOrCreateNodes(Class<? extends Enum> clazz) { Map<? extends Enum, LockGraphNode> existing = lockGraphNodesPerType.get(clazz); if (existing != null) { return existing; } Map<? extends Enum, LockGraphNode> created = createNodes(clazz); existing = lockGraphNodesPerType.putIfAbsent(clazz, created); return MoreObjects.firstNonNull(existing, created); }
/** * Returns an immutable set of the values for the given key. If no mappings * in the multimap have the provided key, an empty immutable set is returned. * The values are in the same order as the parameters used to build this * multimap. */ @Override public ImmutableSet<V> get(@Nullable K key) { // This cast is safe as its type is known in constructor. ImmutableSet<V> set = (ImmutableSet<V>) map.get(key); return MoreObjects.firstNonNull(set, emptySet); }
@Nullable private AvlNode<E> floor(Comparator<? super E> comparator, E e) { int cmp = comparator.compare(e, elem); if (cmp > 0) { return (right == null) ? this : MoreObjects.firstNonNull(right.floor(comparator, e), this); } else if (cmp == 0) { return this; } else { return (left == null) ? null : left.floor(comparator, e); } }
/** * Constructs a TeredoInfo instance. * * <p>Both server and client can be {@code null}, in which case the value {@code "0.0.0.0"} will * be assumed. * * @throws IllegalArgumentException if either of the {@code port} or the {@code flags} arguments * are out of range of an unsigned short */ // TODO: why is this public? public TeredoInfo( @Nullable Inet4Address server, @Nullable Inet4Address client, int port, int flags) { checkArgument( (port >= 0) && (port <= 0xffff), "port '%s' is out of range (0 <= port <= 0xffff)", port); checkArgument( (flags >= 0) && (flags <= 0xffff), "flags '%s' is out of range (0 <= flags <= 0xffff)", flags); this.server = MoreObjects.firstNonNull(server, ANY4); this.client = MoreObjects.firstNonNull(client, ANY4); this.port = port; this.flags = flags; }
@Override public Collection<V> removeAll(@Nullable Object key) { return MoreObjects.firstNonNull(asMap().remove(key), unmodifiableEmptyCollection()); }
@Nullable private AvlNode<E> ceiling(Comparator<? super E> comparator, E e) { int cmp = comparator.compare(e, elem); if (cmp < 0) { return (left == null) ? this : MoreObjects.firstNonNull(left.ceiling(comparator, e), this); } else if (cmp == 0) { return this; } else { return (right == null) ? null : right.ceiling(comparator, e); } }
@VisibleForTesting Set<Subscriber> getSubscribersForTesting(Class<?> eventType) { return MoreObjects.firstNonNull(subscribers.get(eventType), ImmutableSet.<Subscriber>of()); }
/** * Registers all subscriber methods on the given listener object. */ void register(Object listener) { Multimap<Class<?>, Subscriber> listenerMethods = findAllSubscribers(listener); for (Map.Entry<Class<?>, Collection<Subscriber>> entry : listenerMethods.asMap().entrySet()) { Class<?> eventType = entry.getKey(); Collection<Subscriber> eventMethodsInListener = entry.getValue(); CopyOnWriteArraySet<Subscriber> eventSubscribers = subscribers.get(eventType); if (eventSubscribers == null) { CopyOnWriteArraySet<Subscriber> newSet = new CopyOnWriteArraySet<Subscriber>(); eventSubscribers = MoreObjects.firstNonNull(subscribers.putIfAbsent(eventType, newSet), newSet); } eventSubscribers.addAll(eventMethodsInListener); } }
@Override public L getAt(int index) { if (size != Integer.MAX_VALUE) { Preconditions.checkElementIndex(index, size()); } // else no check necessary, all index values are valid L existing = locks.get(index); if (existing != null) { return existing; } L created = supplier.get(); existing = locks.putIfAbsent(index, created); return MoreObjects.firstNonNull(existing, created); }
Equivalence<Object> getKeyEquivalence() { return MoreObjects.firstNonNull(keyEquivalence, getKeyStrength().defaultEquivalence()); }
Equivalence<Object> getValueEquivalence() { return MoreObjects.firstNonNull(valueEquivalence, getValueStrength().defaultEquivalence()); }
Equivalence<Object> getKeyEquivalence() { return MoreObjects.firstNonNull(keyEquivalence, getKeyStrength().defaultEquivalence()); }
/** * {@inheritDoc} * * @throws NullPointerException if {@code columnKey} is {@code null} */ @Override public ImmutableMap<R, V> column(C columnKey) { checkNotNull(columnKey); return MoreObjects.firstNonNull( (ImmutableMap<R, V>) columnMap().get(columnKey), ImmutableMap.<R, V>of()); }
/** * {@inheritDoc} * * @throws NullPointerException if {@code rowKey} is {@code null} */ @Override public ImmutableMap<C, V> row(R rowKey) { checkNotNull(rowKey); return MoreObjects.firstNonNull( (ImmutableMap<C, V>) rowMap().get(rowKey), ImmutableMap.<C, V>of()); }