Uses of Interface
org.apache.commons.collections4.Transformer

Packages that use Transformer
org.apache.commons.collections4 This package contains the interfaces and utilities shared across all the subpackages of this component. 
org.apache.commons.collections4.bag This package contains implementations of the Bag and SortedBag interfaces. 
org.apache.commons.collections4.collection This package contains implementations of the Collection interface. 
org.apache.commons.collections4.comparators This package contains implementations of the Comparator interface. 
org.apache.commons.collections4.functors This package contains implementations of the Closure, Predicate, Transformer and Factory interfaces. 
org.apache.commons.collections4.iterators This package contains implementations of the Iterator interface. 
org.apache.commons.collections4.list This package contains implementations of the List interface. 
org.apache.commons.collections4.map This package contains implementations of the Map, IterableMap, OrderedMap and SortedMap interfaces. 
org.apache.commons.collections4.queue This package contains implementations for the Queue interface. 
org.apache.commons.collections4.set This package contains implementations of the Set and SortedSet interfaces. 
org.apache.commons.collections4.splitmap The "split map" concept is that of an object that implements the Put and Get interfaces, with differing generic types. 
 

Uses of Transformer in org.apache.commons.collections4
 

Methods in org.apache.commons.collections4 that return Transformer
static
<T> Transformer<T,T>
TransformerUtils.asTransformer(Closure<? super T> closure)
          Creates a Transformer that calls a Closure each time the transformer is used.
static
<I,O> Transformer<I,O>
TransformerUtils.asTransformer(Factory<? extends O> factory)
          Creates a Transformer that calls a Factory each time the transformer is used.
static
<T> Transformer<T,Boolean>
TransformerUtils.asTransformer(Predicate<? super T> predicate)
          Creates a Transformer that calls a Predicate each time the transformer is used.
static
<T> Transformer<T,T>
TransformerUtils.chainedTransformer(Collection<? extends Transformer<T,T>> transformers)
          Create a new Transformer that calls each transformer in turn, passing the result into the next transformer.
static
<T> Transformer<T,T>
TransformerUtils.chainedTransformer(Transformer<? super T,? extends T>... transformers)
          Create a new Transformer that calls each transformer in turn, passing the result into the next transformer.
static
<T> Transformer<T,T>
TransformerUtils.cloneTransformer()
          Gets a transformer that returns a clone of the input object.
static
<I,O> Transformer<I,O>
TransformerUtils.constantTransformer(O constantToReturn)
          Creates a Transformer that will return the same object each time the transformer is used.
static
<I,O> Transformer<I,O>
TransformerUtils.exceptionTransformer()
          Gets a transformer that always throws an exception.
static
<T> Transformer<Class<? extends T>,T>
TransformerUtils.instantiateTransformer()
          Gets a Transformer that expects an input Class object that it will instantiate.
static
<T> Transformer<Class<? extends T>,T>
TransformerUtils.instantiateTransformer(Class<?>[] paramTypes, Object[] args)
          Creates a Transformer that expects an input Class object that it will instantiate.
static
<I,O> Transformer<I,O>
TransformerUtils.invokerTransformer(String methodName)
          Gets a Transformer that invokes a method on the input object.
static
<I,O> Transformer<I,O>
TransformerUtils.invokerTransformer(String methodName, Class<?>[] paramTypes, Object[] args)
          Gets a Transformer that invokes a method on the input object.
static
<I,O> Transformer<I,O>
TransformerUtils.mapTransformer(Map<? super I,? extends O> map)
          Creates a Transformer that uses the passed in Map to transform the input object (as a simple lookup).
static
<T> Transformer<T,T>
TransformerUtils.nopTransformer()
          Gets a transformer that returns the input object.
static
<I,O> Transformer<I,O>
TransformerUtils.nullTransformer()
          Gets a transformer that always returns null.
static
<T> Transformer<T,String>
TransformerUtils.stringValueTransformer()
          Gets a transformer that returns a java.lang.String representation of the input object.
static
<I,O> Transformer<I,O>
TransformerUtils.switchMapTransformer(Map<I,Transformer<I,O>> objectsAndTransformers)
          Create a new Transformer that uses the input object as a key to find the transformer to call.
static
<I,O> Transformer<I,O>
TransformerUtils.switchTransformer(Map<Predicate<I>,Transformer<I,O>> predicatesAndTransformers)
          Create a new Transformer that calls one of the transformers depending on the predicates.
