SetBase (Java Tool 1.10.0 API)

java.lang.Object
- java.util.AbstractCollection<E>
- - java.util.AbstractSet<T>
  - - org.osgl.util.SetBase<T>

All Implemented Interfaces:

Iterable<T>, Collection<T>, Set<T>, C.Featured, C.Set<T>, C.Traversable<T>
```
public abstract class SetBase<T>
extends AbstractSet<T>
implements C.Set<T>
```

Nested Class Summary
- Nested classes/interfaces inherited from interface org.osgl.util.C.Featured
  C.Featured.Factory

Constructor Summary

Constructors
Constructor and Description

SetBase()

Constructors
Constructor and Description
`SetBase()`

Method Summary

Methods
Modifier and Type	Method and Description
`SetBase<T>`	`accept(Lang.Visitor<? super T> visitor)` Iterate this `Traversable` with a visitor function.
`boolean`	`allMatch(Lang.Function<? super T,Boolean> predicate)` Check if all elements match the predicate specified
`boolean`	`anyMatch(Lang.Function<? super T,Boolean> predicate)` Check if any elements matches the predicate specified
`SetBase<T>`	`each(Lang.Visitor<? super T> visitor)` Alias of `#accept(Osgl.Visitor)`
`C.Set<T>`	`eager()` Returns this traversable and turn off `C.Feature.LAZY`
`protected EnumSet<C.Feature>`	`features_()`
`EnumSet<C.Feature>`	`features()` Get all characteristics in `EnumSet`
`C.Set<T>`	`filter(Lang.Function<? super T,Boolean> predicate)` Returns an new traversable that contains all elements in the current traversable except that does not pass the test of the filter function specified.
`Lang.Option<T>`	`findOne(Lang.Function<? super T,Boolean> predicate)` Returns an element that matches the predicate specified.
`<R> C.Set<R>`	`flatMap(Lang.Function<? super T,? extends Iterable<? extends R>> mapper)` Returns a traversable consisting of the results of replacing each element of this stream with the contents of the iterable produced by applying the provided mapping function to each element.
`SetBase<T>`	`forEach(Lang.Visitor<? super T> visitor)` Sub class could override this method to implement iterating in parallel.
`protected abstract EnumSet<C.Feature>`	`initFeatures()` Sub class should override this method to provide initial feature set for the feature based instance
`boolean`	`is(C.Feature feature)` Check if this object has a certain `C.Feature`
`protected boolean`	`isImmutable()`
`protected boolean`	`isLazy()`
`protected boolean`	`isMutable()`
`protected boolean`	`isReadOnly()`
`C.Set<T>`	`lazy()` Returns this traversable and try to turn on `C.Feature.LAZY`.
`<R> C.Set<R>`	`map(Lang.Function<? super T,? extends R> mapper)` Returns an new traversable with a mapper function specified.
`boolean`	`noneMatch(Lang.Function<? super T,Boolean> predicate)` Check if no elements matches the predicate specified.
`C.Set<T>`	`onlyIn(Collection<? extends T> col)` Returns a set contains all elements in the `col` collection specified but not in this set
`C.Set<T>`	`parallel()` Returns this traversable and try to turn on `C.Feature.PARALLEL`.
`Lang.Option<T>`	`reduce(Lang.Func2<T,T,T> accumulator)` Performs a reduction on the elements in this traversable, using provided accumulating function.
`<R> R`	`reduce(R identity, Lang.Func2<R,T,R> accumulator)` Performs a reduction on the elements in this traversable, using the provided identity and accumulating function.
`C.Set<T>`	`sequential()` Returns this traversable and turn off `C.Feature.PARALLEL`
`protected SetBase<T>`	`setFeature(C.Feature feature)`
`protected SetBase<T>`	`unsetFeature(C.Feature feature)`
`C.Set<T>`	`with(Collection<? extends T> col)` Returns a set contains all elements in this set and all elements in the `col` collection specified
`C.Set<T>`	`with(T element)` Returns a set contains all elements in this set plus the element specified
`C.Set<T>`	`with(T element, T... elements)` Returns a set contains all elements in this set plus all the elements specified in the parameter list
`C.Set<T>`	`withIn(Collection<? extends T> col)` Returns a set contains only elements in both `col` collection specified and this set
`C.Set<T>`	`without(Collection<? super T> col)` Returns a set contains all elements in this set and not in the `col` collection specified
`C.Set<T>`	`without(T element)` Returns a set contains all elements in the set except the one specified
`C.Set<T>`	`without(T element, T... elements)` Returns a set contains all elements in the set except the ones specified

Methods inherited from class java.util.AbstractSet
equals, hashCode, removeAll

