C (Java Tool 1.20.2 API)

java.lang.Object
- org.osgl.util.C

Direct Known Subclasses:

CollectionNS
```
public class C
extends Object
```
The namespace for OSGL collection utilities

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`C._CollectStage`
`static class`	`C._CollectStage2`
`static class`	`C._FilterStage<T>`
`static class`	`C._FilterStage2<T>`
`static class`	`C._MapStage<T>`
`static class`	`C._MapStage2<T,R>`
`static class`	`C.Array<T>`
`static class`	`C.F` the namespace of function definitions relevant to Collection manipulation
`static class`	`C.Feature` The character enum for a data structure
`static interface`	`C.Featured` Define a type that holds a set of `C.Feature`
`static interface`	`C.List<T>` The osgl List interface is a mixture of `List` and osgl `C.Sequence`
`static interface`	`C.ListFactory` Defines a factory to create `java List` instance used by `DelegatingList` to create it’s backing data structure
`static interface`	`C.ListOrSet<T>`
`static class`	`C.Map<K,V>`
`static class`	`C.Mutable`
`static interface`	`C.Range<ELEMENT>` Define a Range data structure which contains a discrete sequence of elements start from `C.Range.from()` until `C.Range.to()`.
`static interface`	`C.ReversibleSequence<T>` A bidirectional sequence which can be iterated from tail to head
`static interface`	`C.Sequence<T>`
`static interface`	`C.Set<T>`
`static interface`	`C.Traversable<T>` Define a traversable structure with functional programming support, including map, reduce etc.

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`CONF_LINKED_LIST_FACTORY` “osgl.list.factory”, the property key to configure user defined `list factory`.
`static String`	`CONF_RANDOM_ACCESS_LIST_FACTORY` “osgl.random_access_list.factory”, the property key to configure user defined `random access list factory`.
`static C.ListOrSet`	`EMPTY`
`static C.List`	`EMPTY_LIST`
`static C.Map`	`EMPTY_MAP`
`static C.Set`	`EMPTY_SET`

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static <T> Collection<T>`	`asCollection(Iterable<T> iterable)`
`static C._CollectStage`	`collect(Iterable source)`
`static <T> C.List<T>`	`collect(Iterable source, String propertyPath)`
`static C._CollectStage2`	`collect(String propertyPath)`
`static <T> C.List<T>`	`concat(C.List<T> l1, C.List<T> l2)` Concatenate two `List` into one.
`static <T> C.ReversibleSequence<T>`	`concat(C.ReversibleSequence<T> s1, C.ReversibleSequence<T> s2)` Concatenate two `C.ReversibleSequence` into one
`static <T> C.Sequence<T>`	`concat(C.Sequence<T> s1, C.Sequence<T> s2)` Concatenate two `C.Sequence` into one
`static <T> C.ListOrSet<T>`	`empty()`
`static boolean`	`empty(Collection<?> col)`
`static boolean`	`empty(Map map)`
`static <T> C.List<T>`	`emptyListOf(Class<T> c)`
`static <T> Iterable<T>`	`enumerable(Enumeration<T> e)` Convert a `Enumeration` to an `Iterable`
`static C.Range<Integer>`	`evenNumbers()` Returns a `C.Range` of non-negative even numbers starts from `0` to `Integer.MAX_VALUE`.
`static <PROPERTY> C.List<PROPERTY>`	`extract(Collection<?> collection, String propertyPath)` Alias of `collect(Iterable, String)`
`static <T> C._FilterStage<T>`	`filter(Iterable<? extends T> source)`
`static <T> C.Sequence<T>`	`filter(Iterable<? extends T> iterable, Lang.Function<? super T,Boolean> predicate)`
`static <T> C._FilterStage2<T>`	`filter(Lang.Predicate<? super T> predicate)`
`static <T> void`	`forEach(Iterable<? extends T> iterable, Lang.Visitor<? super T> visitor)` Run visitor function on each element supplied by the iterable.
`static <T> void`	`forEach(Iterator<? extends T> iterator, Lang.Visitor<? super T> visitor)` Run visitor function on each element supplied by the iterator.
`static <K,V> void`	`forEach(Map<K,V> map, Lang.IndexedVisitor<? super K,? super V> indexedVisitor)` Run indexedVisitor function on all key/value pair in a given map.
`static <T> C.Set<T>`	`intercectionOf(Collection<? extends T> col1, Collection<? extends T> col2)`
`static <T> C.Set<T>`	`interceptionOf(Collection<? extends T> col1, Collection<? extends T> col2, Collection<? extends T> col3, Collection<? extends T>... otherCols)`
`static boolean`	`isEmpty(Collection<?> col)`
`static boolean`	`isEmpty(Map map)`
`static boolean`	`isImmutable(C.Traversable<?> t)` Check if a `C.Traversable` structure is immutable.
`static boolean`	`isReadOnly(C.Traversable<?> t)` Check if a `C.Traversable` structure is read only.
`static <PROPERTY> C.Sequence<PROPERTY>`	`lazyExtract(Iterable<?> iterable, String propertyPath)`
`static <T> C.List<T>`	`list()` Returns an empty immutable list
`static C.List<Boolean>`	`list(boolean[] elements)` Create an immutable Boolean list of a byte (primitive type) array.
`static C.List<Byte>`	`list(byte[] elements)` Create an immutable Byte list of a byte (primitive type) array.
`static C.List<Character>`	`list(char[] elements)` Create an immutable Character list of a char array.
`static <T> C.List<T>`	`list(Collection<? extends T> col)`
`static C.List<Double>`	`list(double[] elements)` Create an immutable Byte list of a double array.
`static <T> C.List<T>`	`list(Enumeration<? extends T> enumeration)`
`static C.List<Float>`	`list(float[] elements)` Create an immutable byte list of a float array.
`static C.List<Integer>`	`list(int[] elements)` Create an immutable integer list of a int array.
`static <T> C.List<T>`	`list(Iterable<? extends T> iterable)`
`static <T> C.List<T>`	`list(Iterator<? extends T> iterator)`
`static <T> C.List<T>`	`list(List<? extends T> javaList)`
`static C.List<Long>`	`list(long[] elements)` Create an immutable Long list of a long array.
`static C.List<Short>`	`list(short[] elements)` Create an immutable Short list of a short array.
`static <T> C.List<T>`	`list(T t)`
`static <T> C.List<T>`	`list(T t, T... ta)` Creates an immutable list from an element plus an array of elements
`static C.List<Boolean>`	`listOf(boolean[] elements)` Create an immutable Boolean list from a boolean (primitive type) array.
`static C.List<Byte>`	`listOf(byte[] elements)` Create an immutable Byte list from a byte (primitive type) array.
`static C.List<Character>`	`listOf(char[] elements)` Create an immutable Short list from a char (primitive type) array.
`static C.List<Double>`	`listOf(double[] elements)` Create an immutable Double list from an double (primitive type) array.
`static C.List<Float>`	`listOf(float[] elements)` Create an immutable Float list from a float (primitive type) array.
`static C.List<Integer>`	`listOf(int[] elements)` Create an immutable Integer list from an int (primitive type) array.
`static C.List<Long>`	`listOf(long[] elements)` Create an immutable Long list from a long (primitive type) array.
`static C.List<Short>`	`listOf(short[] elements)` Create an immutable Short list from a short (primitive type) array.
`static <T> C.List<T>`	`listOf(T... ta)` Creates an immutable list of an array of elements.
`static <K,V> C.Map<K,V>`	`Map(boolean readOnly, Map<K,V> map)`
`static <T,R> C.ReversibleSequence<R>`	`map(C.ReversibleSequence<? extends T> seq, Lang.Function<? super T,? extends R> mapper)`
`static <K,V> C.Map<K,V>`	`Map(Collection<Lang.Tuple<K,V>> kvCol)`
`static <T> C._MapStage<T>`	`map(Iterable<? extends T> source)`
`static <T,R> C.Sequence<R>`	`map(Iterable<? extends T> seq, Lang.Function<? super T,? extends R> mapper)`
`static <T,R> C._MapStage2`	`map(Lang.Function<? super T,? extends R> mapper)`
`static <K,V> C.Map<K,V>`	`Map(Map<? extends K,? extends V> map)` Create an immutable `Map` from existing `Map`
`static <K,V> C.Map<K,V>`	`Map(Object... args)` Create a immutable `Map` from elements specified in an array.
`static C.Range<Integer>`	`naturalNumbers()` Returns a `C.Range` of non-negative integers start from `0` to `Integer.MAX_VALUE`.
`static <T> C.List<T>`	`newList()`
`static <T> C.List<T>`	`newList(Iterable<? extends T> iterable)`
`static <T> C.List<T>`	`newList(T t)`
`static <T> C.List<T>`	`newList(T t1, T t2)`
`static <T> C.List<T>`	`newList(T t1, T t2, T t3)`
`static <T> C.List<T>`	`newList(T t1, T t2, T t3, T... ta)`
`static <T> C.List<T>`	`newListOf(T[] ts)`
`static <K,V> C.Map<K,V>`	`newMap(Map<? extends K,? extends V> map)` Create an new `Map` from existing `Map`
`static <K,V> C.Map<K,V>`	`newMap(Object... args)` Create an new `Map` from an array of elements.
`static <T> C.Set<T>`	`newSet()` Create an new empty set
`static <T> C.Set<T>`	`newSet(Collection<? extends T> col)` Create an new set with all elements contained in the collection specified
`static <T> C.Set<T>`	`newSet(T t1, T... ta)` Create an mutable set contains specified elements
`static <T> C.List<T>`	`newSizedList(int size)`
`static boolean`	`notEmpty(Collection<?> col)`
`static boolean`	`notEmpty(Map map)`
`static C.Range<Integer>`	`oddNumbers()` Returns a `C.Range` of positive odd numbers starts from `1` to `Integer.MAX_VALUE`.
`static <T> C.Sequence<T>`	`prepend(T t, C.Sequence<T> sequence)`
`static C.Range<Byte>`	`range(byte from, byte to)` Returns a `C.Range` of byte specified by `from` and `to`.
`static C.Range<Integer>`	`range(int from, int to)` Returns a `C.Range` of integer specified by `from` and `to`.
`static C.Range<Long>`	`range(long from, long to)` Returns a `C.Range` of long specified by `from` and `to`.
`static C.Range<Short>`	`range(short from, short to)` Returns a `C.Range` of short specified by `from` and `to`.
`static <T> C.Sequence<T>`	`seq(Enumeration<? extends T> enumeration)`
`static <T> C.Sequence<T>`	`seq(Iterable<? extends T> iterable)` Return a `C.Sequence` consists of all elements in the iterable specified
`static <T> C.Sequence<T>`	`seq(Iterator<? extends T> iterator)`
`static <T> C.Set<T>`	`set()` Deprecated.
`static <T> C.Set<T>`	`Set()` Create an empty immutable set
`static <T> C.Set<T>`	`set(Collection<? extends T> col)` Deprecated.
`static <T> C.Set<T>`	`Set(Collection<? extends T> col)` Create an immutable set of all elements contained in the collection specified
`static <T> C.Set<T>`	`set(Iterable<? extends T> itr)` Create an immutable set of all elements supplied by the iterable specified
`static <T> C.Set<T>`	`set(T element)` Create an immutable set of a single element
`static <T> C.Set<T>`	`set(T t1, T... ta)` Create an immutable set contains specified elements
`static <T> C.Set<T>`	`setOf(T... ta)` Create an immutable set of an array of elements
`static <T> C.List<T>`	`singletonList(T t)`
`static <T> C.Set<T>`	`unionOf(Collection<? extends T> col1, Collection<? extends T> col2)`
`static <T> C.Set<T>`	`unionOf(Collection<? extends T> col1, Collection<? extends T> col2, Collection<? extends T> col3, Collection<? extends T>... otherCols)`
`static <T> C.List<T>`	`wrap(List<T> list)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - CONF_LINKED_LIST_FACTORY
```
public static final String CONF_LINKED_LIST_FACTORY
```
    “osgl.list.factory”, the property key to configure user defined list factory. Upon loaded, osgl tried to get a class name string from system properties use this configuration key. If osgl find the String returned is not empty then it will initialize the list factory use the class name configured. If any exception raised during the initialization, then it might cause the JVM failed to boot up
    
    Since:
    
    0.2
    
    See Also:
    
    Constant Field Values
  - CONF_RANDOM_ACCESS_LIST_FACTORY
```
public static final String CONF_RANDOM_ACCESS_LIST_FACTORY
```
    “osgl.random_access_list.factory”, the property key to configure user defined random access list factory. See CONF_LINKED_LIST_FACTORY for how osgl use this configuration
    
    Since:
    
    0.2
    
    See Also:
    
    Constant Field Values
  - EMPTY_LIST
```
public static final C.List EMPTY_LIST
```
  - EMPTY_SET
```
public static final C.Set EMPTY_SET
```
  - EMPTY_MAP
```
public static final C.Map EMPTY_MAP
```
  - EMPTY
```
public static final C.ListOrSet EMPTY
```
- Method Detail
  - empty
```
public static boolean empty(Collection<?> col)
```
  - notEmpty
```
public static boolean notEmpty(Collection<?> col)
```
  - isEmpty
```
public static boolean isEmpty(Collection<?> col)
```
  - empty
```
public static boolean empty(Map map)
```
  - notEmpty
```
public static boolean notEmpty(Map map)
```
  - isEmpty
```
public static boolean isEmpty(Map map)
```
  - asCollection
```
public static <T> Collection<T> asCollection(Iterable<T> iterable)
```
  - range
```
public static C.Range<Integer> range(int from,
                                     int to)
```
    Returns a C.Range of integer specified by from and to. from can be less or larger than to.
    
    Parameters:
    
    from - specify the left side of the range (inclusive)
    
    to - specify the right hand side of the range (exclusive)
    
    Returns:
    
    a range of integer @{code [from .. to)}
  - range