static
<I,O> Transformer<I,O>
TransformerUtils.switchTransformer(Predicate<? super I>[] predicates, Transformer<? super I,? extends O>[] transformers)
          Create a new Transformer that calls one of the transformers depending on the predicates.
static
<I,O> Transformer<I,O>
TransformerUtils.switchTransformer(Predicate<? super I>[] predicates, Transformer<? super I,? extends O>[] transformers, Transformer<? super I,? extends O> defaultTransformer)
          Create a new Transformer that calls one of the transformers depending on the predicates.
static
<I,O> Transformer<I,O>
TransformerUtils.switchTransformer(Predicate<? super I> predicate, Transformer<? super I,? extends O> trueTransformer, Transformer<? super I,? extends O> falseTransformer)
          Create a new Transformer that calls one of two transformers depending on the specified predicate.
 

Methods in org.apache.commons.collections4 with parameters of type Transformer
static
<E> Closure<E>
ClosureUtils.asClosure(Transformer<? super E,?> transformer)
          Creates a Closure that calls a Transformer each time it is called.
static
<T> Predicate<T>
PredicateUtils.asPredicate(Transformer<? super T,Boolean> transformer)
          Create a new Predicate that wraps a Transformer.
static
<T> Transformer<T,T>
TransformerUtils.chainedTransformer(Transformer<? super T,? extends T>... transformers)
          Create a new Transformer that calls each transformer in turn, passing the result into the next transformer.
static
<I,O,R extends Collection<? super O>>
R
CollectionUtils.collect(Iterable<? extends I> inputCollection, Transformer<? super I,? extends O> transformer, R outputCollection)
          Transforms all elements from inputCollection with the given transformer and adds them to the outputCollection.
static
<I,O> Collection<O>
CollectionUtils.collect(Iterable<I> inputCollection, Transformer<? super I,? extends O> transformer)
          Returns a new Collection consisting of the elements of inputCollection transformed by the given transformer.
static
<I,O,R extends Collection<? super O>>
R
CollectionUtils.collect(Iterator<? extends I> inputIterator, Transformer<? super I,? extends O> transformer, R outputCollection)
          Transforms all elements from the inputIterator with the given transformer and adds them to the outputCollection.
static
<I,O> Collection<O>
CollectionUtils.collect(Iterator<I> inputIterator, Transformer<? super I,? extends O> transformer)
          Transforms all elements from the inputIterator with the given transformer and adds them to the outputCollection.
static
<K,V> IterableMap<K,V>
MapUtils.lazyMap(Map<K,V> map, Transformer<? super K,? extends V> transformerFactory)
          Returns a "lazy" map whose values will be created on demand.
static
<K,V> SortedMap<K,V>
MapUtils.lazySortedMap(SortedMap<K,V> map, Transformer<? super K,? extends V> transformerFactory)
          Returns a "lazy" sorted map whose values will be created on demand.
static
<E> Iterator<E>
IteratorUtils.objectGraphIterator(E root, Transformer<? super E,? extends E> transformer)
          Gets an iterator that operates over an object graph.
static
<K,V,E> void
MapUtils.populateMap(Map<K,V> map, Iterable<? extends E> elements, Transformer<E,K> keyTransformer, Transformer<E,V> valueTransformer)
          Populates a Map using the supplied Transformers to transform the elements into keys and values.
static
<K,V,E> void
MapUtils.populateMap(Map<K,V> map, Iterable<? extends E> elements, Transformer<E,K> keyTransformer, Transformer<E,V> valueTransformer)
          Populates a Map using the supplied Transformers to transform the elements into keys and values.
static
<K,V> void
MapUtils.populateMap(Map<K,V> map, Iterable<? extends V> elements, Transformer<V,K> keyTransformer)
          Populates a Map using the supplied Transformer to transform the elements into keys, using the unaltered element as the value in the Map.
static
<K,V,E> void
MapUtils.populateMap(MultiMap<K,V> map, Iterable<? extends E> elements, Transformer<E,K> keyTransformer, Transformer<E,V> valueTransformer)
          Populates a MultiMap using the supplied Transformers to transform the elements into keys and values.
static
<K,V,E> void
MapUtils.populateMap(MultiMap<K,V> map, Iterable<? extends E> elements, Transformer<E,K> keyTransformer, Transformer<E,V> valueTransformer)
          Populates a MultiMap using the supplied Transformers to transform the elements into keys and values.
static
<K,V> void
MapUtils.populateMap(MultiMap<K,V> map, Iterable<? extends V> elements, Transformer<V,K> keyTransformer)
          Populates a MultiMap using the supplied Transformer to transform the elements into keys, using the unaltered element as the value in the MultiMap.
static
<I,O> Transformer<I,O>
TransformerUtils.switchTransformer(Predicate<? super I>[] predicates, Transformer<? super I,? extends O>[] transformers)
          Create a new Transformer that calls one of the transformers depending on the predicates.
static
<I,O> Transformer<I,O>
TransformerUtils.switchTransformer(Predicate<? super I>[] predicates, Transformer<? super I,? extends O>[] transformers, Transformer<? super I,? extends O> defaultTransformer)
          Create a new Transformer that calls one of the transformers depending on the predicates.
static
<I,O> Transformer<I,O>
TransformerUtils.switchTransformer(Predicate<? super I>[] predicates, Transformer<? super I,? extends O>[] transformers, Transformer<? super I,? extends O> defaultTransformer)
          Create a new Transformer that calls one of the transformers depending on the predicates.
static
<I,O> Transformer<I,O>
TransformerUtils.switchTransformer(Predicate<? super I> predicate, Transformer<? super I,? extends O> trueTransformer, Transformer<? super I,? extends O> falseTransformer)
          Create a new Transformer that calls one of two transformers depending on the specified predicate.
static
<I,O> Transformer<I,O>
TransformerUtils.switchTransformer(Predicate<? super I> predicate, Transformer<? super I,? extends O> trueTransformer, Transformer<? super I,? extends O> falseTransformer)
          Create a new Transformer that calls one of two transformers depending on the specified predicate.
static
<C> void
CollectionUtils.transform(Collection<C> collection, Transformer<? super C,? extends C> transformer)
          Transform the collection by applying a Transformer to each element.
static
<I,O> Comparator<I>
ComparatorUtils.transformedComparator(Comparator<O> comparator, Transformer<? super I,? extends O> transformer)
          Gets a Comparator that passes transformed objects to the given comparator.
static
<I,O> Iterator<O>
IteratorUtils.transformedIterator(Iterator<? extends I> iterator, Transformer<? super I,? extends O> transform)
          Gets an iterator that transforms the elements of another iterator.
static
<E> List<E>
ListUtils.transformedList(List<E> list, Transformer<? super E,? extends E> transformer)
          Returns a transformed list backed by the given list.
static
<K,V> IterableMap<K,V>
MapUtils.transformedMap(Map<K,V> map, Transformer<? super K,? extends K> keyTransformer, Transformer<? super V,? extends V> valueTransformer)
          Returns a transformed map backed by the given map.
static
<K,V> IterableMap<K,V>
MapUtils.transformedMap(Map<K,V> map, Transformer<? super K,? extends K> keyTransformer, Transformer<? super V,? extends V> valueTransformer)
          Returns a transformed map backed by the given map.
static
<T> Predicate<T>
PredicateUtils.transformedPredicate(Transformer<? super T,? extends T> transformer, Predicate<? super T> predicate)
          Creates a predicate that transforms the input object before passing it to the predicate.
static
<E> Set<E>
SetUtils.transformedSet(Set<E> set, Transformer<? super E,? extends E> transformer)
          Returns a transformed set backed by the given set.
static
<K,V> SortedMap<K,V>
MapUtils.transformedSortedMap(SortedMap<K,V> map, Transformer<? super K,? extends K> keyTransformer, Transformer<? super V,? extends V> valueTransformer)
          Returns a transformed sorted map backed by the given map.
static
<K,V> SortedMap<K,V>
MapUtils.transformedSortedMap(SortedMap<K,V> map, Transformer<? super K,? extends K> keyTransformer, Transformer<? super V,? extends V> valueTransformer)
          Returns a transformed sorted map backed by the given map.
static
<E> SortedSet<E>
SetUtils.transformedSortedSet(SortedSet<E> set, Transformer<? super E,? extends E> transformer)
          Returns a transformed sorted set backed by the given set.
static
<E> Bag<E>
BagUtils.transformingBag(Bag<E> bag, Transformer<? super E,? extends E> transformer)
          Returns a transformed bag backed by the given bag.
static
<E> Collection<E>
CollectionUtils.transformingCollection(Collection<E> collection, Transformer<? super E,? extends E> transformer)
          Returns a transformed bag backed by the given collection.
static
<E> Queue<E>
QueueUtils.transformingQueue(Queue<E> queue, Transformer<? super E,? extends E> transformer)
          Returns a transformed queue backed by the given queue.
