C.F (Java Tool 1.26.2 API)

java.lang.Object
- java.lang.Enum<C.F>
- - org.osgl.util.C.F

All Implemented Interfaces:

Serializable, Comparable<C.F>

Enclosing class:

C
```
public static enum C.F
extends Enum<C.F>
```
the namespace of function definitions relevant to Collection manipulation

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <L extends C.List<? super T>,T> Lang.F1<L,L>`	`add(int index, T element)` Returns a function that add specified element into the argument list at specified position.
`static <T> Lang.Predicate<Collection<? super T>>`	`add(T element)` Returns a function that add the specified element into the argument collection and return `true` if add successfully or `false` otherwise
`static <T> Lang.Predicate<Collection<? super T>>`	`addAll(Collection<? extends T> source)` Returns a function that add all elements in the source collection specified into the destination collection as argument.
`static <T> Lang.Predicate<C.List<? super T>>`	`addAll(int index, Collection<? extends T> source)` Returns a function that add all elements from the source collection specified into the argument list at the position specified
`static <T> Lang.Predicate<Iterable<? extends T>>`	`addAllTo(Collection<? super T> destination)` Returns a function that takes argument of type `Collection` and add all elements inside into the specified collection.
`static <T> Lang.Predicate<Collection<? extends T>>`	`addAllTo(int index, C.List<? super T> destination)` Returns a function that add all elements from the argument collection into the destination list specified at the position specified
`static <T> Lang.Predicate<T>`	`addTo(Collection<? super T> destination)` Returns a function that add the argument to a collection specified and returns `true` if added successfully or `false` otherwise
`static <L extends C.List<? super T>,T> Lang.F1<T,L>`	`addTo(int index, L destination)` Returns a function that add the argument into the specified list at specified position.
`static <T> Lang.Predicate<Collection<? extends T>>`	`allContainsIn(Collection<? super T> collection)` Returns a predicate function that check if all element in the argument (a collection) contained in the collection specified
`static <T> Lang.F1<T,C.Sequence<? super T>>`	`appendTo(C.Sequence<? super T> sequence)` Returns a function that append the argument to a `C.Sequence` specified
`static <T> Lang.F1<T,Deque<? super T>>`	`appendTo(Deque<? super T> deque)` Returns a function that append the argument to a `Deque` specified
`static <T> Lang.Transformer<Iterable<T>,Collection<T>>`	`asCollection()`
`static <T> Lang.Predicate<Collection<? super T>>`	`contains(T element)` Returns a predicate function that check if the argument (collection) contains the element specified
`static <T> Lang.Predicate<Collection<? super T>>`	`containsAll(Collection<? extends T> collection)` Returns a predicate function that check if all element in the collection specified are contained in the argument collection
`static <T> Lang.Predicate<T>`	`containsIn(Collection<? super T> collection)` Returns a predicate function that check if the argument is contained in the collection specified
`static <T> Lang.Processor<Deque<? super T>>`	`dequeAppend(T element)` Returns a function that append specified element to argument deque
`static <T> Lang.Processor<Deque<? super T>>`	`dequePrepend(T element)` Returns a function that prepend specified element to argument deque
`static <T> Lang.F1<Iterable<? extends T>,Void>`	`forEachIterable(Lang.Visitor<? super T> visitor)` Returns a function that apply the visitor function specified on the argument (iterable)
`static <T> Lang.F1<T,C.Sequence<? super T>>`	`prependTo(C.Sequence<? super T> sequence)` Returns a function that prepend the argument to a `C.Sequence` specified
`static <T> Lang.F1<T,Deque<? super T>>`	`prependTo(Deque<? super T> deque)` Returns a function that prepend an element to a deque specified and return the deque instance
`static <T> Lang.Predicate<Collection<? super T>>`	`remove(T toBeRemoved)` Returns a function that remove the element specified from the argument collection.
`static <T> Lang.Predicate<Collection<? super T>>`	`removeAll(Collection<? extends T> source)` Returns a function that remove all elements in the `source` collection from the argument collection.
`static <T> Lang.Predicate<Collection<? extends T>>`	`removeAllFrom(Collection<? super T> fromCollection)` Returns a function that remove all elements in the argument collection from the `fromCollection` specified.
`static <T> Lang.Predicate<T>`	`removeFrom(Collection<? super T> collection)` Returns a function that remove the argument from a collection specified.
`static <T> Lang.Predicate<Collection<? super T>>`	`retainAll(Collection<? extends T> collection)` Returns a function that retains only elements contained in the specified collection in the argument collection.
`static <T> Lang.Predicate<Collection<? extends T>>`	`retainAllIn(Collection<? super T> collection)` Returns a function that retains only elements contained in the argument collection in the collection specified.
`static <T> Lang.Processor<C.Sequence<? super T>>`	`sequenceAppend(T element)` Returns a function that append specified element to argument sequence
`static <T> Lang.Processor<C.Sequence<? super T>>`	`sequencePrepend(T element)` Returns a function that preppend specified element to argument sequence
`static C.F`	`valueOf(String name)` Returns the enum constant of this type with the specified name.
`static C.F[]`	`values()` Returns an array containing the constants of this enum type, in the order they are declared.

Methods inherited from class java.lang.Enum
clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, toString, valueOf

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

- Method Detail
  - values
```
public static C.F[] values()
```
    Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows:
```
for (C.F c : C.F.values())
    System.out.println(c);