```
public static C.Range<Byte> range(byte from,
                                  byte to)
```
    Returns a C.Range of byte specified by from and to. from can be less or larger than to.
    
    Parameters:
    
    from - specify the left side of the range (inclusive)
    
    to - specify the right hand side of the range (exclusive)
    
    Returns:
    
    a range of byte @{code [from .. to)}
  - range
```
public static C.Range<Short> range(short from,
                                   short to)
```
    Returns a C.Range of short specified by from and to. from can be less or larger than to.
    
    Parameters:
    
    from - specify the left side of the range (inclusive)
    
    to - specify the right hand side of the range (exclusive)
    
    Returns:
    
    a range of short @{code [from .. to)}
  - range
```
public static C.Range<Long> range(long from,
                                  long to)
```
    Returns a C.Range of long specified by from and to. from can be less or larger than to.
    
    Parameters:
    
    from - specify the left side of the range (inclusive)
    
    to - specify the right hand side of the range (exclusive)
    
    Returns:
    
    a range of long @{code [from .. to)}
  - naturalNumbers
```
public static C.Range<Integer> naturalNumbers()
```
    Returns a C.Range of non-negative integers start from 0 to Integer.MAX_VALUE. Note unlike traditional definition of natural number, zero is included in the range returned
    
    Returns:
    
    a range of non negative integers
  - evenNumbers
```
public static C.Range<Integer> evenNumbers()
```
    Returns a C.Range of non-negative even numbers starts from 0 to Integer.MAX_VALUE.
    
    Returns:
    
    a range of non-negative even numbers
  - oddNumbers
```
public static C.Range<Integer> oddNumbers()
```
    Returns a C.Range of positive odd numbers starts from 1 to Integer.MAX_VALUE.
    
    Returns:
    
    a range of positive odd numbers
  - empty
```
public static <T> C.ListOrSet<T> empty()
```
  - list
```
public static <T> C.List<T> list()
```
    Returns an empty immutable list
    
    Type Parameters:
    
    T - the type of the list element
    
    Returns:
    
    the empty list
  - emptyListOf
```
public static <T> C.List<T> emptyListOf(Class<T> c)
```
  - list
```
public static <T> C.List<T> list(T t)
```
  - listOf
```
public static <T> C.List<T> listOf(T... ta)
```
    Creates an immutable list of an array of elements.
    Note the array will not be copied, instead it will be used directly as the backing data for the list. To create an list with a copy of the array specified. Use the newListOf(Object[]) method
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    ta - an array of elements
    
    Returns:
    
    an immutable list backed by the specified array
  - list
```
public static <T> C.List<T> list(T t,
                                 T... ta)
```
    Creates an immutable list from an element plus an array of elements
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    t - the first element
    
    ta - the array
    
    Returns:
    
    an immutable list contains the first element and followed by all element in the array
  - listOf
```
public static C.List<Boolean> listOf(boolean[] elements)
```
    Create an immutable Boolean list from a boolean (primitive type) array.
    At the moment the implementation will convert the boolean (primary) array to Boolean (wraper) array, thus a copy of the array will actually take place. However it should assume the array will directly be used as backing data in user application to cater to the future optimized implementation
    
    Parameters:
    
    elements - an array of primary boolean
    
    Returns:
    
    a Boolean typed list
  - list
```
public static C.List<Boolean> list(boolean[] elements)
```
    Create an immutable Boolean list of a byte (primitive type) array. The elements of the array is copied into the returned list
    
    Parameters:
    
    elements - an array of bytes
    
    Returns:
    
    an immutable list contains specified elements
  - listOf
```
public static C.List<Byte> listOf(byte[] elements)
```
    Create an immutable Byte list from a byte (primitive type) array.
    At the moment the implementation will convert the byte (primary) array to Byte (reference) array, thus a copy of the array will actually take place. However it should assume the array will directly be used as backing data in user application to cater to the future optimized implementation
    
    Parameters:
    
    elements - an array of primary byte
    
    Returns:
    
    a Byte typed list
  - list
```
public static C.List<Byte> list(byte[] elements)
```
    Create an immutable Byte list of a byte (primitive type) array. The elements of the array is copied into the returned list
    
    Parameters:
    
    elements - an array of bytes
    
    Returns:
    
    an immutable list contains specified elements
  - listOf
```
public static C.List<Character> listOf(char[] elements)
```
    Create an immutable Short list from a char (primitive type) array.
    At the moment the implementation will convert the char (primary) array to Character (reference) array, thus a copy of the array will actually take place. However it should assume the array will directly be used as backing data in user application to cater to the future optimized implementation
    
    Parameters:
    
    elements - an array of primary short
    
    Returns:
    
    a Short typed list
  - list
```
public static C.List<Character> list(char[] elements)
```
    Create an immutable Character list of a char array. The elements of the array is copied into the returned list
    
    Parameters:
    
    elements - an array of shorts
    
    Returns:
    
    an immutable list contains specified elements
  - listOf
```
public static C.List<Short> listOf(short[] elements)
```
    Create an immutable Short list from a short (primitive type) array.
    At the moment the implementation will convert the short (primary) array to Short (reference) array, thus a copy of the array will actually take place. However it should assume the array will directly be used as backing data in user application to cater to the future optimized implementation
    
    Parameters:
    
    elements - an array of primary short
    
    Returns:
    
    a Short typed list
  - list
```
public static C.List<Short> list(short[] elements)
```
    Create an immutable Short list of a short array. The elements of the array is copied into the returned list
    
    Parameters:
    
    elements - an array of shorts
    
    Returns:
    
    an immutable list contains specified elements
  - listOf
```
public static C.List<Integer> listOf(int[] elements)
```
    Create an immutable Integer list from an int (primitive type) array.
    At the moment the implementation will convert the int (primary) array to Integer (reference) array, thus a copy of the array will actually take place. However it should assume the array will directly be used as backing data in user application to cater to the future optimized implementation
    
    Parameters:
    
    elements - an array of primary int
    
    Returns:
    
    an Integer list
  - list
```
public static C.List<Integer> list(int[] elements)
```
    Create an immutable integer list of a int array. If an empty array specified, the nan empty immutable list is returned
    
    Parameters:
    
    elements - an array of int
    
    Returns:
    
    an immutable list contains specified elements
  - listOf
```
public static C.List<Long> listOf(long[] elements)
```
    Create an immutable Long list from a long (primitive type) array.
    At the moment the implementation will convert the long (primary) array to Long (reference) array, thus a copy of the array will actually take place. However it should assume the array will directly be used as backing data in user application to cater to the future optimized implementation
    
    Parameters:
    
    elements - an array of primary long
    
    Returns:
    
    an Long list
  - list
```
public static C.List<Long> list(long[] elements)
```
    Create an immutable Long list of a long array. If an empty array specified, the nan empty immutable list is returned
    
    Parameters:
    
    elements - an array of long
    
    Returns:
    
    an immutable list contains specified elements
  - listOf
```
public static C.List<Float> listOf(float[] elements)
```
    Create an immutable Float list from a float (primitive type) array.
    At the moment the implementation will convert the float (primary) array to Float (reference) array, thus a copy of the array will actually take place. However it should assume the array will directly be used as backing data in user application to cater to the future optimized implementation
    
    Parameters:
    
    elements - an array of primary float
    
    Returns:
    
    an Float list
  - list
```
public static C.List<Float> list(float[] elements)
```
    Create an immutable byte list of a float array. If an empty array specified, the nan empty immutable list is returned
    
    Parameters:
    
    elements - an array of floats
    
    Returns:
    
    an immutable list contains specified elements
  - listOf
```
public static C.List<Double> listOf(double[] elements)
```
    Create an immutable Double list from an double (primitive type) array.
    At the moment the implementation will convert the double (primary) array to Double (reference) array, thus a copy of the array will actually take place. However it should assume the array will directly be used as backing data in user application to cater to the future optimized implementation
    
    Parameters:
    
    elements - an array of primary double
    
    Returns:
    
    an Double list
  - list
```
public static C.List<Double> list(double[] elements)
```
    Create an immutable Byte list of a double array. If an empty array specified, the nan empty immutable list is returned
    
    Parameters:
    
    elements - an array of double
    
    Returns:
    
    an immutable list contains specified elements
  - list
```
public static <T> C.List<T> list(Iterable<? extends T> iterable)
```
  - list
```
public static <T> C.List<T> list(Iterator<? extends T> iterator)
```
  - list
```
public static <T> C.List<T> list(Enumeration<? extends T> enumeration)
```
  - list
```
public static <T> C.List<T> list(Collection<? extends T> col)
```
  - list