static
<E> SortedBag<E>
BagUtils.transformingSortedBag(SortedBag<E> bag, Transformer<? super E,? extends E> transformer)
          Returns a transformed sorted bag backed by the given bag.
 

Method parameters in org.apache.commons.collections4 with type arguments of type Transformer
static
<T> Transformer<T,T>
TransformerUtils.chainedTransformer(Collection<? extends Transformer<T,T>> transformers)
          Create a new Transformer that calls each transformer in turn, passing the result into the next transformer.
static
<I,O> Transformer<I,O>
TransformerUtils.switchMapTransformer(Map<I,Transformer<I,O>> objectsAndTransformers)
          Create a new Transformer that uses the input object as a key to find the transformer to call.
static
<I,O> Transformer<I,O>
TransformerUtils.switchTransformer(Map<Predicate<I>,Transformer<I,O>> predicatesAndTransformers)
          Create a new Transformer that calls one of the transformers depending on the predicates.
 

Uses of Transformer in org.apache.commons.collections4.bag
 

Methods in org.apache.commons.collections4.bag with parameters of type Transformer
static
<E> Bag<E>
TransformedBag.transformedBag(Bag<E> bag, Transformer<? super E,? extends E> transformer)
          Factory method to create a transforming bag that will transform existing contents of the specified bag.
static
<E> TransformedSortedBag<E>
TransformedSortedBag.transformedSortedBag(SortedBag<E> bag, Transformer<? super E,? extends E> transformer)
          Factory method to create a transforming sorted bag that will transform existing contents of the specified sorted bag.
static
<E> Bag<E>
TransformedBag.transformingBag(Bag<E> bag, Transformer<? super E,? extends E> transformer)
          Factory method to create a transforming bag.
static
<E> TransformedSortedBag<E>
TransformedSortedBag.transformingSortedBag(SortedBag<E> bag, Transformer<? super E,? extends E> transformer)
          Factory method to create a transforming sorted bag.
 

Constructors in org.apache.commons.collections4.bag with parameters of type Transformer
TransformedBag(Bag<E> bag, Transformer<? super E,? extends E> transformer)
          Constructor that wraps (not copies).
TransformedSortedBag(SortedBag<E> bag, Transformer<? super E,? extends E> transformer)
          Constructor that wraps (not copies).
 

Uses of Transformer in org.apache.commons.collections4.collection
 

Fields in org.apache.commons.collections4.collection declared as Transformer
protected  Transformer<? super E,? extends E> TransformedCollection.transformer
          The transformer to use
 

Methods in org.apache.commons.collections4.collection with parameters of type Transformer
static
<K,C> IndexedCollection<K,C>
IndexedCollection.nonUniqueIndexedCollection(Collection<C> coll, Transformer<C,K> keyTransformer)
          Create an IndexedCollection for a non-unique index.
static
<E> TransformedCollection<E>
TransformedCollection.transformedCollection(Collection<E> collection, Transformer<? super E,? extends E> transformer)
          Factory method to create a transforming collection that will transform existing contents of the specified collection.
static
<E> TransformedCollection<E>
TransformedCollection.transformingCollection(Collection<E> coll, Transformer<? super E,? extends E> transformer)
          Factory method to create a transforming collection.
static
<K,C> IndexedCollection<K,C>
IndexedCollection.uniqueIndexedCollection(Collection<C> coll, Transformer<C,K> keyTransformer)
          Create an IndexedCollection for a unique index.
 

Constructors in org.apache.commons.collections4.collection with parameters of type Transformer
IndexedCollection(Collection<C> coll, Transformer<C,K> keyTransformer, MultiMap<K,C> map, boolean uniqueIndex)
          Create a IndexedCollection.
TransformedCollection(Collection<E> coll, Transformer<? super E,? extends E> transformer)
          Constructor that wraps (not copies).
 

Uses of Transformer in org.apache.commons.collections4.comparators
 

Constructors in org.apache.commons.collections4.comparators with parameters of type Transformer
TransformingComparator(Transformer<? super I,? extends O> transformer)
          Constructs an instance with the given Transformer and a ComparableComparator.
TransformingComparator(Transformer<? super I,? extends O> transformer, Comparator<O> decorated)
          Constructs an instance with the given Transformer and Comparator.
 

Uses of Transformer in org.apache.commons.collections4.functors
 