```
    Returns:
    
    an array containing the constants of this enum type, in the order they are declared
  - valueOf
```
public static C.F valueOf(String name)
```
    Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)
    
    Parameters:
    
    name - the name of the enum constant to be returned.
    
    Returns:
    
    the enum constant with the specified name
    
    Throws:
    
    IllegalArgumentException - if this enum type has no constant with the specified name
    
    NullPointerException - if the argument is null
  - asCollection
```
public static <T> Lang.Transformer<Iterable<T>,Collection<T>> asCollection()
```
  - containsIn
```
public static <T> Lang.Predicate<T> containsIn(Collection<? super T> collection)
```
    Returns a predicate function that check if the argument is contained in the collection specified
    
    Type Parameters:
    
    T - the generic type of the element of the collection
    
    Parameters:
    
    collection - the collection to be checked on against the argument when applying the prediate
    
    Returns:
    
    a predicate function
    
    See Also:
    
    Collection.contains(Object), contains(Object)
  - contains
```
public static <T> Lang.Predicate<Collection<? super T>> contains(T element)
```
    Returns a predicate function that check if the argument (collection) contains the element specified
    
    Type Parameters:
    
    T - the type of the element
    
    Parameters:
    
    element - the element to be checked
    
    Returns:
    
    the function that do the check
    
    See Also:
    
    Collection.contains(Object), containsIn(Collection)
  - allContainsIn
```
public static <T> Lang.Predicate<Collection<? extends T>> allContainsIn(Collection<? super T> collection)
```
    Returns a predicate function that check if all element in the argument (a collection) contained in the collection specified
    
    Type Parameters:
    
    T - the generic type of the element of the collection or argument
    
    Parameters:
    
    collection - the collection to be checked on against all elements in the argument when applying the function
    
    Returns:
    
    the function that do the check
    
    See Also:
    
    Collection.containsAll(Collection), containsAll(Collection)
  - containsAll
```
public static <T> Lang.Predicate<Collection<? super T>> containsAll(Collection<? extends T> collection)
```
    Returns a predicate function that check if all element in the collection specified are contained in the argument collection
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    collection - the collection in which all elements will be checked if contained in the argument collection when applying the function
    
    Returns:
    
    the function that do the check
    
    See Also:
    
    Collection.containsAll(Collection), allContainsIn(Collection)
  - addTo
```
public static <T> Lang.Predicate<T> addTo(Collection<? super T> destination)
```
    Returns a function that add the argument to a collection specified and returns true if added successfully or false otherwise
    
    Type Parameters:
    
    T - the generic type of the collection elements
    
    Parameters:
    
    destination - the collection into which the argument to be added
    
    Returns:
    
    a function that do the add operation
    
    See Also:
    
    Collection.add(Object), add(Object)
  - add
```
public static <T> Lang.Predicate<Collection<? super T>> add(T element)
```
    Returns a function that add the specified element into the argument collection and return true if add successfully or false otherwise
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    element - the element to be added when applying the function
    
    Returns:
    
    the function
    
    See Also:
    
    Collection.add(Object), addTo(Collection)
  - addTo
```
public static <L extends C.List<? super T>,T> Lang.F1<T,L> addTo(int index,
                                                                 L destination)
```
    Returns a function that add the argument into the specified list at specified position. the function returns true if added successfully or false otherwise
    
    Type Parameters:
    
    L - the generic type of the list
    
    T - the generic type of the list element
    
    Parameters:
    
    destination - a list into which the argument to be added
    
    index - specify the position where the argument can be added
    
    Returns:
    
    the function that do the add operation
    
    See Also:
    
    List.add(int, Object), add(int, Object)
  - add
```
public static <L extends C.List<? super T>,T> Lang.F1<L,L> add(int index,
                                                               T element)
