Module com.github.underscore

Package com.github.underscore

Class U.Chain<T>

java.lang.Object

com.github.underscore.U.Chain<T>

Direct Known Subclasses:

U.Chain

Enclosing class:

U<T>

public static class U.Chain<T>
extends Object

Constructor Summary

Constructors

Constructor	Description
Chain(List<T> list)
Chain(Map<String,Object> map)
Chain(T item)

Method Summary

Modifier and Type	Method	Description
U.Chain<List<T>>	chunk(int size)
U.Chain<List<T>>	chunk(int size, int step)
U.Chain<List<T>>	chunkFill(int size, int step, T fillValue)
U.Chain<List<T>>	chunkFill(int size, T fillValue)
U.Chain<T>	compact()
U.Chain<T>	compact(T falsyValue)
U.Chain<T>	concat(List<T>... lists)
U.Chain<Boolean>	contains(T elem)
U.Chain<Boolean>	containsWith(T elem)
U.Chain<Integer>	count(Predicate<T> pred)
U.Chain<Map<T,Integer>>	countBy()
<F> U.Chain<Map<F,Integer>>	countBy(Function<T,F> func)
U.Chain<T>	cycle(int times)
U.Chain<T>	difference(List<T>... lists)
U.Chain<T>	distinct()
<F> U.Chain<F>	distinctBy(Function<T,F> func)
U.Chain<Boolean>	every(Predicate<T> pred)
U.Chain<T>	filter(Predicate<T> pred)
U.Chain<T>	filterFalse(Predicate<T> pred)
U.Chain<T>	filterIndexed(PredicateIndexed<T> pred)
U.Chain<Optional<T>>	find(Predicate<T> pred)
U.Chain<Optional<T>>	findLast(Predicate<T> pred)
<E> U.Chain<Optional<T>>	findWhere(List<Tuple<String,E>> properties)
U.Chain<T>	first()
U.Chain<T>	first(int n)
U.Chain<T>	first(Predicate<T> pred)
U.Chain<T>	first(Predicate<T> pred, int n)
U.Chain<T>	firstOrNull()
U.Chain<T>	firstOrNull(Predicate<T> pred)
U.Chain	flatten()
U.Chain<T>	forEach(Consumer<T> func)
U.Chain<T>	forEachRight(Consumer<T> func)
<F> U.Chain<Map<F,List<T>>>	groupBy(Function<T,F> func)
<F> U.Chain<Map<F,Optional<T>>>	groupBy(Function<T,F> func, BinaryOperator<T> binaryOperator)
U.Chain<Map<Object,List<T>>>	indexBy(String property)
U.Chain<T>	initial()
U.Chain<T>	initial(int n)
U.Chain<T>	interpose(T element)
U.Chain<T>	interposeByList(Iterable<T> interIter)
U.Chain<T>	intersection(List<T>... lists)
U.Chain<T>	invoke(String methodName)
U.Chain<T>	invoke(String methodName, List<Object> args)
boolean	isEmpty()
boolean	isNotEmpty()
T	item()
U.Chain<String>	join()
U.Chain<String>	join(String separator)
U.Chain<T>	last()
U.Chain<T>	last(int n)
U.Chain<T>	lastOrNull()
U.Chain<T>	lastOrNull(Predicate<T> pred)
U.Chain<T>	limit(int size)
Map<String,Object>	map()
<F> U.Chain<F>	map(Function<? super T,F> func)
<F> U.Chain<F>	mapIndexed(BiFunction<Integer,? super T,F> func)
<F> U.Chain<F>	mapMulti(BiConsumer<? super T,? super Consumer<F>> mapper)
U.Chain<Comparable>	max()
<F extends Comparable<? super F>> U.Chain<T>	max(Function<T,F> func)
U.Chain<Comparable>	min()
<F extends Comparable<? super F>> U.Chain<T>	min(Function<T,F> func)
U.Chain<Object>	pluck(String propertyName)
U.Chain<Tuple<T,List<T>>>	pop()
U.Chain<T>	push(T... values)
U.Chain<Integer>	range(int stop)
U.Chain<Integer>	range(int start, int stop)
U.Chain<Integer>	range(int start, int stop, int step)
<F> U.Chain<F>	reduce(BiFunction<F,T,F> func, F zeroElem)
U.Chain<Optional<T>>	reduce(BinaryOperator<T> func)
<F> U.Chain<F>	reduceRight(BiFunction<F,T,F> func, F zeroElem)
U.Chain<Optional<T>>	reduceRight(BinaryOperator<T> func)
U.Chain<T>	reject(Predicate<T> pred)
U.Chain<T>	rejectIndexed(PredicateIndexed<T> pred)
U.Chain<T>	replace(Predicate<T> pred, T value)
U.Chain<T>	replaceIndexed(PredicateIndexed<T> pred, T value)
U.Chain<T>	rest()
U.Chain<T>	rest(int n)
U.Chain<T>	reverse()
U.Chain<T>	sample()
U.Chain<T>	sample(int howMany)
U.Chain<Tuple<T,List<T>>>	shift()
U.Chain<T>	shuffle()
int	size()
U.Chain<T>	skip(int numberToSkip)
U.Chain<T>	slice(int start)
U.Chain<T>	slice(int start, int end)
U.Chain<Boolean>	some(Predicate<T> pred)
U.Chain<Comparable>	sort()
<F extends Comparable<? super F>> U.Chain<T>	sortBy(Function<T,F> func)
<K> U.Chain<Map<K,Comparable>>	sortBy(K key)
<F extends Comparable<? super F>> U.Chain<F>	sortWith(Comparator<F> comparator)
U.Chain<List<T>>	splitAt(int position)
U.Chain<T>	takeSkipping(int stepSize)
U.Chain<T>	tap(Consumer<T> func)
List<T>	toList()
<K,V> U.Chain<Map<K,V>>	toMap()
String	toString()
U.Chain<T>	union(List<T>... lists)
U.Chain<T>	uniq()
<F> U.Chain<T>	uniq(Function<T,F> func)
U.Chain<T>	unshift(T... values)
List<T>	value()
<E> U.Chain<T>	where(List<Tuple<String,E>> properties)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

Chain

public Chain(T item)

Chain

public Chain(List<T> list)

Chain

public Chain(Map<String,Object> map)

Method Detail

first

public U.Chain<T> first()

first

public U.Chain<T> first(int n)

first

public U.Chain<T> first(Predicate<T> pred)

first

public U.Chain<T> first(Predicate<T> pred,
                        int n)

firstOrNull

public U.Chain<T> firstOrNull()

firstOrNull

public U.Chain<T> firstOrNull(Predicate<T> pred)

initial

public U.Chain<T> initial()

initial

public U.Chain<T> initial(int n)

last

public U.Chain<T> last()

last

public U.Chain<T> last(int n)

lastOrNull

public U.Chain<T> lastOrNull()

lastOrNull

public U.Chain<T> lastOrNull(Predicate<T> pred)

rest

public U.Chain<T> rest()

rest

public U.Chain<T> rest(int n)

compact

public U.Chain<T> compact()

compact

public U.Chain<T> compact(T falsyValue)

flatten

public U.Chain flatten()

map

public <F> U.Chain<F> map(Function<? super T,F> func)

mapMulti

public <F> U.Chain<F> mapMulti(BiConsumer<? super T,? super Consumer<F>> mapper)

mapIndexed

public <F> U.Chain<F> mapIndexed(BiFunction<Integer,? super T,F> func)

replace

public U.Chain<T> replace(Predicate<T> pred,
                          T value)

replaceIndexed

public U.Chain<T> replaceIndexed(PredicateIndexed<T> pred,
                                 T value)

filter

public U.Chain<T> filter(Predicate<T> pred)

filterIndexed

public U.Chain<T> filterIndexed(PredicateIndexed<T> pred)

reject

public U.Chain<T> reject(Predicate<T> pred)

rejectIndexed

public U.Chain<T> rejectIndexed(PredicateIndexed<T> pred)

filterFalse

public U.Chain<T> filterFalse(Predicate<T> pred)

reduce

public <F> U.Chain<F> reduce(BiFunction<F,T,F> func,
                             F zeroElem)

reduce

public U.Chain<Optional<T>> reduce(BinaryOperator<T> func)

reduceRight

public <F> U.Chain<F> reduceRight(BiFunction<F,T,F> func,
                                  F zeroElem)

reduceRight

public U.Chain<Optional<T>> reduceRight(BinaryOperator<T> func)

find

public U.Chain<Optional<T>> find(Predicate<T> pred)

findLast

public U.Chain<Optional<T>> findLast(Predicate<T> pred)

max

public U.Chain<Comparable> max()

max

public <F extends Comparable<? super F>> U.Chain<T> max(Function<T,F> func)