Classes in org.apache.commons.collections4.functors that implement Transformer
 class ChainedTransformer<T>
          Transformer implementation that chains the specified transformers together.
 class CloneTransformer<T>
          Transformer implementation that returns a clone of the input object.
 class ClosureTransformer<T>
          Transformer implementation that calls a Closure using the input object and then returns the input.
 class ConstantTransformer<I,O>
          Transformer implementation that returns the same constant each time.
 class ExceptionTransformer<I,O>
          Transformer implementation that always throws an exception.
 class FactoryTransformer<I,O>
          Transformer implementation that calls a Factory and returns the result.
 class InstantiateTransformer<T>
          Transformer implementation that creates a new object instance by reflection.
 class InvokerTransformer<I,O>
          Transformer implementation that creates a new object instance by reflection.
 class MapTransformer<I,O>
          Transformer implementation that returns the value held in a specified map using the input parameter as a key.
 class NOPTransformer<T>
          Transformer implementation that does nothing.
 class PredicateTransformer<T>
          Transformer implementation that calls a Predicate using the input object and then returns the result.
 class StringValueTransformer<T>
          Transformer implementation that returns the result of calling String.valueOf on the input object.
 class SwitchTransformer<I,O>
          Transformer implementation calls the transformer whose predicate returns true, like a switch statement.
 

Fields in org.apache.commons.collections4.functors declared as Transformer
static Transformer<Object,String> StringValueTransformer.INSTANCE
          Singleton predicate instance
static Transformer<Object,Object> ExceptionTransformer.INSTANCE
          Singleton predicate instance
static Transformer<Object,Object> NOPTransformer.INSTANCE
          Singleton predicate instance
static Transformer<Object,Object> CloneTransformer.INSTANCE
          Singleton predicate instance
static Transformer<Class<?>,?> InstantiateTransformer.NO_ARG_INSTANCE
          Singleton instance that uses the no arg constructor
static Transformer<Object,Object> ConstantTransformer.NULL_INSTANCE
          Returns null each time
 

Methods in org.apache.commons.collections4.functors that return Transformer
static
<T> Transformer<T,T>
ChainedTransformer.chainedTransformer(Collection<? extends Transformer<T,T>> transformers)
          Create a new Transformer that calls each transformer in turn, passing the result into the next transformer.
static
<T> Transformer<T,T>
ChainedTransformer.chainedTransformer(Transformer<? super T,? extends T>... transformers)
          Factory method that performs validation and copies the parameter array.
static
<T> Transformer<T,T>
CloneTransformer.cloneTransformer()
          Factory returning the singleton instance.
static
<T> Transformer<T,T>
ClosureTransformer.closureTransformer(Closure<? super T> closure)
          Factory method that performs validation.
static
<I,O> Transformer<I,O>
ConstantTransformer.constantTransformer(O constantToReturn)
          Transformer method that performs validation.
static
<I,O> Transformer<I,O>
ExceptionTransformer.exceptionTransformer()
          Factory returning the singleton instance.
static
<I,O> Transformer<I,O>
FactoryTransformer.factoryTransformer(Factory<? extends O> factory)
          Factory method that performs validation.
 Transformer<? super I,? extends O> SwitchTransformer.getDefaultTransformer()
          Gets the default transformer.
 Transformer<? super T,? extends T> TransformedPredicate.getTransformer()
          Gets the transformer in use.
 Transformer<? super T,Boolean> TransformerPredicate.getTransformer()
          Gets the transformer.
 Transformer<? super E,?> TransformerClosure.getTransformer()
          Gets the transformer.
 Transformer<? super I,? extends O>[] SwitchTransformer.getTransformers()
          Gets the transformers.
 Transformer<? super T,? extends T>[] ChainedTransformer.getTransformers()
          Gets the transformers.
static
<T> Transformer<Class<? extends T>,T>
InstantiateTransformer.instantiateTransformer()
          Get a typed no-arg instance.
static
<T> Transformer<Class<? extends T>,T>
InstantiateTransformer.instantiateTransformer(Class<?>[] paramTypes, Object[] args)
          Transformer method that performs validation.
static
<I,O> Transformer<I,O>
InvokerTransformer.invokerTransformer(String methodName)
          Gets an instance of this transformer calling a specific method with no arguments.
static
<I,O> Transformer<I,O>
InvokerTransformer.invokerTransformer(String methodName, Class<?>[] paramTypes, Object[] args)
          Gets an instance of this transformer calling a specific method with specific values.
static
<I,O> Transformer<I,O>
MapTransformer.mapTransformer(Map<? super I,? extends O> map)
          Factory to create the transformer.
static
<T> Transformer<T,T>
NOPTransformer.nopTransformer()
          Factory returning the singleton instance.
static
<I,O> Transformer<I,O>
ConstantTransformer.nullTransformer()
          Get a typed null instance.
static
<T> Transformer<T,Boolean>
PredicateTransformer.predicateTransformer(Predicate<? super T> predicate)
          Factory method that performs validation.
static
<T> Transformer<T,String>
StringValueTransformer.stringValueTransformer()
          Factory returning the singleton instance.
static
<I,O> Transformer<I,O>
SwitchTransformer.switchTransformer(Map<? extends Predicate<? super I>,? extends Transformer<? super I,? extends O>> map)
          Create a new Transformer that calls one of the transformers depending on the predicates.
static
<I,O> Transformer<I,O>
SwitchTransformer.switchTransformer(Predicate<? super I>[] predicates, Transformer<? super I,? extends O>[] transformers, Transformer<? super I,? extends O> defaultTransformer)
          Factory method that performs validation and copies the parameter arrays.
 

Methods in org.apache.commons.collections4.functors with parameters of type Transformer
static
<T> Transformer<T,T>
ChainedTransformer.chainedTransformer(Transformer<? super T,? extends T>... transformers)
          Factory method that performs validation and copies the parameter array.
static
<I,O> Transformer<I,O>
SwitchTransformer.switchTransformer(Predicate<? super I>[] predicates, Transformer<? super I,? extends O>[] transformers, Transformer<? super I,? extends O> defaultTransformer)
          Factory method that performs validation and copies the parameter arrays.
static
<I,O> Transformer<I,O>
SwitchTransformer.switchTransformer(Predicate<? super I>[] predicates, Transformer<? super I,? extends O>[] transformers, Transformer<? super I,? extends O> defaultTransformer)
          Factory method that performs validation and copies the parameter arrays.
static
<T> Predicate<T>
TransformedPredicate.transformedPredicate(Transformer<? super T,? extends T> transformer, Predicate<? super T> predicate)
          Factory to create the predicate.
static
<E> Closure<E>
TransformerClosure.transformerClosure(Transformer<? super E,?> transformer)
          Factory method that performs validation.
static
<T> Predicate<T>
TransformerPredicate.transformerPredicate(Transformer<? super T,Boolean> transformer)
          Factory to create the predicate.
 

Method parameters in org.apache.commons.collections4.functors with type arguments of type Transformer
static
<T> Transformer<T,T>
ChainedTransformer.chainedTransformer(Collection<? extends Transformer<T,T>> transformers)
          Create a new Transformer that calls each transformer in turn, passing the result into the next transformer.
static
<I,O> Transformer<I,O>
SwitchTransformer.switchTransformer(Map<? extends Predicate<? super I>,? extends Transformer<? super I,? extends O>> map)
          Create a new Transformer that calls one of the transformers depending on the predicates.
 

Constructors in org.apache.commons.collections4.functors with parameters of type Transformer
ChainedTransformer(Transformer<? super T,? extends T>... transformers)
          Constructor that performs no validation.
SwitchTransformer(Predicate<? super I>[] predicates, Transformer<? super I,? extends O>[] transformers, Transformer<? super I,? extends O> defaultTransformer)
          Constructor that performs no validation.
SwitchTransformer(Predicate<? super I>[] predicates, Transformer<? super I,? extends O>[] transformers, Transformer<? super I,? extends O> defaultTransformer)
          Constructor that performs no validation.
TransformedPredicate(Transformer<? super T,? extends T> transformer, Predicate<? super T> predicate)
          Constructor that performs no validation.
TransformerClosure(Transformer<? super E,?> transformer)
          Constructor that performs no validation.
TransformerPredicate(Transformer<? super T,Boolean> transformer)
          Constructor that performs no validation.
 

Uses of Transformer in org.apache.commons.collections4.iterators
 

Methods in org.apache.commons.collections4.iterators that return Transformer
 Transformer<? super I,? extends O> TransformIterator.getTransformer()
          Gets the transformer this iterator is using.
 

Methods in org.apache.commons.collections4.iterators with parameters of type Transformer
 void TransformIterator.setTransformer(Transformer<? super I,? extends O> transformer)
          Sets the transformer this the iterator to use.
 

Constructors in org.apache.commons.collections4.iterators with parameters of type Transformer
ObjectGraphIterator(E root, Transformer<? super E,? extends E> transformer)
          Constructs an ObjectGraphIterator using a root object and transformer.
TransformIterator(Iterator<? extends I> iterator, Transformer<? super I,? extends O> transformer)
          Constructs a new TransformIterator that will use the given iterator and transformer.
 

Uses of Transformer in org.apache.commons.collections4.list
 

Methods in org.apache.commons.collections4.list with parameters of type Transformer
static
<E> TransformedList<E>
TransformedList.transformedList(List<E> list, Transformer<? super E,? extends E> transformer)
          Factory method to create a transforming list that will transform existing contents of the specified list.
static
<E> TransformedList<E>
TransformedList.transformingList(List<E> list, Transformer<? super E,? extends E> transformer)
          Factory method to create a transforming list.
 

Constructors in org.apache.commons.collections4.list with parameters of type Transformer
TransformedList(List<E> list, Transformer<? super E,? extends E> transformer)
          Constructor that wraps (not copies).
 

Uses of Transformer in org.apache.commons.collections4.map
 

Fields in org.apache.commons.collections4.map declared as Transformer
protected  Transformer<? super K,? extends V> LazyMap.factory
          The factory to use to construct elements
protected  Transformer<? super K,? extends K> TransformedMap.keyTransformer
          The transformer to use for the key
protected  Transformer<? super V,? extends V> TransformedMap.valueTransformer
          The transformer to use for the value
 

Methods in org.apache.commons.collections4.map with parameters of type Transformer
static
<K,V> Map<K,V>
DefaultedMap.defaultedMap(Map<K,V> map, Transformer<? super K,? extends V> transformer)
          Factory method to create a defaulting map.
static
<V,K> LazyMap<K,V>
LazyMap.lazyMap(Map<K,V> map, Transformer<? super K,? extends V> factory)
          Factory method to create a lazily instantiated map.
static
<K,V> LazySortedMap<K,V>
LazySortedMap.lazySortedMap(SortedMap<K,V> map, Transformer<? super K,? extends V> factory)
          Factory method to create a lazily instantiated sorted map.
static
<K,V> TransformedMap<K,V>
TransformedMap.transformedMap(Map<K,V> map, Transformer<? super K,? extends K> keyTransformer, Transformer<? super V,? extends V> valueTransformer)
          Factory method to create a transforming map that will transform existing contents of the specified map.
static
<K,V> TransformedMap<K,V>
TransformedMap.transformedMap(Map<K,V> map, Transformer<? super K,? extends K> keyTransformer, Transformer<? super V,? extends V> valueTransformer)
          Factory method to create a transforming map that will transform existing contents of the specified map.
static
<K,V> TransformedSortedMap<K,V>
TransformedSortedMap.transformedSortedMap(SortedMap<K,V> map, Transformer<? super K,? extends K> keyTransformer, Transformer<? super V,? extends V> valueTransformer)
          Factory method to create a transforming sorted map that will transform existing contents of the specified map.
static
<K,V> TransformedSortedMap<K,V>
TransformedSortedMap.transformedSortedMap(SortedMap<K,V> map, Transformer<? super K,? extends K> keyTransformer, Transformer<? super V,? extends V> valueTransformer)
          Factory method to create a transforming sorted map that will transform existing contents of the specified map.
static
<K,V> TransformedMap<K,V>
TransformedMap.transformingMap(Map<K,V> map, Transformer<? super K,? extends K> keyTransformer, Transformer<? super V,? extends V> valueTransformer)
          Factory method to create a transforming map.
static
<K,V> TransformedMap<K,V>
TransformedMap.transformingMap(Map<K,V> map, Transformer<? super K,? extends K> keyTransformer, Transformer<? super V,? extends V> valueTransformer)
          Factory method to create a transforming map.
static
<K,V> TransformedSortedMap<K,V>
TransformedSortedMap.transformingSortedMap(SortedMap<K,V> map, Transformer<? super K,? extends K> keyTransformer, Transformer<? super V,? extends V> valueTransformer)
          Factory method to create a transforming sorted map.
static
<K,V> TransformedSortedMap<K,V>
TransformedSortedMap.transformingSortedMap(SortedMap<K,V> map, Transformer<? super K,? extends K> keyTransformer, Transformer<? super V,? extends V> valueTransformer)
          Factory method to create a transforming sorted map.
 

Constructors in org.apache.commons.collections4.map with parameters of type Transformer
DefaultedMap(Map<K,V> map, Transformer<? super K,? extends V> defaultValueTransformer)
          Constructor that wraps (not copies).