```
    Returns a function that add specified element into the argument list at specified position. The function returns the argument list after element added
    
    Type Parameters:
    
    L - the list type
    
    T - the element type
    
    Parameters:
    
    index - the location at where the element should be added to
    
    element - the element the be added to the argument list
    
    Returns:
    
    the function
    
    See Also:
    
    List.add(int, Object), #addTo(int, List)
  - addAllTo
```
public static <T> Lang.Predicate<Iterable<? extends T>> addAllTo(Collection<? super T> destination)
```
    Returns a function that takes argument of type Collection and add all elements inside into the specified collection. The function returns true if the collection specified has been changed as a result of adding elements
    
    Type Parameters:
    
    T - the generic type of the collection element and the argument collection element
    
    Parameters:
    
    destination - the collection into which all elements in the argument collection will be added when applying the function
    
    Returns:
    
    the function that add all elements from iterable argument into the collection specified
    
    See Also:
    
    Collection.addAll(Collection), addAll(Collection)
  - addAll
```
public static <T> Lang.Predicate<Collection<? super T>> addAll(Collection<? extends T> source)
```
    Returns a function that add all elements in the source collection specified into the destination collection as argument. The function returns true if the argument collection has been changes as a result of call.
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    source - the collection from which the elements will be added into the argument collection when applying the function
    
    Returns:
    
    the function the perform the add operation
    
    See Also:
    
    Collection.addAll(Collection), addAllTo(Collection)
  - addAllTo
```
public static <T> Lang.Predicate<Collection<? extends T>> addAllTo(int index,
                                                                   C.List<? super T> destination)
```
    Returns a function that add all elements from the argument collection into the destination list specified at the position specified
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    index - the position at where the element shall be inserted into the destination list
    
    destination - the list into which the elements will be added
    
    Returns:
    
    the function that do the add operation
    
    See Also:
    
    List.addAll(int, Collection), addAll(int, Collection)
  - addAll
```
public static <T> Lang.Predicate<C.List<? super T>> addAll(int index,
                                                           Collection<? extends T> source)
```
    Returns a function that add all elements from the source collection specified into the argument list at the position specified
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    index - the position where the element should be insert in the argument list
    
    source - the collection from which the elements to be get to added into the argument list
    
    Returns:
    
    the function that do the add operation
    
    See Also:
    
    List.addAll(int, Collection), #addAllTo(int, List)
  - removeFrom
```
public static <T> Lang.Predicate<T> removeFrom(Collection<? super T> collection)
```
    Returns a function that remove the argument from a collection specified.
    The function returns true if argument removed successfully or false otherwise
    
    Parameters:
    
    collection - the collection from which the argument to be removed when applying the function returned
    
    Returns:
    
    the function that remove element from the collection
    
    See Also:
    
    Collection.remove(Object), remove(Object)
  - remove
```
public static <T> Lang.Predicate<Collection<? super T>> remove(T toBeRemoved)
```
    Returns a function that remove the element specified from the argument collection. The function returns true if the argument collection changed as a result of the call.
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    toBeRemoved - the element to be removed from the argument when applying the function
    
    Returns:
    
    the function that do removing
    
    See Also:
    
    Collection.remove(Object), removeFrom(Collection)
  - removeAllFrom
```
public static <T> Lang.Predicate<Collection<? extends T>> removeAllFrom(Collection<? super T> fromCollection)
```
    Returns a function that remove all elements in the argument collection from the fromCollection specified. The function returns true if the fromCollection changed as a result of call
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    fromCollection - the collection from which elements will be removed
    
    Returns:
    
    the function
    
    See Also:
    
    Collection.removeAll(Collection), removeAll(Collection)
  - removeAll
```
public static <T> Lang.Predicate<Collection<? super T>> removeAll(Collection<? extends T> source)
```
    Returns a function that remove all elements in the source collection from the argument collection. The function returns true if the argument collection changed as a result of call
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    source - the collection in which elements will be used to remove from argument collection
    
    Returns:
    
    the function
    
    See Also:
    
    Collection.removeAll(Collection), removeAllFrom(Collection)
  - retainAllIn
```
public static <T> Lang.Predicate<Collection<? extends T>> retainAllIn(Collection<? super T> collection)
```
    Returns a function that retains only elements contained in the argument collection in the collection specified. The function returns true if the collection specified changed as a result of call
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    collection - the collection in which elements will be retained/removed
    
    Returns:
    
    the function as described
    
    See Also:
    
    Collection.retainAll(Collection), retainAll(Collection)
  - retainAll
```
public static <T> Lang.Predicate<Collection<? super T>> retainAll(Collection<? extends T> collection)
```
    Returns a function that retains only elements contained in the specified collection in the argument collection. The function returns true if argument collection changes as a result of the call
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    collection - the collection in which elements will be used to check if argument collection element shall be retained or not
    
    Returns:
    
    the function as described above
    
    See Also:
    
    Collection.retainAll(Collection), retainAllIn(Collection)
  - prependTo
```
public static <T> Lang.F1<T,Deque<? super T>> prependTo(Deque<? super T> deque)
```
    Returns a function that prepend an element to a deque specified and return the deque instance
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    deque - the deque to which the element argument will be prepend to
    
    Returns:
    
    the function as described
    
    See Also:
    
    Deque.addFirst(Object), dequePrepend(Object)
  - dequePrepend
```
public static <T> Lang.Processor<Deque<? super T>> dequePrepend(T element)
```
    Returns a function that prepend specified element to argument deque
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    element - the element to be added to the head of the argument (deque type)
    
    Returns:
    
    the function as described
    
    See Also:
    
    Deque.addFirst(Object), prependTo(Deque)
  - appendTo
```
public static <T> Lang.F1<T,Deque<? super T>> appendTo(Deque<? super T> deque)
```
    Returns a function that append the argument to a Deque specified
    
    Type Parameters:
    
    T - the generic type of the argument/deque element
    
    Parameters:
    
    deque - the deque to which the argument shall be append when applying the function returned
    
    Returns:
    
    the function that do the append operation
    
    See Also:
    
    Deque.add(Object), dequeAppend(Object)
  - dequeAppend
```
public static <T> Lang.Processor<Deque<? super T>> dequeAppend(T element)
```
    Returns a function that append specified element to argument deque
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    element - the element to be added to the tail of the argument (deque type)
    
    Returns:
    
    the function as described
    
    See Also:
    
    Deque.add(Object), appendTo(Deque)
  - prependTo
```
public static <T> Lang.F1<T,C.Sequence<? super T>> prependTo(C.Sequence<? super T> sequence)
```
    Returns a function that prepend the argument to a C.Sequence specified
    
    Type Parameters:
    
    T - the generic type of the argument/sequence element
    
    Parameters:
    
    sequence - the sequence to which the argument shall be prepend whene applying the function
    
    Returns:
    
    the function that do the prepend operation
    
    See Also:
    
    C.Sequence.prepend(Object), sequencePrepend(Object)
  - sequencePrepend
```
public static <T> Lang.Processor<C.Sequence<? super T>> sequencePrepend(T element)
```
    Returns a function that preppend specified element to argument sequence
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    element - the element to be added to the head of the argument (sequence type)
    
    Returns:
    
    the function as described
    
    See Also:
    
    C.Sequence.prepend(Object), #prependTo(Sequence)
  - appendTo
```
public static <T> Lang.F1<T,C.Sequence<? super T>> appendTo(C.Sequence<? super T> sequence)
```
    Returns a function that append the argument to a C.Sequence specified
    Note the function returns the sequence with the argument been removed
    
    Type Parameters:
    
    T - the generic type of the argument/sequence element
    
    Parameters:
    
    sequence - the sequence to which the argument shall be append when applying the function
    
    Returns:
    
    the function that do the append operation
    
    See Also:
    
    C.Sequence.append(Iterable), sequenceAppend(Object)
  - sequenceAppend
```
public static <T> Lang.Processor<C.Sequence<? super T>> sequenceAppend(T element)
```
    Returns a function that append specified element to argument sequence
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    element - the element to be added to the tail of the argument (sequence type)
    
    Returns:
    
    the function as described
    
    See Also:
    
    C.Sequence.append(Iterable), #appendTo(Sequence)
  - forEachIterable
```
public static <T> Lang.F1<Iterable<? extends T>,Void> forEachIterable(Lang.Visitor<? super T> visitor)
```
    Returns a function that apply the visitor function specified on the argument (iterable)
    
    Type Parameters:
    
    T - the element type
    
    Parameters:
    
    visitor - the function to be used to loop through the argument
    
    Returns:
    
    the function as described
    
    See Also:
    
    C.forEach(Iterable, org.osgl.Lang.Visitor)

Enum C.F

Method Summary

Methods inherited from class java.lang.Enum

Methods inherited from class java.lang.Object

Method Detail

values

valueOf

asCollection

containsIn

contains

allContainsIn

containsAll

addTo

add

addTo

add

addAllTo

addAll

addAllTo

addAll

removeFrom

remove

removeAllFrom

removeAll

retainAllIn

retainAll

prependTo

dequePrepend

appendTo

dequeAppend

prependTo

sequencePrepend

appendTo

sequenceAppend

forEachIterable