|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Function | |
---|---|
com.google.common.base | Basic utility libraries and interfaces. |
com.google.common.cache | This package contains caching utilities. |
com.google.common.collect | This package contains generic collection interfaces and implementations, and other utilities for working with collections. |
com.google.common.util.concurrent | Concurrency utilities. |
Uses of Function in com.google.common.base |
---|
Methods in com.google.common.base that return Function | ||
---|---|---|
static
|
Functions.compose(Function<B,C> g,
Function<A,? extends B> f)
Returns the composition of two functions. |
|
static
|
Functions.constant(E value)
Creates a function that returns value for any input. |
|
static
|
Functions.forMap(Map<K,? extends V> map,
V defaultValue)
Returns a function which performs a map lookup with a default value. |
|
static
|
Functions.forMap(Map<K,V> map)
Returns a function which performs a map lookup. |
|
static
|
Functions.forPredicate(Predicate<T> predicate)
Creates a function that returns the same boolean output as the given predicate for all inputs. |
|
static
|
Functions.forSupplier(Supplier<T> supplier)
Returns a function that always returns the result of invoking Supplier.get() on supplier , regardless of its input. |
|
static
|
Functions.identity()
Returns the identity function. |
|
static
|
Suppliers.supplierFunction()
Returns a function that accepts a supplier and returns the result of invoking Supplier.get() on that supplier. |
|
static Function<Object,String> |
Functions.toStringFunction()
Returns a function that calls toString() on its argument. |
|
static
|
Enums.valueOfFunction(Class<T> enumClass)
Returns a Function that maps an Enum name to the associated
Enum constant. |
Methods in com.google.common.base with parameters of type Function | ||
---|---|---|
static
|
Suppliers.compose(Function<? super F,T> function,
Supplier<F> supplier)
Returns a new supplier which is the composition of the provided function and supplier. |
|
static
|
Functions.compose(Function<B,C> g,
Function<A,? extends B> f)
Returns the composition of two functions. |
|
static
|
Functions.compose(Function<B,C> g,
Function<A,? extends B> f)
Returns the composition of two functions. |
|
static
|
Predicates.compose(Predicate<B> predicate,
Function<A,? extends B> function)
Returns the composition of a function and a predicate. |
|
|
Equivalence.onResultOf(Function<F,? extends T> function)
Returns a new equivalence relation for F which evaluates equivalence by first applying
function to the argument, then evaluating using this . |
|
abstract
|
Optional.transform(Function<? super T,V> function)
If the instance is present, it is transformed with the given Function ; otherwise,
Optional.absent() is returned. |
Uses of Function in com.google.common.cache |
---|
Subinterfaces of Function in com.google.common.cache | |
---|---|
interface |
LoadingCache<K,V>
A semi-persistent mapping from keys to values. |
Classes in com.google.common.cache that implement Function | |
---|---|
class |
AbstractLoadingCache<K,V>
This class provides a skeletal implementation of the Cache interface to minimize the
effort required to implement this interface. |
class |
ForwardingLoadingCache<K,V>
A cache which forwards all its method calls to another cache. |
static class |
ForwardingLoadingCache.SimpleForwardingLoadingCache<K,V>
A simplified version of ForwardingLoadingCache where subclasses can pass in an already
constructed LoadingCache as the delegete. |
Methods in com.google.common.cache with parameters of type Function | ||
---|---|---|
static
|
CacheLoader.from(Function<K,V> function)
Returns a cache loader based on an existing function instance. |
Uses of Function in com.google.common.collect |
---|
Methods in com.google.common.collect that return Function | ||
---|---|---|
static
|
Interners.asFunction(Interner<E> interner)
Returns a function that delegates to the Interner.intern(E) method of the given interner. |
Methods in com.google.common.collect with parameters of type Function | ||
---|---|---|
static
|
Multimaps.index(Iterable<V> values,
Function<? super V,K> keyFunction)
Creates an index ImmutableListMultimap that contains the results of
applying a specified function to each item in an Iterable of
values. |
|
static
|
Multimaps.index(Iterator<V> values,
Function<? super V,K> keyFunction)
Creates an index ImmutableListMultimap that contains the results of
applying a specified function to each item in an Iterator of
values. |
|
abstract
|
GenericMapMaker.makeComputingMap(Function<? super K,? extends V> computingFunction)
Deprecated. |
|
|
MapMaker.makeComputingMap(Function<? super K,? extends V> computingFunction)
Deprecated. Caching functionality in MapMaker is being moved to
CacheBuilder , with MapMaker.makeComputingMap(com.google.common.base.Function super K, ? extends V>) being replaced
by CacheBuilder.build(com.google.common.cache.CacheLoader super K1, V1>) . See the
MapMaker
Migration Guide for more details.
This method is scheduled for deletion in February 2013. |
|
|
Ordering.onResultOf(Function<F,? extends T> function)
Returns a new ordering on F which orders elements by first applying
a function to them, then comparing those results using this . |
|
static
|
Collections2.transform(Collection<F> fromCollection,
Function<? super F,T> function)
Returns a collection that applies function to each element of
fromCollection . |
|
|
FluentIterable.transform(Function<? super E,T> function)
Returns a fluent iterable that applies function to each element of this
fluent iterable. |
|
static
|
Iterables.transform(Iterable<F> fromIterable,
Function<? super F,? extends T> function)
Returns an iterable that applies function to each element of fromIterable . |
|
static
|
Iterators.transform(Iterator<F> fromIterator,
Function<? super F,? extends T> function)
Returns an iterator that applies function to each element of fromIterator . |
|
static
|
Lists.transform(List<F> fromList,
Function<? super F,? extends T> function)
Returns a list that applies function to each element of fromList . |
|
|
FluentIterable.transformAndConcat(Function<? super E,? extends Iterable<T>> function)
Applies function to each element of this fluent iterable and returns
a fluent iterable with the concatenated combination of results. |
|
static
|
Multimaps.transformValues(ListMultimap<K,V1> fromMultimap,
Function<? super V1,V2> function)
Returns a view of a ListMultimap where each value is transformed by
a function. |
|
static
|
Maps.transformValues(Map<K,V1> fromMap,
Function<? super V1,V2> function)
Returns a view of a map where each value is transformed by a function. |
|
static
|
Multimaps.transformValues(Multimap<K,V1> fromMultimap,
Function<? super V1,V2> function)
Returns a view of a multimap where each value is transformed by a function. |
|
static
|
Maps.transformValues(NavigableMap<K,V1> fromMap,
Function<? super V1,V2> function)
Returns a view of a navigable map where each value is transformed by a function. |
|
static
|
Maps.transformValues(SortedMap<K,V1> fromMap,
Function<? super V1,V2> function)
Returns a view of a sorted map where each value is transformed by a function. |
|
static
|
Tables.transformValues(Table<R,C,V1> fromTable,
Function<? super V1,V2> function)
Returns a view of a table where each value is transformed by a function. |
|
static
|
Maps.uniqueIndex(Iterable<V> values,
Function<? super V,K> keyFunction)
Returns an immutable map for which the Map.values() are the given
elements in the given order, and each key is the product of invoking a
supplied function on its corresponding value. |
|
static
|
Maps.uniqueIndex(Iterator<V> values,
Function<? super V,K> keyFunction)
Returns an immutable map for which the Map.values() are the given
elements in the given order, and each key is the product of invoking a
supplied function on its corresponding value. |
Uses of Function in com.google.common.util.concurrent |
---|
Methods in com.google.common.util.concurrent with parameters of type Function | ||
---|---|---|
static
|
Futures.lazyTransform(Future<I> input,
Function<? super I,? extends O> function)
Like Futures.transform(ListenableFuture, Function) except that the
transformation function is invoked on each call to
get() on the returned future. |
|
static
|
Futures.makeChecked(ListenableFuture<V> future,
Function<Exception,X> mapper)
Creates a CheckedFuture out of a normal ListenableFuture
and a Function that maps from Exception instances into the
appropriate checked type. |
|
static
|
Futures.transform(ListenableFuture<I> input,
Function<? super I,? extends O> function)
Returns a new ListenableFuture whose result is the product of
applying the given Function to the result of the given Future . |
|
static
|
Futures.transform(ListenableFuture<I> input,
Function<? super I,? extends O> function,
Executor executor)
Returns a new ListenableFuture whose result is the product of
applying the given Function to the result of the given Future . |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |