com.aol.cyclops.matcher.builders

Class MatchingInstance<T,X>

java.lang.Object

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

Type Parameters:

T -

X -

All Implemented Interfaces:

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

public class MatchingInstance<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
MatchingInstance()

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
ElementCase<X>	when() Create a builder for Matching against a provided Object as is (i.e.
<V> CaseBuilder.InMatchOfBuilder<V,X>	whenAllMatch(org.hamcrest.Matcher<V>... matchers) Build a Case which is triggered when all of the supplied Hamcrest Matchers holds
<V> CaseBuilder.InMatchOfBuilder<V,X>	whenAnyMatch(org.hamcrest.Matcher<V>... matchers) Build a Case which is triggered when any of the supplied Hamcrest Matchers holds
<V> CaseBuilder.InMatchOfBuilder<V,X>	whenIsMatch(org.hamcrest.Matcher<V> match) Build a Case which is triggered when the supplied Hamcrest Matcher holds
<V> CaseBuilder.InCaseOfBuilder<V>	whenIsTrue(java.util.function.Predicate<V> match) Build a Case which is triggered when the supplied Predicate holds
<T,R> MatchingInstance<T,R>	whenIsType(TypedFunction<T,R> a) Create a completed Case which is triggered when matching input is of the same type (T) as the input parameter to ActionWithReturn.
<V> Step<V,X>	whenIsValue(V value) Build a Case which is triggered when the user input matches the supplied Value (via Objects.equals)
<V> CaseBuilder.InMatchOfBuilder<V,X>	whenNoneMatch(org.hamcrest.Matcher<V>... matchers) Build a Case which is triggered when none of the supplied Hamcrest Matchers holds

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

MatchingInstance

public MatchingInstance()

Method Detail

cases

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

when

public final ElementCase<X> when()

Create a builder for Matching against a provided Object as is (i.e. the Steps this builder provide assume you don't wish to disaggregate it and match on it's decomposed parts separately). Allows matching by type, value, JDK 8 Predicate, or Hamcrest Matcher

Returns:

Simplex Element based Pattern Matching Builder

whenIsValue

public <V> Step<V,X> whenIsValue(V value)

Build a Case which is triggered when the user input matches the supplied Value (via Objects.equals)

Parameters:

value - will be compared to input provided in match method

Returns:

Next step in this Case builder

whenIsType

public <T,R> MatchingInstance<T,R> whenIsType(TypedFunction<T,R> a)

Create a completed Case which is triggered when matching input is of the same type (T) as the input parameter to ActionWithReturn. The ActionWithReturn will then be executed and the result returned as the match result.

Parameters:

a - Action for the new Case, Predicate for the Case will be created from the input type to the Action.

Returns:

Completed Case

whenIsTrue

public <V> CaseBuilder.InCaseOfBuilder<V> whenIsTrue(java.util.function.Predicate<V> match)

Build a Case which is triggered when the supplied Predicate holds

Parameters:

match - Predicate which will trigger this case

Returns:

Next Step in the Case Builder process

whenIsMatch

public <V> CaseBuilder.InMatchOfBuilder<V,X> whenIsMatch(org.hamcrest.Matcher<V> match)

Build a Case which is triggered when the supplied Hamcrest Matcher holds

Parameters:

match - Hamcrest Matcher that will trigger this case

Returns:

Next Step in the Case Builder process

whenAllMatch

@SafeVarargs
public final <V> CaseBuilder.InMatchOfBuilder<V,X> whenAllMatch(org.hamcrest.Matcher<V>... matchers)

Build a Case which is triggered when all of the supplied Hamcrest Matchers holds

Parameters:

matchers - Hamcrest Matchers that will trigger this case

Returns:

Next Step in the Case Builder process

whenAnyMatch

@SafeVarargs
public final <V> CaseBuilder.InMatchOfBuilder<V,X> whenAnyMatch(org.hamcrest.Matcher<V>... matchers)

Build a Case which is triggered when any of the supplied Hamcrest Matchers holds

Parameters:

matchers - Hamcrest Matchers that will trigger this case

Returns:

Next Step in the Case Builder process

whenNoneMatch

@SafeVarargs
public final <V> CaseBuilder.InMatchOfBuilder<V,X> whenNoneMatch(org.hamcrest.Matcher<V>... matchers)

Build a Case which is triggered when none of the supplied Hamcrest Matchers holds

Parameters:

matchers - Hamcrest Matchers that will trigger this case

Returns:

Next Step in the Case Builder process

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