Cases (simple-react 1.0.0-RC2.2 API)

java.lang.Object
- com.aol.cyclops.internal.matcher2.Cases<T,R>

Type Parameters:

T - Input type for predicate and function (action)

R - Return type for function (action) which is executed if the predicate tests positive

X - Type of Function - cyclops pattern matching builders use ActionWithReturn which is serialisable and retains type info

All Implemented Interfaces:

java.util.function.Function<T,Maybe<R>>
```
public class Cases<T,R>
extends java.lang.Object
implements java.util.function.Function<T,Maybe<R>>
```
Represents an ordered list of pattern matching cases.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Cases<T,R>`	`append(int index, Case<T,R> pattern)` Append an individual case with supplied Cases inserted at index
`Maybe<R>`	`apply(T t)`
`<T1,X> java.util.function.Function<T1,X>`	`asUnwrappedFunction()` assertThat(Cases.of(Case.of(input->true,input->"hello")).asUnwrappedFunction().apply(10),is("hello"));
`org.pcollections.PStack<Case<T,R>>`	`get()`
`<R> Maybe<R>`	`match(java.lang.Object... t)` Aggregates supplied objects into a List for matching against
`<R> Maybe<R>`	`match(T t)`
`<R> java.util.concurrent.CompletableFuture<Maybe<R>>`	`matchAsync(java.util.concurrent.Executor executor, java.lang.Object... t)` Aggregates supplied objects into a List for matching asynchronously against
`<R> java.util.stream.Stream<R>`	`matchFromStream(java.util.stream.Stream<T> s)` Each input element can generated a single matched value
`<R> java.util.concurrent.CompletableFuture<java.util.stream.Stream<R>>`	`matchFromStreamAsync(java.util.concurrent.Executor executor, java.util.stream.Stream<T> s)` Execute matchFromStream asynchronously
`static <T,R> Cases<T,R>`	`of(Case<T,R>... cazes)` Construct a Cases instance from an array Pattern Matching Cases Will execute sequentially when Match is called.
`static <T,R> Cases<T,R>`	`ofList(java.util.List<Case<T,R>> cases)` Construct a Cases instance from a list of Pattern Matching Cases Will execute sequentially when Match is called.
`static <T,R> Cases<T,R>`	`ofPStack(org.pcollections.PStack<Case<T,R>> cases)` Construct a Cases instance from a persistent stack of Pattern Matching Cases Will execute sequentially when Match is called.
`int`	`size()`
`java.util.stream.Stream<Case<T,R>>`	`stream()`
`<R> Maybe<R>`	`unapply(Decomposable t)` Decomposes the supplied input via it's unapply method Provides a List to the Matcher of values to match on

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

Methods inherited from interface java.util.function.Function
andThen, compose, identity

Method Detail

get

public org.pcollections.PStack<Case<T,R>> get()

ofPStack
```
public static <T,R> Cases<T,R> ofPStack(org.pcollections.PStack<Case<T,R>> cases)
```
Construct a Cases instance from a persistent stack of Pattern Matching Cases Will execute sequentially when Match is called.

Parameters:

cases - Persistent Stack of cases to build Cases from

Returns:

New Cases instance (sequential)

ofList
```
public static <T,R> Cases<T,R> ofList(java.util.List<Case<T,R>> cases)
```
Construct a Cases instance from a list of Pattern Matching Cases Will execute sequentially when Match is called.

Parameters:

cases - Persistent Stack of cases to build Cases from

Returns:

New Cases instance (sequential)

of
```
public static <T,R> Cases<T,R> of(Case<T,R>... cazes)
```
Construct a Cases instance from an array Pattern Matching Cases Will execute sequentially when Match is called.

Parameters:

cazes - Array of cases to build Cases instance from

Returns:

New Cases instance (sequential)

append
```
public Cases<T,R> append(int index,
                         Case<T,R> pattern)