min

public U.Chain<Comparable> min()

min

public <F extends Comparable<? super F>> U.Chain<T> min(Function<T,F> func)

sort

public U.Chain<Comparable> sort()

sortWith

public <F extends Comparable<? super F>> U.Chain<F> sortWith(Comparator<F> comparator)

sortBy

public <F extends Comparable<? super F>> U.Chain<T> sortBy(Function<T,F> func)

sortBy

public <K> U.Chain<Map<K,Comparable>> sortBy(K key)

groupBy

public <F> U.Chain<Map<F,List<T>>> groupBy(Function<T,F> func)

groupBy

public <F> U.Chain<Map<F,Optional<T>>> groupBy(Function<T,F> func,
                                                     BinaryOperator<T> binaryOperator)

indexBy

public U.Chain<Map<Object,List<T>>> indexBy(String property)

countBy

public <F> U.Chain<Map<F,Integer>> countBy(Function<T,F> func)

countBy

public U.Chain<Map<T,Integer>> countBy()

shuffle

public U.Chain<T> shuffle()

sample

public U.Chain<T> sample()

sample

public U.Chain<T> sample(int howMany)

tap

public U.Chain<T> tap(Consumer<T> func)

forEach

public U.Chain<T> forEach(Consumer<T> func)

forEachRight

public U.Chain<T> forEachRight(Consumer<T> func)

every

public U.Chain<Boolean> every(Predicate<T> pred)

some

public U.Chain<Boolean> some(Predicate<T> pred)

count

public U.Chain<Integer> count(Predicate<T> pred)

contains

public U.Chain<Boolean> contains(T elem)

containsWith

public U.Chain<Boolean> containsWith(T elem)

invoke

public U.Chain<T> invoke(String methodName,
                         List<Object> args)

invoke

public U.Chain<T> invoke(String methodName)

pluck

public U.Chain<Object> pluck(String propertyName)

where

public <E> U.Chain<T> where(List<Tuple<String,E>> properties)

findWhere

public <E> U.Chain<Optional<T>> findWhere(List<Tuple<String,E>> properties)

uniq

public U.Chain<T> uniq()

uniq

public <F> U.Chain<T> uniq(Function<T,F> func)

distinct

public U.Chain<T> distinct()

distinctBy

public <F> U.Chain<F> distinctBy(Function<T,F> func)

union

public U.Chain<T> union(List<T>... lists)

intersection

public U.Chain<T> intersection(List<T>... lists)

difference

public U.Chain<T> difference(List<T>... lists)

range

public U.Chain<Integer> range(int stop)

range

public U.Chain<Integer> range(int start,
                              int stop)

range

public U.Chain<Integer> range(int start,
                              int stop,
                              int step)

chunk

public U.Chain<List<T>> chunk(int size)

chunk

public U.Chain<List<T>> chunk(int size,
                              int step)

chunkFill

public U.Chain<List<T>> chunkFill(int size,
                                  T fillValue)

chunkFill

public U.Chain<List<T>> chunkFill(int size,
                                  int step,
                                  T fillValue)

cycle

public U.Chain<T> cycle(int times)

interpose

public U.Chain<T> interpose(T element)

interposeByList

public U.Chain<T> interposeByList(Iterable<T> interIter)

concat

public U.Chain<T> concat(List<T>... lists)

slice

public U.Chain<T> slice(int start)

slice

public U.Chain<T> slice(int start,
                        int end)

splitAt

public U.Chain<List<T>> splitAt(int position)

takeSkipping

public U.Chain<T> takeSkipping(int stepSize)

reverse

public U.Chain<T> reverse()

join

public U.Chain<String> join()

join

public U.Chain<String> join(String separator)

push

public U.Chain<T> push(T... values)

pop

public U.Chain<Tuple<T,List<T>>> pop()

shift

public U.Chain<Tuple<T,List<T>>> shift()

unshift

public U.Chain<T> unshift(T... values)

skip

public U.Chain<T> skip(int numberToSkip)

limit

public U.Chain<T> limit(int size)

toMap

public <K,V> U.Chain<Map<K,V>> toMap()

isEmpty

public boolean isEmpty()

isNotEmpty

public boolean isNotEmpty()

size

public int size()

item

public T item()

value

public List<T> value()

map

public Map<String,Object> map()

toList

public List<T> toList()

toString

public String toString()

Overrides:

toString in class Object