org.osgl.util

Interface C.ReversibleSequence<T>

Type Parameters:

T - the element type

All Superinterfaces:

C.Featured, C.Sequence<T>, C.Traversable<T>, Iterable<T>

All Known Subinterfaces:

C.List<T>, C.ListOrSet<T>

All Known Implementing Classes:

C.Array, CompositeList, FastStr, ListBase, Osgl.Val, Osgl.Var, Str, StrBase

Enclosing class:

C

public static interface C.ReversibleSequence<T>
extends C.Sequence<T>

A bidirectional sequence which can be iterated from tail to head

Nested Class Summary

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

C.Featured.Factory

Method Summary

Modifier and Type	Method and Description
C.ReversibleSequence<T>	accept(Osgl.Function<? super T,?> visitor) Iterate this Traversable with a visitor function.
C.ReversibleSequence<T>	acceptLeft(Osgl.Function<? super T,?> visitor) Iterate through this sequence from head to tail with the visitor function specified
C.ReversibleSequence<T>	acceptRight(Osgl.Function<? super T,?> visitor) Iterate through this sequence from tail to head with the visitor function specified
C.ReversibleSequence<T>	append(C.ReversibleSequence<T> seq) Returns an new reversible sequence contains all elements in this sequence followed by all elements in the specified reverse sequence
C.ReversibleSequence<T>	append(T t) Returns a sequence consists of all elements of this sequence followed by the element specified.
C.ReversibleSequence<T>	drop(int n) Returns a Sequence consisting of the elements from this Sequence except the first n if number n is positive and the Sequence contains more than n elements
C.ReversibleSequence<T>	dropWhile(Osgl.Function<? super T,Boolean> predicate) Returns a Sequence consisting of the elements from this sequence with leading elements dropped until the predicate returns true
C.ReversibleSequence<T>	each(Osgl.Function<? super T,?> visitor) Alias of C.Traversable.accept(Osgl.Function)
C.ReversibleSequence<T>	eager() Returns this traversable and make sure C.Feature.LAZY is unset
C.ReversibleSequence<T>	filter(Osgl.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.
Osgl.Option<T>	findLast(Osgl.Function<? super T,Boolean> predicate) Apply the predicate specified to the element of this sequence from tail to head.
<R> C.ReversibleSequence<R>	flatMap(Osgl.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.
C.ReversibleSequence<T>	forEach(Osgl.Function<? super T,?> visitor) Alias of C.Traversable.accept(Osgl.Function)
C.ReversibleSequence<T>	head(int n) Alias of C.Sequence.take(int)
T	last() Returns the last element from this Sequence
C.ReversibleSequence<T>	lazy() Returns this traversable and make sure C.Feature.LAZY is set
<R> C.ReversibleSequence<R>	map(Osgl.Function<? super T,? extends R> mapper) Returns an new traversable with a mapper function specified.
C.ReversibleSequence<T>	parallel() Returns this traversable and make sure C.Feature.PARALLEL is set
C.ReversibleSequence<T>	prepend(C.ReversibleSequence<T> seq) Returns an new reversible sequence contains all elements in specified reversible sequence followed by all elements in this sequence
C.ReversibleSequence<T>	prepend(T t) Returns a sequence consists of the element specified followed by all elements of this sequence.
Osgl.Option<T>	reduceRight(Osgl.Func2<T,T,T> accumulator) Run reduction from tail to head.
<R> R	reduceRight(R identity, Osgl.Func2<R,T,R> accumulator) Run reduction from tail side.
C.ReversibleSequence<T>	reverse() Returns an new Sequence that reverse this Sequence.
Iterator<T>	reverseIterator() Returns an Iterator iterate the sequence from tail to head
C.ReversibleSequence<T>	sequential() Returns this traversable and make sure C.Feature.PARALLEL is unset
C.ReversibleSequence<T>	tail() Returns the rest part of the Sequence except the first element
C.ReversibleSequence<T>	tail(int n) Returns a Sequence consisting the last n elements from this Sequence if number n is positive and the Sequence contains more than n elements
C.ReversibleSequence<T>	take(int n) Returns a Sequence consisting the first n elements from this Sequence if number n is positive and the Sequence contains more than n elements
C.ReversibleSequence<T>	takeWhile(Osgl.Function<? super T,Boolean> predicate) Returns an new Sequence that takes the head of this Sequence until the predicate evaluate to false:
<T2> C.ReversibleSequence<Osgl.T2<T,T2>>	zip(C.ReversibleSequence<T2> rseq)
<T2> C.ReversibleSequence<Osgl.T2<T,T2>>	zipAll(C.ReversibleSequence<T2> rseq, T def1, T2 def2)

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

append, append, append, append, count, findFirst, first, head, prepend, prepend, prepend, prepend, reduce, reduce, reduceLeft, reduceLeft, zip, zipAll, zipWithIndex

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

allMatch, anyMatch, findOne, isEmpty, noneMatch, size

Methods inherited from interface java.lang.Iterable

forEach, iterator, spliterator

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

features, is

Method Detail

parallel

C.ReversibleSequence<T> parallel()

Returns this traversable and make sure C.Feature.PARALLEL is set

Specified by:

parallel in interface C.Sequence<T>

Specified by:

parallel in interface C.Traversable<T>

Returns:

this reference with parallel turned on

sequential

C.ReversibleSequence<T> sequential()

Returns this traversable and make sure C.Feature.PARALLEL is unset

Specified by:

sequential in interface C.Sequence<T>

Specified by:

sequential in interface C.Traversable<T>

Returns:

this reference with parallel turned off

lazy

C.ReversibleSequence<T> lazy()

Returns this traversable and make sure C.Feature.LAZY is set

Specified by:

lazy in interface C.Sequence<T>

Specified by:

lazy in interface C.Traversable<T>

Returns:

this reference with lazy turned on

eager

C.ReversibleSequence<T> eager()

Returns this traversable and make sure C.Feature.LAZY is unset

Specified by:

eager in interface C.Sequence<T>

Specified by:

eager in interface C.Traversable<T>

Returns:

this reference with lazy turned off

head

C.ReversibleSequence<T> head(int n)

Alias of C.Sequence.take(int)

Specified by:

head in interface C.Sequence<T>

Parameters:

n - the number of elements to be taken into the return sequence

Returns:

an new reversible sequence contains the first n elements in this sequence

tail

C.ReversibleSequence<T> tail()

Returns the rest part of the Sequence except the first element

Specified by:

tail in interface C.Sequence<T>

Returns:

an new reversible sequence contains all elements in this sequence except the first element

See Also:

C.Sequence.head(), tail(int)

take

C.ReversibleSequence<T> take(int n)

Returns a Sequence consisting the first n elements from this Sequence if number n is positive and the Sequence contains more than n elements

If this Sequence contains less than n elements, then a Sequence consisting the whole elements of this Sequence is returned. Note it might return this Sequence itself if the Sequence is immutable.

If the number n is zero, then an empty Sequence is returned in reverse order

If the number n is negative, then the last -n elements from this Sequence is returned in an new Sequence, or throw UnsupportedOperationException if this operation is not supported

     Sequence seq = C.list(1, 2, 3, 4);
     assertEquals(C.list(1, 2), seq.take(2));
     assertEquals(C.list(1, 2, 3, 4), seq.take(100));
     assertEquals(C.list(), seq.take(0));
     assertEquals(C.list(3, 4), seq.take(-2));
     assertEquals(C.list(1, 2, 3, 4), seq.take(-200));
 

Specified by:

take in interface C.Sequence<T>

Parameters:

n - specify the number of elements to be taken from the head of this Sequence

Returns:

an new reversible sequence contains the first n elements in this sequence

See Also:

C.Sequence.head(int)

takeWhile

C.ReversibleSequence<T> takeWhile(Osgl.Function<? super T,Boolean> predicate)

Returns an new Sequence that takes the head of this Sequence until the predicate evaluate to false:

     C.Sequence seq = C.list(1, 2, 3, 4, 5, 4, 3, 2, 1);
     assertEquals(C.list(C.list(1, 2, 3), seq.takeWhile(_.F.lt(4)));
     assertEquals(C.list(C.list(1, 2, 3, 3, 2, 1), seq.filter(_.F.lt(4)));
 

Specified by:

takeWhile in interface C.Sequence<T>

Parameters:

predicate - specify which the elements in this Sequence will put into the new Sequence

Returns:

an new reversible sequence contains the elements in this sequence until predicate evaluate to false

drop

C.ReversibleSequence<T> drop(int n)

Returns a Sequence consisting of the elements from this Sequence except the first n if number n is positive and the Sequence contains more than n elements

If this Sequence contains less than n elements, then an empty Sequence is returned

If the number n is zero, then a copy of this Sequence or this Sequence itself is returned depending on the implementation

If the number n is negative, then either IllegalArgumentException should be thrown out if this sequence is not C.Feature.LIMITED or it drop -n element starts from the tail side

     C.Sequence seq = C.list(1, 2, 3, 4, 5);
     assertEquals(C.list(3, 4, 5), seq.drop(2));
     assertEquals(C.list(1, 2, 3, 4, 5), seq.drop(0));
     assertEquals(C.list(), seq.drop(100));
 

Note this method does NOT modify the current sequence, instead it returns an new sequence structure containing the elements as required

Specified by:

drop in interface C.Sequence<T>

Parameters:

n - specify the number of elements to be taken from the head of this Sequence or the -n number of elements to be taken from the tail of this sequence if n is an negative number

Returns:

a reversible sequence without the first n number of elements

dropWhile

C.ReversibleSequence<T> dropWhile(Osgl.Function<? super T,Boolean> predicate)

Description copied from interface: C.Sequence

Returns a Sequence consisting of the elements from this sequence with leading elements dropped until the predicate returns true

      Sequence seq = C.list(1, 2, 3, 4, 3, 2, 1);
      assertTrue(C.list(), seq.dropWhile(_.F.gt(100)));
      assertTrue(C.list(4, 3, 2, 1), seq.dropWhile(_.F.lt(3)));
 

Note this method does NOT modify the current sequence, instead it returns an new sequence structure containing the elements as required

Specified by:

dropWhile in interface C.Sequence<T>

Parameters:

predicate - the function that check if drop operation should stop

Returns:

the sequence after applying the drop operations

filter

C.ReversibleSequence<T> filter(Osgl.Function<? super T,Boolean> predicate)

Description copied from interface: C.Sequence

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.Sequence<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:

An new Sequence consists of elements that passed the predicate

append

C.ReversibleSequence<T> append(T t)

Returns a sequence consists of all elements of this sequence followed by the element specified.

an immutable Sequence must return an new Sequence; while a mutable Sequence implementation might append the element to this sequence instance directly

Specified by:

append in interface C.Sequence<T>

Parameters:

t - the element to be appended to this sequence

Returns:

a reversible sequence contains this seq's element followed by t

append

C.ReversibleSequence<T> append(C.ReversibleSequence<T> seq)

Returns an new reversible sequence contains all elements in this sequence followed by all elements in the specified reverse sequence

Parameters:

seq - another reversible sequence

Returns:

an new reversible sequence contains both seq's elements

prepend

C.ReversibleSequence<T> prepend(T t)

Returns a sequence consists of the element specified followed by all elements of this sequence.

an immutable Sequence must return an new Sequence; while a mutable Sequence implementation might append the element to this sequence instance directly

Specified by:

prepend in interface C.Sequence<T>

Parameters:

t - the element to be appended to this sequence

Returns:

a reversible sequence contains by t followed this seq's element

prepend

C.ReversibleSequence<T> prepend(C.ReversibleSequence<T> seq)

Returns an new reversible sequence contains all elements in specified reversible sequence followed by all elements in this sequence

Parameters:

seq - another reversible sequence

Returns:

an new reversible sequence contains both seq's elements

last

T last()
throws UnsupportedOperationException,
       NoSuchElementException

Returns the last element from this Sequence

Returns:

the last element

Throws:

UnsupportedOperationException - if this Sequence is not limited

NoSuchElementException - if the Sequence is empty

Since:

0.2

See Also:

C.Traversable.isEmpty(), C.Feature.LIMITED, C.Featured.is(org.osgl.util.C.Feature)

tail

C.ReversibleSequence<T> tail(int n)
                      throws UnsupportedOperationException,
                             IndexOutOfBoundsException

Returns a Sequence consisting the last n elements from this Sequence if number n is positive and the Sequence contains more than n elements

If this Sequence contains less than n elements, then a Sequence consisting the whole elements of this Sequence is returned. Note it might return this Sequence itself if the Sequence is immutable.

If the number n is zero, then an empty Sequence is returned in reverse order

If the number n is negative, then the first -n elements from this Sequence is returned in an new Sequence

     Sequence seq = C1.list(1, 2, 3, 4);
     assertEquals(C1.list(3, 4), seq.tail(2));
     assertEquals(C1.list(1, 2, 3, 4), seq.tail(100));
     assertEquals(C1.list(), seq.tail(0));
     assertEquals(C1.list(1, 2, 3), seq.tail(-3));
     assertEquals(C1.list(1, 2, 3, 4), seq.tail(-200));
 

This method does not mutate the underline container

Parameters:

n - specify the number of elements to be taken from the tail of this Sequence

Returns:

a Sequence consisting of the last n elements from this Sequence

Throws:

UnsupportedOperationException - if the traversal is unlimited or empty

IndexOutOfBoundsException - if n is greater than the size of this Sequence

Since:

0.2

See Also:

C.Feature.LIMITED, C.Featured.is(org.osgl.util.C.Feature)

reverse

C.ReversibleSequence<T> reverse()
                         throws UnsupportedOperationException

Returns an new Sequence that reverse this Sequence.

Returns:

a reversed Sequence

Throws:

UnsupportedOperationException - if this Sequence is unlimited

Since:

0.2

See Also:

C.Feature.LIMITED, C.Featured.is(org.osgl.util.C.Feature)

reverseIterator

Iterator<T> reverseIterator()

Returns an Iterator iterate the sequence from tail to head

Returns:

the iterator

Since:

0.2

reduceRight

<R> R reduceRight(R identity,
                  Osgl.Func2<R,T,R> accumulator)

Run reduction from tail side. This is equivalent to:

      R result = identity;
      for (T element: this sequence.reverse()) {
          result = accumulator.apply(result, element);
      }
      return result;
 

Type Parameters:

R - the accumulation result

Parameters:

identity - the initial value

accumulator - the function performs accumulation from T an R to anthoer R

Returns:

the aggregation result

Since:

0.2

See Also:

C.Sequence.reduce(Object, Osgl.Func2)

reduceRight

Osgl.Option<T> reduceRight(Osgl.Func2<T,T,T> accumulator)

Run reduction from tail to head. This is equivalent to

      if (isEmpty()) {
          return _.none();
      }
      T result = last();
      for (T element: this sequence.reverse.tail()) {
          result = accumulator.apply(result, element);
      }
      return _.some(result);
 

Parameters:

accumulator - the function accumulate each element to the final result

Returns:

an $.Option describing the accumulating result

Since:

0.2

findLast

Osgl.Option<T> findLast(Osgl.Function<? super T,Boolean> predicate)

Apply the predicate specified to the element of this sequence from tail to head. Stop at the element that returns true, and returns an $.Option describing the element. If none of the element applications in the sequence returns true then Osgl.none() is returned

Parameters:

predicate - the function map the element to Boolean

Returns:

an option describe the first element matches the predicate or Osgl.none()

Since:

0.2

map

<R> C.ReversibleSequence<R> map(Osgl.Function<? super T,? extends R> mapper)

Description copied from interface: C.Sequence

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.Sequence<T>

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:

a Sequence of R that are mapped from this sequence

flatMap

<R> C.ReversibleSequence<R> flatMap(Osgl.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. 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.Sequence<T>

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:

a ReversibleSequence of R type element that are mapped from this sequences

Since:

0.2

accept

C.ReversibleSequence<T> accept(Osgl.Function<? 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.Sequence<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

each

C.ReversibleSequence<T> each(Osgl.Function<? super T,?> visitor)

Description copied from interface: C.Traversable

Alias of C.Traversable.accept(Osgl.Function)

Specified by:

each in interface C.Sequence<T>

Specified by:

each in interface C.Traversable<T>

Parameters:

visitor - the visitor to tranverse the elements

Returns:

this Traversable instance

forEach

C.ReversibleSequence<T> forEach(Osgl.Function<? super T,?> visitor)

Description copied from interface: C.Traversable

Alias of C.Traversable.accept(Osgl.Function)

Specified by:

forEach in interface C.Sequence<T>

Specified by:

forEach in interface C.Traversable<T>

Parameters:

visitor - the visitor function

Returns:

this Traversable instance

acceptLeft

C.ReversibleSequence<T> acceptLeft(Osgl.Function<? super T,?> visitor)

Description copied from interface: C.Sequence

Iterate through this sequence from head to tail with the visitor function specified

Specified by:

acceptLeft in interface C.Sequence<T>

Parameters:

visitor - the function to visit elements in this sequence

Returns:

this sequence

See Also:

C.Traversable.accept(Osgl.Function), acceptRight(Osgl.Function)

acceptRight

C.ReversibleSequence<T> acceptRight(Osgl.Function<? super T,?> visitor)

Iterate through this sequence from tail to head with the visitor function specified

Parameters:

visitor - the function to visit elements in this sequence

Returns:

this sequence

Since:

0.2

See Also:

C.Traversable.accept(Osgl.Function), C.Sequence.acceptLeft(Osgl.Function)

zip

<T2> C.ReversibleSequence<Osgl.T2<T,T2>> zip(C.ReversibleSequence<T2> rseq)

zipAll

<T2> C.ReversibleSequence<Osgl.T2<T,T2>> zipAll(C.ReversibleSequence<T2> rseq,
                                                T def1,
                                                T2 def2)