```
public static <T> C.List<T> list(List<? extends T> javaList)
```
  - singletonList
```
public static <T> C.List<T> singletonList(T t)
```
  - wrap
```
public static <T> C.List<T> wrap(List<T> list)
```
  - newSizedList
```
public static <T> C.List<T> newSizedList(int size)
```
  - newList
```
public static <T> C.List<T> newList()
```
  - newList
```
public static <T> C.List<T> newList(Iterable<? extends T> iterable)
```
  - newList
```
public static <T> C.List<T> newList(T t)
```
  - newList
```
public static <T> C.List<T> newList(T t1,
                                    T t2)
```
  - newList
```
public static <T> C.List<T> newList(T t1,
                                    T t2,
                                    T t3)
```
  - newList
```
public static <T> C.List<T> newList(T t1,
                                    T t2,
                                    T t3,
                                    T... ta)
```
  - newListOf
```
public static <T> C.List<T> newListOf(T[] ts)
```
  - seq
```
public static <T> C.Sequence<T> seq(Iterable<? extends T> iterable)
```
    Return a C.Sequence consists of all elements in the iterable specified
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    iterable - the iterable in which elements will be used to fill into the sequence
    
    Returns:
    
    the sequence
  - seq
```
public static <T> C.Sequence<T> seq(Iterator<? extends T> iterator)
```
  - seq
```
public static <T> C.Sequence<T> seq(Enumeration<? extends T> enumeration)
```
  - extract
```
public static <PROPERTY> C.List<PROPERTY> extract(Collection<?> collection,
                                                  String propertyPath)
```
    Alias of collect(Iterable, String)
    
    Type Parameters:
    
    PROPERTY -
    
    Parameters:
    
    collection -
    
    propertyPath -
    
    Returns:
  - lazyExtract
```
public static <PROPERTY> C.Sequence<PROPERTY> lazyExtract(Iterable<?> iterable,
                                                          String propertyPath)
```
  - map
```
public static <T,R> C.Sequence<R> map(Iterable<? extends T> seq,
                                      Lang.Function<? super T,? extends R> mapper)
```
  - map
```
public static <T,R> C.ReversibleSequence<R> map(C.ReversibleSequence<? extends T> seq,
                                                Lang.Function<? super T,? extends R> mapper)
```
  - filter
```
public static <T> C.Sequence<T> filter(Iterable<? extends T> iterable,
                                       Lang.Function<? super T,Boolean> predicate)
```
  - prepend
```
public static <T> C.Sequence<T> prepend(T t,
                                        C.Sequence<T> sequence)
```
  - concat
```
public static <T> C.Sequence<T> concat(C.Sequence<T> s1,
                                       C.Sequence<T> s2)
```
    Concatenate two C.Sequence into one
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    s1 - the first sequence
    
    s2 - the second sequence
    
    Returns:
    
    the concatenated sequence
  - concat
```
public static <T> C.ReversibleSequence<T> concat(C.ReversibleSequence<T> s1,
                                                 C.ReversibleSequence<T> s2)
```
    Concatenate two C.ReversibleSequence into one
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    s1 - the first reversible sequence
    
    s2 - the second reversible sequence
    
    Returns:
    
    the concatenated reversible sequence
  - concat
```
public static <T> C.List<T> concat(C.List<T> l1,
                                   C.List<T> l2)
```
    Concatenate two List into one.
    Note if the first list is readonly or immutable an new list instance will be created with elements in both list 1 and list 2 filled in. Otherwise all elemnets from list 2 will be appended to list 1 and return list 1 instance
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    l1 - list 1
    
    l2 - list 2
    
    Returns:
    
    a list with elements of both list 1 and list 2
  - set
```
@Deprecated
public static <T> C.Set<T> set()
```
    Deprecated.
    
    This method is deprecated. Please use Set() instead
  - Set
```
public static <T> C.Set<T> Set()
```
    Create an empty immutable set
    
    Type Parameters:
    
    T - the generic type
    
    Returns:
    
    the empty set
  - set
```
public static <T> C.Set<T> set(T element)
```
    Create an immutable set of a single element
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    element - the single element
    
    Returns:
    
    the set that contains only specified element
  - set
```
public static <T> C.Set<T> set(T t1,
                               T... ta)
```
    Create an immutable set contains specified elements
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    t1 - one element to be added into the result set
    
    ta - an array from which all elements will be added into the result set
    
    Returns:
    
    a set that contains all elements specified
  - setOf
```
public static <T> C.Set<T> setOf(T... ta)
```
    Create an immutable set of an array of elements
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    ta - the array from which all elements will be added into the result set
    
    Returns:
    
    the set contains all elements in the array
  - set