DefaultedMap(Transformer<? super K,? extends V> defaultValueTransformer)
          Constructs a new empty DefaultedMap that decorates a HashMap.
LazyMap(Map<K,V> map, Transformer<? super K,? extends V> factory)
          Constructor that wraps (not copies).
LazySortedMap(SortedMap<K,V> map, Transformer<? super K,? extends V> factory)
          Constructor that wraps (not copies).
TransformedMap(Map<K,V> map, Transformer<? super K,? extends K> keyTransformer, Transformer<? super V,? extends V> valueTransformer)
          Constructor that wraps (not copies).
TransformedMap(Map<K,V> map, Transformer<? super K,? extends K> keyTransformer, Transformer<? super V,? extends V> valueTransformer)
          Constructor that wraps (not copies).
TransformedSortedMap(SortedMap<K,V> map, Transformer<? super K,? extends K> keyTransformer, Transformer<? super V,? extends V> valueTransformer)
          Constructor that wraps (not copies).
TransformedSortedMap(SortedMap<K,V> map, Transformer<? super K,? extends K> keyTransformer, Transformer<? super V,? extends V> valueTransformer)
          Constructor that wraps (not copies).
 

Uses of Transformer in org.apache.commons.collections4.queue
 

Methods in org.apache.commons.collections4.queue with parameters of type Transformer
static
<E> TransformedQueue<E>
TransformedQueue.transformedQueue(Queue<E> queue, Transformer<? super E,? extends E> transformer)
          Factory method to create a transforming queue that will transform existing contents of the specified queue.
static
<E> TransformedQueue<E>
TransformedQueue.transformingQueue(Queue<E> queue, Transformer<? super E,? extends E> transformer)
          Factory method to create a transforming queue.
 

Constructors in org.apache.commons.collections4.queue with parameters of type Transformer
TransformedQueue(Queue<E> queue, Transformer<? super E,? extends E> transformer)
          Constructor that wraps (not copies).
 

Uses of Transformer in org.apache.commons.collections4.set
 

Methods in org.apache.commons.collections4.set with parameters of type Transformer
static
<E> Set<E>
TransformedSet.transformedSet(Set<E> set, Transformer<? super E,? extends E> transformer)
          Factory method to create a transforming set that will transform existing contents of the specified set.
static
<E> TransformedSortedSet<E>
TransformedSortedSet.transformedSortedSet(SortedSet<E> set, Transformer<? super E,? extends E> transformer)
          Factory method to create a transforming sorted set that will transform existing contents of the specified sorted set.
static
<E> TransformedSet<E>
TransformedSet.transformingSet(Set<E> set, Transformer<? super E,? extends E> transformer)
          Factory method to create a transforming set.
static
<E> TransformedSortedSet<E>
TransformedSortedSet.transformingSortedSet(SortedSet<E> set, Transformer<? super E,? extends E> transformer)
          Factory method to create a transforming sorted set.
 

Constructors in org.apache.commons.collections4.set with parameters of type Transformer
TransformedSet(Set<E> set, Transformer<? super E,? extends E> transformer)
          Constructor that wraps (not copies).
TransformedSortedSet(SortedSet<E> set, Transformer<? super E,? extends E> transformer)
          Constructor that wraps (not copies).
 

Uses of Transformer in org.apache.commons.collections4.splitmap
 

Methods in org.apache.commons.collections4.splitmap with parameters of type Transformer
static
<J,K,U,V> TransformedSplitMap<J,K,U,V>
TransformedSplitMap.transformingMap(Map<K,V> map, Transformer<? super J,? extends K> keyTransformer, Transformer<? super U,? extends V> valueTransformer)
          Factory method to create a transforming map.
static
<J,K,U,V> TransformedSplitMap<J,K,U,V>
TransformedSplitMap.transformingMap(Map<K,V> map, Transformer<? super J,? extends K> keyTransformer, Transformer<? super U,? extends V> valueTransformer)
          Factory method to create a transforming map.
 

Constructors in org.apache.commons.collections4.splitmap with parameters of type Transformer
TransformedSplitMap(Map<K,V> map, Transformer<? super J,? extends K> keyTransformer, Transformer<? super U,? extends V> valueTransformer)
          Constructor that wraps (not copies).
TransformedSplitMap(Map<K,V> map, Transformer<? super J,? extends K> keyTransformer, Transformer<? super U,? extends V> valueTransformer)
          Constructor that wraps (not copies).
 



Copyright © 2001–2013 The Apache Software Foundation. All rights reserved.