```
Append an individual case with supplied Cases inserted at index

Parameters:

index - to insert supplied cases in new Case instance

pattern - Cases to append / insert

Returns:

New Cases with current and supplied cases

See Also:

#merge

size
```
public int size()
```
Returns:

number of cases

asUnwrappedFunction

public <T1,X> java.util.function.Function<T1,X> asUnwrappedFunction()

 
 
 assertThat(Cases.of(Case.of(input->true,input->"hello")).asUnwrappedFunction().apply(10),is("hello"));

Returns:: A function that when applied will return the 'unwrapped' result of matching. I.e. Optional#get will have been called.

apply
```
public Maybe<R> apply(T t)
```
Specified by:

apply in interface java.util.function.Function<T,Maybe<R>>

matchFromStream

public <R> java.util.stream.Stream<R> matchFromStream(java.util.stream.Stream<T> s)

Each input element can generated a single matched value

 
                List<String> results = Cases
                        .of(Case.of((Integer input) -> 10 == input, input -> "hello"),
                                        Case.of((Integer input) -> 10 == input, input -> "ignored"),
                                        Case.of(input -> 11 == input, input -> "world"))
                        .<String> matchFromStream(Stream.of(1, 11, 10)).toList(); 

        assertThat(results.size(), is(2));
        assertThat(results, hasItem("hello"));
        assertThat(results, hasItem("world"));

Parameters:: s - Stream of data to match against (input to matcher)
Returns:: Stream of matched values, one case per input value can match

matchFromStreamAsync

public <R> java.util.concurrent.CompletableFuture<java.util.stream.Stream<R>> matchFromStreamAsync(java.util.concurrent.Executor executor,
                                                                                                   java.util.stream.Stream<T> s)

Execute matchFromStream asynchronously

Parameters:

executor - executor Executor to execute task asynchronously

s - Stream of data

Returns:

Results

See Also:

 List<String> results = Cases
			.of(Case.of((Integer input) -> 10 == input, input -> "hello"),
					Case.of((Integer input) -> 10 == input, input -> "ignored"),
					Case.of(input -> 11 == input, input -> "world"))
			.<String> matchFromStreamAsync(ForkJoinPool.commonPool(),Stream.of(1, 11, 10)).join().toList(); 
  
	assertThat(results.size(), is(2));
	assertThat(results, hasItem("hello"));
	assertThat(results, hasItem("world"));

match

public <R> Maybe<R> match(java.lang.Object... t)

Aggregates supplied objects into a List for matching against

 assertThat(Cases.of(Case.of((List<Integer> input) -> input.size()==3, input -> "hello"),
                        Case.of((List<Integer> input) -> input.size()==2, input -> "ignored"),
                        Case.of((List<Integer> input) -> input.size()==1, input -> "world")).match(1,2,3).get(),is("hello"));

Parameters:: t - Array to match on
Returns:: Matched value wrapped in Optional

matchAsync

public <R> java.util.concurrent.CompletableFuture<Maybe<R>> matchAsync(java.util.concurrent.Executor executor,
                                                                       java.lang.Object... t)

Aggregates supplied objects into a List for matching asynchronously against

 assertThat(Cases.of(Case.of((List<Integer> input) -> input.size()==3, input -> "hello"),
                        Case.of((List<Integer> input) -> input.size()==2, input -> "ignored"),
                        Case.of((List<Integer> input) -> input.size()==1, input -> "world"))
                        .matchAsync(ForkJoinPool.commonPool(),1,2,3).join().get(),is("hello"));

Parameters:: executor - Executor to perform the async task; t - Array to match on
Returns:: Matched value wrapped in CompletableFuture & Optional

unapply

public <R> Maybe<R> unapply(Decomposable t)

Decomposes the supplied input via it's unapply method Provides a List to the Matcher of values to match on

 assertThat(Cases.of(Case.of((List input) -> input.size()==3, input -> "hello"),
                        Case.of((List input) -> input.size()==2, input -> "ignored"),
                        Case.of((List input) -> input.size()==1, input -> "world"))
                        .unapply(new MyClass(1,"hello")).get(),is("ignored"));
                                        
        \@Value static class MyClass implements Decomposable{ int value; String name; }

Parameters:: t - Object to decompose and match on
Returns:: Matched result wrapped in an Optional

match
```
public <R> Maybe<R> match(T t)
```
Parameters:

t - Object to match against supplied cases

Returns:

Value returned from matched case (if present) otherwise Optional.empty()

stream

public java.util.stream.Stream<Case<T,R>> stream()

Class Cases<T,R>

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.function.Function

Method Detail

get

ofPStack

ofList

of

append

size

asUnwrappedFunction

apply

matchFromStream

matchFromStreamAsync

match

matchAsync

unapply

match

stream