```
@Deprecated
public static <T> C.Set<T> set(Collection<? extends T> col)
```
    Deprecated.
    
    This method is deprecated. Please use Set(Collection) instead
  - Set
```
public static <T> C.Set<T> Set(Collection<? extends T> col)
```
    Create an immutable set of all elements contained in the collection specified
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    col - the collection from which elements will be added into the result set
    
    Returns:
    
    the set contains all elements in the collection
    
    See Also:
    
    newSet(Collection)
  - set
```
public static <T> C.Set<T> set(Iterable<? extends T> itr)
```
    Create an immutable set of all elements supplied by the iterable specified
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    itr - the iterable from where elements will be added into the result set
    
    Returns:
    
    the set contains all elements supplied by the iterable
  - newSet
```
public static <T> C.Set<T> newSet()
```
    Create an new empty set
    
    Type Parameters:
    
    T - the element type
    
    Returns:
    
    an empty set
  - newSet
```
public static <T> C.Set<T> newSet(T t1,
                                  T... ta)
```
    Create an mutable set contains specified elements
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    t1 - one element to be added into the result set
    
    ta - an array from which all elements will be added into the result set
    
    Returns:
    
    a set that contains all elements specified
  - newSet
```
public static <T> C.Set<T> newSet(Collection<? extends T> col)
```
    Create an new set with all elements contained in the collection specified
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    col - the collection from which all elements will be added into the result set
    
    Returns:
    
    the set contains all elements in the collection
    
    See Also:
    
    set(Collection)
  - unionOf
```
public static <T> C.Set<T> unionOf(Collection<? extends T> col1,
                                   Collection<? extends T> col2)
```
  - unionOf
```
public static <T> C.Set<T> unionOf(Collection<? extends T> col1,
                                   Collection<? extends T> col2,
                                   Collection<? extends T> col3,
                                   Collection<? extends T>... otherCols)
```
  - intercectionOf
```
public static <T> C.Set<T> intercectionOf(Collection<? extends T> col1,
                                          Collection<? extends T> col2)
```
  - interceptionOf
```
public static <T> C.Set<T> interceptionOf(Collection<? extends T> col1,
                                          Collection<? extends T> col2,
                                          Collection<? extends T> col3,
                                          Collection<? extends T>... otherCols)
```
  - Map
```
public static <K,V> C.Map<K,V> Map(Object... args)
```
    Create a immutable Map from elements specified in an array.
    Example
```
  Map<String, Integer> scores = C.map(“Tom”, 80, “Peter”, 93, …); 
```
    The above code will create an immutable Map with the following entries
    - (Tom, 80)
    - (Peter, 93)
    - …
    Note the array size must be an even number, otherwise IndexOutOfBoundsException will be thrown out
    Type Parameters:
    
    K - the key type
    
    V - the value type
    
    Parameters:
    
    args - the argument array specifies the entries
    
    Returns:
    
    an immutable map contains of specified entries
    
    See Also:
    
    newMap(Object...)
  - Map
```
public static <K,V> C.Map<K,V> Map(boolean readOnly,
                                   Map<K,V> map)
```
  - Map
```
public static <K,V> C.Map<K,V> Map(Collection<Lang.Tuple<K,V>> kvCol)
```
  - Map
```
public static <K,V> C.Map<K,V> Map(Map<? extends K,? extends V> map)
```
    Create an immutable Map from existing Map
    
    Type Parameters:
    
    K - the key type
    
    V - the value type
    
    Parameters:
    
    map - the map from which entries will be put into the new immutable map
    
    Returns:
    
    an immutable map of the existing map
  - newMap
```
public static <K,V> C.Map<K,V> newMap(Object... args)
```
    Create an new Map from an array of elements.
    Example
```
  Map<String, Integer> scores = C.newMap(“Tom”, 80, “Peter”, 93, …); 
```
    The above code will create a Map with the following entries
    - (Tom, 80)
    - (Peter, 93)
    - …
    Note the array size must be an even number, otherwise IndexOutOfBoundsException will be thrown out
    Type Parameters:
    
    K - the key type
    
    V - the value type
    
    Parameters:
    
    args - the argument array specifies the entries
    
    Returns:
    
    a map contains of specified entries
    
    See Also:
    
    Map(Object...)
  - newMap
```
public static <K,V> C.Map<K,V> newMap(Map<? extends K,? extends V> map)
```
    Create an new Map from existing Map
    
    Type Parameters:
    
    K - the key type
    
    V - the value type
    
    Parameters:
    
    map - the map that contains elements to be put into the new map
    
    Returns:
    
    a map that contains all entries in the existing map
  - enumerable