Methods inherited from class java.util.AbstractCollection
add, addAll, clear, contains, containsAll, isEmpty, iterator, remove, retainAll, size, toArray, toArray, toString

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

Methods inherited from interface java.util.Set
add, addAll, clear, contains, containsAll, equals, hashCode, isEmpty, iterator, remove, removeAll, retainAll, size, toArray, toArray

Methods inherited from interface org.osgl.util.C.Traversable
isEmpty, size

- Constructor Detail
  - SetBase
```
public SetBase()
```
- Method Detail
  - parallel
```
public C.Set<T> parallel()
```
    Description copied from interface: C.Traversable
    
    Returns this traversable and try to turn on C.Feature.PARALLEL. If this traversable does not support C.Feature.PARALLEL then return this traversable directly without any state change
    
    Specified by:
    
    parallel in interface C.Set<T>
    
    Specified by:
    
    parallel in interface C.Traversable<T>
    
    Returns:
    this reference with parallel turned on if parallel is supported
  - sequential
```
public C.Set<T> sequential()
```
    Description copied from interface: C.Traversable
    
    Returns this traversable and turn off C.Feature.PARALLEL
    
    Specified by:
    
    sequential in interface C.Set<T>
    
    Specified by:
    
    sequential in interface C.Traversable<T>
    
    Returns:
    this reference with parallel turned off
  - lazy
```
public C.Set<T> lazy()
```
    Description copied from interface: C.Traversable
    
    Returns this traversable and try to turn on C.Feature.LAZY. If lazy is not supported then return this traversable directly without any state change
    
    Specified by:
    
    lazy in interface C.Set<T>
    
    Specified by:
    
    lazy in interface C.Traversable<T>
    
    Returns:
    this reference with lazy turned on if it is supported
  - eager
```
public C.Set<T> eager()
```
    Description copied from interface: C.Traversable
    
    Returns this traversable and turn off C.Feature.LAZY
    
    Specified by:
    
    eager in interface C.Set<T>
    
    Specified by:
    
    eager in interface C.Traversable<T>
    
    Returns:
    this reference with lazy turned off
  - filter
```
public C.Set<T> filter(Lang.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.Traversable
    Returns an new traversable that contains all elements in the current traversable except that does not pass the test of the filter function specified.
```
  Traversable traversable = C.list(-1, 0, 1, -3, 7);  Traversable filtered = traversable.filter(_.F.gt(0));  assertTrue(filtered.contains(1));  assertFalse(filtered.contains(-3)); 
```
    Specified by:
    
    filter in interface C.Set<T>
    
    Specified by:
    
    filter in interface C.Traversable<T>
    
    Parameters:
    predicate - the function that test if the element in the traversable should be kept in the resulting traversable. When applying the filter function to the element, if the result is true then the element will be kept in the resulting traversable.
    
    Returns:
    the new traversable consists of elements passed the filter function test
  - accept
```
public SetBase<T> accept(Lang.Visitor<? super T> visitor)
```
    Description copied from interface: C.Traversable
    
    Iterate this Traversable with a visitor function. This method does not specify the approach to iterate through this structure. The implementation might choose iterate from left to right, or vice versa. It might even choose to split the structure into multiple parts, and iterate through them in parallel
    
    Specified by:
    
    accept in interface C.Set<T>
    
    Specified by:
    
    accept in interface C.Traversable<T>
    
    Parameters:
    visitor - a function that apply to element in this Traversable. The return value of the function is ignored
    
    Returns:
    this Traversable instance for chained call
  - map
```
public <R> C.Set<R> map(Lang.Function<? super T,? extends R> mapper)
```
    Description copied from interface: C.Traversable
    Returns an new traversable with a mapper function specified. The element in the new traversal is the result of the mapper function applied to this traversal element.
```
  Traversable traversable = C.list(23, .NONE, null);  assertEquals(C.list(true, false, false), traversal.map(.F.NOT_NULL));  assertEquals(C.list(“23”, "“, ”"), traversal.map(_.F.AS_STRING)); 
```
    For Lazy Traversable, it must use lazy evaluation for this method. Otherwise it is up to implementation to decide whether use lazy evaluation or not
    Specified by:
    
    map in interface C.Traversable<T>
    
    Type Parameters:
    R - the element type of the new traversal
    Parameters:
    mapper - the function that applied to element in this traversal and returns element in the result traversal
    
    Returns:
    the new traversal contains results of the mapper function applied to this traversal
  - flatMap
```
public <R> C.Set<R> flatMap(Lang.Function<? super T,? extends Iterable<? extends R>> mapper)
```
    Description copied from interface: C.Traversable
    
    Returns a traversable consisting of the results of replacing each element of this stream with the contents of the iterable produced by applying the provided mapping function to each element. If the result of the mapping function is null, this is treated as if the result is an empty traversable.
    
    Specified by:
    
    flatMap in interface C.Traversable<T>
    
    Type Parameters:
    R - the element type of the the new traversable
    Parameters:
    mapper - the function produce an iterable when applied to an element
    
    Returns:
    the new traversable
  - reduce
```
public <R> R reduce(R identity,
           Lang.Func2<R,T,R> accumulator)
