com.aol.cyclops.matcher.builders

Class RecursiveMatcherInstance<T,X>

java.lang.Object

com.aol.cyclops.matcher.builders.RecursiveMatcherInstance<T,X>

Type Parameters:

T -

X -

All Implemented Interfaces:

java.util.function.Function<T,java.util.Optional<X>>

public class RecursiveMatcherInstance<T,X>
extends java.lang.Object
implements java.util.function.Function<T,java.util.Optional<X>>

Pattern Matching builder instance

Constructor Summary

Constructors

Constructor and Description
RecursiveMatcherInstance()

Method Summary

Modifier and Type	Method and Description
java.util.Optional<X>	apply(java.lang.Object t)
java.util.function.Function<T,java.util.stream.Stream<X>>	asStreamFunction()
java.util.function.Function<T,X>	asUnwrappedFunction()
Cases<T,X,TypedFunction<T,X>>	cases()
java.util.Optional<X>	match(java.lang.Object... t) Aggregates supplied objects into a List for matching against
java.util.Optional<X>	match(java.lang.Object t)
<R> java.util.stream.Stream<R>	matchFromStream(java.util.stream.Stream s) Each input element can generated a single matched value
<R> java.util.stream.Stream<R>	matchMany(java.lang.Object t)
<R> java.util.stream.Stream<R>	matchManyFromStream(java.util.stream.Stream s) Each input element can generated multiple matched values
java.util.Optional<X>	unapply(com.aol.cyclops.objects.Decomposable decomposableObject) Immediately decompose the supplied parameter and pass it to the PatternMatcher for matching
CheckTypeAndValues<X>	when() Create a builder for Matching on Case classes.
<T,R> CheckTypeAndValues.AndMembersMatchBuilder<T,R>	whenIsType(java.lang.Class<T> t, java.util.function.Function<T,R> f)
<T,R> CheckTypeAndValues.AndMembersMatchBuilder<T,R>	whenIsType(TypedFunction<T,R> a) Build a Case where we will check if user input matches the Type of the input params on the ActionWithReturn instance supplied If it does, the ActionWithReturn will be executed (applied) to get the result of the Match.

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

Constructor Detail

RecursiveMatcherInstance

public RecursiveMatcherInstance()

Method Detail

cases

public final Cases<T,X,TypedFunction<T,X>> cases()

when

public final CheckTypeAndValues<X> when()

Create a builder for Matching on Case classes. This is the closest builder for Scala / ML style pattern matching. Case classes can be constructed succintly in Java with Lombok or jADT e.g.

 \@Value final class CaseClass implements Decomposable { int field1; String field2;}
 

Use with static imports from the Predicates class to get wildcards via '__' or ANY() And to apply nested / recursive matching via Predicates.type( ).with ( ) Match disaggregated elements by type, value, JDK 8 Predicate or Hamcrest Matcher

Returns:

Case Class style Pattern Matching Builder

whenIsType

public final <T,R> CheckTypeAndValues.AndMembersMatchBuilder<T,R> whenIsType(TypedFunction<T,R> a)

Build a Case where we will check if user input matches the Type of the input params on the ActionWithReturn instance supplied If it does, the ActionWithReturn will be executed (applied) to get the result of the Match. isType will attempt to match on the type of the supplied Case class. If it matches the Case class will be 'decomposed' via it's unapply method and the Case will then attempt to match on each of the elements that make up the Case class. If the Case class implements Decomposable, that interface and it's unapply method will be used. Otherwise in Extractors it is possible to register Decomposition Funcitons that will unapply Case classes from other sources (e.g. javaslang, jADT or even Scala). If no Decomposition Function has been registered, reflection will be used to call an unapply method on the Case class if it exists.

Parameters:

a - Action from which the Predicate (by param type) and Function will be extracted to build a Pattern Matching case

Returns:

Next step in Case builder

See Also:

Extractors.decompose(), Extractors.registerDecompositionFunction(java.lang.Class<T>, java.util.function.Function<T, R>)

whenIsType

public final <T,R> CheckTypeAndValues.AndMembersMatchBuilder<T,R> whenIsType(java.lang.Class<T> t,
                                                                             java.util.function.Function<T,R> f)

asUnwrappedFunction

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

Returns:

Pattern Matcher as function that will return the 'unwrapped' result when apply is called. i.e. Optional#get will be called.

asStreamFunction

public java.util.function.Function<T,java.util.stream.Stream<X>> asStreamFunction()

Returns:

Pattern Matcher as a function that will return a Stream of results

apply

public java.util.Optional<X> apply(java.lang.Object t)

Specified by:

apply in interface java.util.function.Function<T,java.util.Optional<X>>

matchManyFromStream

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

Each input element can generated multiple matched values

Parameters:

s - Stream of data to match against (input to matcher)

Returns:

Stream of values from matched cases

matchMany

public <R> java.util.stream.Stream<R> matchMany(java.lang.Object t)

Parameters:

t - input to match against - can generate multiple values

Returns:

Stream of values from matched cases for the input

matchFromStream

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

Each input element can generated a single matched value

Parameters:

s - Stream of data to match against (input to matcher)

Returns:

Stream of matched values, one case per input value can match

match

public java.util.Optional<X> 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

match

public java.util.Optional<X> match(java.lang.Object t)

Parameters:

t - Object to match against supplied cases

Returns:

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

unapply

public java.util.Optional<X> unapply(com.aol.cyclops.objects.Decomposable decomposableObject)

Immediately decompose the supplied parameter and pass it to the PatternMatcher for matching

Parameters:

decomposableObject - Object to match on after decomposed via unapply method

Returns:

Matching result