```
public static <T> Iterable<T> enumerable(Enumeration<T> e)
```
    Convert a Enumeration to an Iterable
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    e - the enumeration
    
    Returns:
    
    an iterable corresponding to the enumeration
  - isReadOnly
```
public static boolean isReadOnly(C.Traversable<?> t)
```
    Check if a C.Traversable structure is read only. A Traversable is considered to be read only structure when is(Feature.READONLY) || is(Feature.IMMUTABLE evaluate to true
    
    Parameters:
    
    t - the structure to be checked
    
    Returns:
    
    true if the structure is read only or immutable
  - isImmutable
```
public static boolean isImmutable(C.Traversable<?> t)
```
    Check if a C.Traversable structure is immutable.
    
    Parameters:
    
    t - the traversable strucure to be checked
    
    Returns:
    
    true if the traversable is immutable
  - forEach
```
public static <T> void forEach(Iterable<? extends T> iterable,
                               Lang.Visitor<? super T> visitor)
                        throws Lang.Break
```
    Run visitor function on each element supplied by the iterable. The visitor function can throw out Lang.Break if it need to break the loop.
    Note if NotAppliedException thrown out by visitor function, it will be ignored and keep looping through the Map entry set. It is kind of continue mechanism in a funcitonal way
    
    Type Parameters:
    
    T - the generic type of the iterable elements
    
    Parameters:
    
    iterable - supply the element to be applied to the visitor function
    
    visitor - the function called on element provided by the iterable
    
    Throws:
    
    $.Break - break the loop
    
    Lang.Break
  - forEach
```
public static <T> void forEach(Iterator<? extends T> iterator,
                               Lang.Visitor<? super T> visitor)
```
    Run visitor function on each element supplied by the iterator. The visitor function can throw out Lang.Break if it need to break the loop.
    Note if NotAppliedException thrown out by visitor function, it will be ignored and keep looping through the Map entry set. It is kind of continue mechanism in a funcitonal way
    
    Type Parameters:
    
    T - the generic type of the element
    
    Parameters:
    
    iterator - iterator provides elements to be applied to the visitor function
    
    visitor - the function applied on the element
  - forEach
```
public static <K,V> void forEach(Map<K,V> map,
                                 Lang.IndexedVisitor<? super K,? super V> indexedVisitor)
                          throws Lang.Break
```
    Run indexedVisitor function on all key/value pair in a given map. The indexedVisitor function can throw out Lang.Break if it need to break the loop.
    Note if NotAppliedException thrown out by indexedVisitor function, it will be ignored and keep looping through the Map entry set. It is kind of continue mechanism in a funcitonal way
    
    Type Parameters:
    
    K - the generic type of Key
    
    V - the generic type of Value
    
    Parameters:
    
    map - the map in which enties will be applied to the indexedVisitor function
    
    indexedVisitor - the function that takes (key,value) pair
    
    Throws:
    
    $.Break - the Lang.Break with payload throwed out by indexedVisitor function to break to loop
    
    Lang.Break
  - collect
```
public static C._CollectStage collect(Iterable source)
```
  - collect
```
public static C._CollectStage2 collect(String propertyPath)
```
  - collect
```
public static <T> C.List<T> collect(Iterable source,
                                    String propertyPath)
```
  - map
```
public static <T> C._MapStage<T> map(Iterable<? extends T> source)
```
  - map
```
public static <T,R> C._MapStage2 map(Lang.Function<? super T,? extends R> mapper)
```
  - filter
```
public static <T> C._FilterStage<T> filter(Iterable<? extends T> source)
```
  - filter
```
public static <T> C._FilterStage2<T> filter(Lang.Predicate<? super T> predicate)
```

Class C

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

CONF_LINKED_LIST_FACTORY

CONF_RANDOM_ACCESS_LIST_FACTORY

EMPTY_LIST

EMPTY_SET

EMPTY_MAP

EMPTY

Method Detail

empty

notEmpty

isEmpty

empty

notEmpty

isEmpty

asCollection

range

range

range

range

naturalNumbers

evenNumbers

oddNumbers

empty

list

emptyListOf

list

listOf

list

listOf

list

listOf

list

listOf

list

listOf

list

listOf

list

listOf

list

listOf

list

listOf

list

list

list

list

list

list

singletonList

wrap

newSizedList

newList

newList

newList

newList

newList

newList

newListOf

seq

seq

seq

extract

lazyExtract

map

map

filter

prepend

concat

concat

concat

set

Set

set

set