```
    Description copied from interface: C.Traversable
    Performs a reduction on the elements in this traversable, using the provided identity and accumulating function. This might be equivalent to:
```
  R result = identity;  for (T element: this traversable) {  result = accumulator.apply(result, element);  }  return result; 
```
    The above shows a typical left side reduce. However depending on the implementation, it might choose another way to do the reduction, including reduction in a parallel way
    Specified by:
    
    reduce in interface C.Traversable<T>
    
    Type Parameters:
    R - the type of identity and the return value
    Parameters:
    identity - the identity value for the accumulating function
    accumulator - the function the combine two values
    
    Returns:
    the result of reduction
  - reduce
```
public Lang.Option<T> reduce(Lang.Func2<T,T,T> accumulator)
```
    Description copied from interface: C.Traversable
    Performs a reduction on the elements in this traversable, using provided accumulating function. This might be equivalent to:
```
  boolean found = false;  T result = null;  for (T element: this traversable) {  if (found) {  result = accumulator.apply(result, element);  } else {  found = true;  result = element;  }  }  return found ? _.some(result) : _.none(); 
```
    The above shows a typical left side reduction. However depending on the implementation, it might choose another way to do the reduction, including reduction in a parallel way
    Specified by:
    
    reduce in interface C.Traversable<T>
    
    Parameters:
    accumulator - the function takes previous accumulating result and the current element being iterated
    
    Returns:
    an option describing the accumulating result or Lang.none() if the structure is empty
  - allMatch
```
public boolean allMatch(Lang.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.Traversable
    
    Check if all elements match the predicate specified
    
    Specified by:
    
    allMatch in interface C.Traversable<T>
    
    Parameters:
    predicate - the function to test the element
    
    Returns:
    true if all elements match the predicate
  - anyMatch
```
public boolean anyMatch(Lang.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.Traversable
    
    Check if any elements matches the predicate specified
    
    Specified by:
    
    anyMatch in interface C.Traversable<T>
    
    Parameters:
    predicate - the function to test the element
    
    Returns:
    true if any element matches the predicate
  - noneMatch
```
public boolean noneMatch(Lang.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.Traversable
    Check if no elements matches the predicate specified. This should be equivalent to:
```
  this.allMatch(_.F.negate(predicate)); 
```
    Specified by:
    
    noneMatch in interface C.Traversable<T>
    
    Parameters:
    predicate - the function to test the element
    
    Returns:
    true if none element matches the predicate
  - findOne
```
public Lang.Option<T> findOne(Lang.Function<? super T,Boolean> predicate)
```
    Description copied from interface: C.Traversable
    
    Returns an element that matches the predicate specified. The interface does not indicate if it should be the first element matches the predicate be returned or in case of parallel computing, whatever element matches found first is returned. It’s all up to the implementation to refine the semantic of this method
    
    Specified by:
    
    findOne in interface C.Traversable<T>
    
    Parameters:
    predicate - the function map element to Boolean
    
    Returns:
    an element in this traversal that matches the predicate or Lang.NONE if no element matches
  - isLazy
```
protected final boolean isLazy()
```
  - isImmutable
```
protected final boolean isImmutable()
```
  - isReadOnly
```
protected final boolean isReadOnly()
```
  - isMutable
```
protected final boolean isMutable()
```
  - forEach
```
public SetBase<T> forEach(Lang.Visitor<? super T> visitor)
                   throws Lang.Break
```
    Sub class could override this method to implement iterating in parallel.
    
    The iterating support partial function visitor by ignoring the NotAppliedException thrown out by visitor's apply method call
    
    Specified by:
    
    forEach in interface C.Set<T>
    
    Specified by:
    
    forEach in interface C.Traversable<T>
    
    Parameters:
    visitor - the visitor
    
    Returns:
    this Traversable instance
    
    Throws:
    
    $.Break - if visitor needs to terminate the iteration
    
    Lang.Break
  - each
```
public SetBase<T> each(Lang.Visitor<? super T> visitor)
```
    Description copied from interface: C.Traversable
    
    Alias of #accept(Osgl.Visitor)
    
    Specified by:
    
    each in interface C.Set<T>
    
    Specified by:
    
    each in interface C.Traversable<T>
    
    Parameters:
    visitor - the visitor to tranverse the elements
    
    Returns:
    this Traversable instance
  - onlyIn
```
public C.Set<T> onlyIn(Collection<? extends T> col)
```
    Description copied from interface: C.Set
    
    Returns a set contains all elements in the col collection specified but not in this set
    
    Specified by:
    
    onlyIn in interface C.Set<T>
    
    Parameters:
    col - the collection in which elements should be included from the result set
    
    Returns:
    a set contains elements only in the col
  - withIn
```
public C.Set<T> withIn(Collection<? extends T> col)
```
    Description copied from interface: C.Set
    
    Returns a set contains only elements in both col collection specified and this set
    
    Specified by:
    
    withIn in interface C.Set<T>
    
    Parameters:
    col - the collection in which elements should be included from the result set
    
    Returns:
    a set contains elements in both col and this set
  - without
```
public C.Set<T> without(Collection<? super T> col)
```
    Description copied from interface: C.Set
    
    Returns a set contains all elements in this set and not in the col collection specified
    
    Specified by:
    
    without in interface C.Set<T>
    
    Parameters:
    col - the collection in which elements should be excluded from the result set
    
    Returns:
    a set contains elements only in this set
  - with
```
public C.Set<T> with(Collection<? extends T> col)
```
    Description copied from interface: C.Set
    
    Returns a set contains all elements in this set and all elements in the col collection specified
    
    Specified by:
    
    with in interface C.Set<T>
    
    Parameters:
    col - the collection in which elements should be included in the result set
    
    Returns:
    a set contains elements in both this set and the collection
  - with
```
public C.Set<T> with(T element)
```
    Description copied from interface: C.Set
    
    Returns a set contains all elements in this set plus the element specified
    
    Specified by:
    
    with in interface C.Set<T>
    
    Parameters:
    element - the new element that will be contained in the returning set
    
    Returns:
    a set as described above
  - with
```
public C.Set<T> with(T element,
            T... elements)
```
    Description copied from interface: C.Set
    
    Returns a set contains all elements in this set plus all the elements specified in the parameter list
    
    Specified by:
    
    with in interface C.Set<T>
    
    Parameters:
    element - the first element to be added into the returning set
    elements - rest elements to be added into the returning set
    
    Returns:
    a set as described above
  - without
```
public C.Set<T> without(T element)
```
    Description copied from interface: C.Set
    
    Returns a set contains all elements in the set except the one specified
    
    Specified by:
    
    without in interface C.Set<T>
    
    Parameters:
    element - the element that should not be in the resulting set
    
    Returns:
    a set without the element specified
  - without
```
public C.Set<T> without(T element,
               T... elements)
```
    Description copied from interface: C.Set
    
    Returns a set contains all elements in the set except the ones specified
    
    Specified by:
    
    without in interface C.Set<T>
    
    Parameters:
    element - the element that should not be in the resulting set
    elements - the array contains elements that should not be in the resulting set
    
    Returns:
    a set without the element specified
  - features_
```
protected final EnumSet<C.Feature> features_()
```
  - initFeatures
```
protected abstract EnumSet<C.Feature> initFeatures()
```
    Sub class should override this method to provide initial feature set for the feature based instance
    
    Returns:
    the initial feature set configuration
  - features
```
public final EnumSet<C.Feature> features()
```
    Description copied from interface: C.Featured
    
    Get all characteristics in EnumSet
    
    Specified by:
    
    features in interface C.Featured
    
    Returns:
    an EnumSet of all characteristics hold by this object
  - is
```
public final boolean is(C.Feature feature)
```
    Description copied from interface: C.Featured
    
    Check if this object has a certain C.Feature
    
    Specified by:
    
    is in interface C.Featured
    
    Parameters:
    feature - the characteristic to be tested
    
    Returns:
    true if this object has the characteristic, or false otherwise
  - setFeature
```
protected SetBase<T> setFeature(C.Feature feature)
```
  - unsetFeature
```
protected SetBase<T> unsetFeature(C.Feature feature)
```

Class SetBase<T>

Nested Class Summary

Nested classes/interfaces inherited from interface org.osgl.util.C.Featured

Constructor Summary

Method Summary

Methods inherited from class java.util.AbstractSet

Methods inherited from class java.util.AbstractCollection

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Set

Methods inherited from interface org.osgl.util.C.Traversable

Constructor Detail

SetBase

Method Detail

parallel

sequential

lazy

eager

filter

accept

map

flatMap

reduce

reduce

allMatch

anyMatch

noneMatch

findOne

isLazy

isImmutable

isReadOnly

isMutable

forEach

each

onlyIn

withIn

without

with

with

with

without

without

features_

initFeatures

features

is

setFeature

unsetFeature