com.aol.cyclops.matcher.builders

Class PatternMatcher

java.lang.Object

com.aol.cyclops.matcher.builders.PatternMatcher

All Implemented Interfaces:

java.util.function.Function

public class PatternMatcher
extends java.lang.Object
implements java.util.function.Function

PatternMatcher supports advanced pattern matching for Java 8 This is an API for creating Case instances and allows new type definitions to be supplied for each Case Features include -cases match by value -cases match by type -cases using predicates inCaseOfXXX caseOfXXX -cases using hamcrest Matchers inMatchOfXXX matchOfXXX -cases as expressions (return value) - inCaseOfXXX, inMatchOfXXX -cases as statements (no return value) - caseOfXXX, matchOfXXX -pre & post variable extraction via Extractor (@see com.aol.cyclops.matcher.Extractors) -match using iterables of predicates or hamcrest Matchers - see caseOfIterable, matchOfIterable, inCaseOfIterable, matchOfIterable -match using tuples of predicates or hamcreate Matchers - see caseOfTuple, matchOfTuple, inCaseOfTuple, inMatchOfTuple - single match (match method) - match many (matchMany) - match against a stream (single match, match many)

Constructor Summary

Constructors

Constructor and Description
PatternMatcher()

Method Summary

Modifier and Type	Method and Description
java.util.Optional<java.lang.Object>	apply(java.lang.Object t)
<T,X> java.util.function.Function<T,java.util.stream.Stream<X>>	asStreamFunction()
<T,X> java.util.function.Function<T,X>	asUnwrappedFunction()
<R,V,T> PatternMatcher	caseOf(Extractor<T,R> ext, java.util.function.Predicate<R> match, Action<V> a)
<V> PatternMatcher	caseOf(java.util.function.Predicate<V> match, Action<V> a)
<V> PatternMatcher	caseOfMany(Action<java.util.List<V>> a, java.util.function.Predicate<V>... predicates) Match against an iterable using supplied predicates.
<T,R,V,V1> PatternMatcher	caseOfPredicates(Two<java.util.function.Predicate<V>,java.util.function.Predicate<V1>> predicates, Action<R> a, Extractor<T,R> extractor) Run both predicates in the supplied tuple against the first two elements of a supplied iterable for matching
<R,V,T> PatternMatcher	caseOfThenExtract(java.util.function.Predicate<V> match, Action<R> a, Extractor<T,R> extractor)
<T,R> PatternMatcher	caseOfTuple(java.lang.Iterable predicates, Action<R> a, Extractor<T,R> extractor) Match against a tuple of predicates (or prototype values, or hamcrest matchers).
<V,X> PatternMatcher	caseOfType(Action<V> a)
<R,T,X,V> PatternMatcher	caseOfType(Extractor<T,R> ext, Action<V> a) Match by type specified in Extractor as input, if user provided type via match, matches the Action (Action extends Consumer) will be executed and provided with the result of the extraction.
<R,V,T,X> PatternMatcher	caseOfValue(R value, Extractor<T,R> extractor, Action<V> a) Match by specified value against the extracted value from user input.
<V,X> PatternMatcher	caseOfValue(V value, Action<V> a) Match by specified value and then execute supplied action.
<R,V,T,X> PatternMatcher	inCaseOf(Extractor<T,R> ext, java.util.function.Predicate<V> match, ActionWithReturn<V,X> a)
<V,X> PatternMatcher	inCaseOf(java.util.function.Predicate<V> match, ActionWithReturn<V,X> a)
<V,X> PatternMatcher	inCaseOfMany(ActionWithReturn<java.util.List<V>,X> a, java.util.function.Predicate<V>... predicates)
<T,V,X> PatternMatcher	inCaseOfManyType(java.util.function.Predicate master, ActionWithReturn<T,X> a, java.util.function.Predicate<V>... predicates)
<T,R,V,V1,X> PatternMatcher	inCaseOfPredicates(Two<java.util.function.Predicate<V>,java.util.function.Predicate<V1>> predicates, ActionWithReturn<R,X> a, Extractor<T,R> extractor)
<T,R,X> PatternMatcher	inCaseOfStream(java.util.stream.Stream<java.util.function.Predicate> predicates, ActionWithReturn<R,X> a, Extractor<T,R> extractor)
<R,T,X> PatternMatcher	inCaseOfThenExtract(java.util.function.Predicate<T> match, ActionWithReturn<R,X> a, Extractor<T,R> extractor)
<V,X> PatternMatcher	inCaseOfType(ActionWithReturn<V,X> a)
<R,V,T,X> PatternMatcher	inCaseOfType(Extractor<T,R> ext, ActionWithReturn<V,X> a)
<V,X> PatternMatcher	inCaseOfValue(V value, ActionWithReturn<V,X> a)
<R,V,T,X> PatternMatcher	inCaseOfValue(V value, Extractor<T,R> ext, ActionWithReturn<V,X> a)
<R,V,T,X> PatternMatcher	inMatchOf(Extractor<T,R> ext, org.hamcrest.Matcher<V> match, ActionWithReturn<V,X> a)
<V,X> PatternMatcher	inMatchOf(org.hamcrest.Matcher<V> match, ActionWithReturn<V,X> a) hamcrest
<V,X> PatternMatcher	inMatchOfMany(ActionWithReturn<java.util.List<V>,X> a, org.hamcrest.Matcher<V>... predicates)
<T,R,V,V1,X> PatternMatcher	inMatchOfMatchers(Two<org.hamcrest.Matcher<V>,org.hamcrest.Matcher<V1>> predicates, ActionWithReturn<R,X> a, Extractor<T,R> extractor)
<T,R,X> PatternMatcher	inMatchOfSeq(java.util.stream.Stream<org.hamcrest.Matcher> predicates, ActionWithReturn<R,X> a, Extractor<T,R> extractor)
<R,T,X> PatternMatcher	inMatchOfThenExtract(org.hamcrest.Matcher<T> match, ActionWithReturn<R,X> a, Extractor<T,R> extractor)
<R> java.util.Optional<R>	match(java.lang.Object... t) Aggregates supplied objects into a List for matching against
<R> java.util.Optional<R>	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
<R,V,T> PatternMatcher	matchOf(Extractor<T,R> ext, org.hamcrest.Matcher<R> match, Action<V> a)
<V> PatternMatcher	matchOf(org.hamcrest.Matcher<V> match, Action<V> a)
<V> PatternMatcher	matchOfMany(Action<java.util.List<V>> a, org.hamcrest.Matcher<V>... predicates) Match against an iterable using supplied hamcrest matchers.
<T,R,V,V1> PatternMatcher	matchOfMatchers(Two<org.hamcrest.Matcher<V>,org.hamcrest.Matcher<V1>> predicates, Action<R> a, Extractor<T,R> extractor) Run both matchers in the supplied tuple against the first two elements of a supplied iterable for matching
<R,V,T> PatternMatcher	matchOfThenExtract(org.hamcrest.Matcher<V> match, Action<V> a, Extractor<T,R> extractor)
<T,R> PatternMatcher	matchOfTuple(java.lang.Iterable predicates, Action<R> a, Extractor<T,R> extractor)
<V,X> PatternMatcher	selectFrom(java.util.stream.Stream<Two<java.util.function.Predicate<V>,java.util.function.Function<V,X>>> stream)
<V,X> PatternMatcher	selectFromChain(java.util.stream.Stream<? extends ChainOfResponsibility<V,X>> stream)
<R> java.util.Optional<R>	unapply(com.aol.cyclops.lambda.api.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

Constructor Detail

PatternMatcher

public PatternMatcher()

Method Detail

asUnwrappedFunction

public <T,X> 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 <T,X> 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<java.lang.Object> apply(java.lang.Object t)

Specified by:

apply in interface java.util.function.Function

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 <R> java.util.Optional<R> match(java.lang.Object... t)

Aggregates supplied objects into a List for matching against

Parameters:

t - Array to match on

Returns:

Matched value wrapped in Optional

unapply

public <R> java.util.Optional<R> unapply(com.aol.cyclops.lambda.api.Decomposable t)

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

Parameters:

t - Object to decompose and match on

Returns:

Matched result wrapped in an Optional

match

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

Parameters:

t - Object to match against supplied cases

Returns:

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

caseOfType

public <R,T,X,V> PatternMatcher caseOfType(Extractor<T,R> ext,
                                           Action<V> a)

Match by type specified in Extractor as input, if user provided type via match, matches the Action (Action extends Consumer) will be executed and provided with the result of the extraction. e.g.

 new PatternMatcher().caseOfType(Person::getAge, (Integer i) -> value = i)
                                .match(new Person(100));
 

This case will be triggered and the action will recieve the age of the Person (100).

Parameters:

ext - will be used to extract a value from the user input to the matcher.

a - A consumer that will accept value from the extractor if user input matches the extractor input type

Returns:

self (type V is not R to allow matching of V against R)

caseOfValue

public <R,V,T,X> PatternMatcher caseOfValue(R value,
                                            Extractor<T,R> extractor,
                                            Action<V> a)

Match by specified value against the extracted value from user input. Data will only be extracted from user input if user input is of a type acceptable to the extractor

 new PatternMatcher.caseOfValue(100, Person::getAge, (Integer i) -> value = i)
                        .match(new Person(100));
 

This case will be triggered and the users age will be extracted, it matches 100 so the action will then be triggered.

Parameters:

value - Value to match against (via equals method)

extractor - will be used to extract a value from the user input to the matcher.

a - A consumer that will accept value from the extractor if user input matches the extractor input type

Returns:

caseOfValue

public <V,X> PatternMatcher caseOfValue(V value,
                                        Action<V> a)

Match by specified value and then execute supplied action.

  new PatternMatcher.caseOfValue(100, (Person p) -> value = p.getAge())
                           .match(new Person(100));
 

Parameters:

value - to compare against, if Objects.equals(value,matching-input) is true, action is triggered

a - Action to be consumed (no return value)

Returns:

new PatternMatcher

caseOfMany

@SafeVarargs
public final <V> PatternMatcher caseOfMany(Action<java.util.List<V>> a,
                                                        java.util.function.Predicate<V>... predicates)

Match against an iterable using supplied predicates. Each predicate will be tested a against a different sequential element in the user supplied iterable. e.g.

        new PatternMatcher()
                .caseOfMany((List<String> list) -> language  = list.get(1) ,
                                                        v -> v.equals("-l") || v.equals("---lang"),v->true)
                .match(asList("-l","java"));
        
        assertThat(language,is("java"));
 

Parameters:

a - Action to execute if case passes

predicates - To match against each sequential element in the iterable

Returns:

New PatternMatcher

matchOfMany

@SafeVarargs
public final <V> PatternMatcher matchOfMany(Action<java.util.List<V>> a,
                                                         org.hamcrest.Matcher<V>... predicates)

Match against an iterable using supplied hamcrest matchers. Each matcher will be tested a against a different sequential element in the user supplied iterable. e.g.

 new PatternMatcher()
        .matchOfMany( (List<String> list) -> language  = list.get(1) ,
                                                equalTo("-l"),any(String.class))
                .match(asList("-l","java"));
        
        assertThat(language,is("java"));
 
 

Parameters:

a - Action to execute if case passes

predicates - To match against each sequential element in the iterable

Returns:

New PatternMatcher

matchOfMatchers

public <T,R,V,V1> PatternMatcher matchOfMatchers(Two<org.hamcrest.Matcher<V>,org.hamcrest.Matcher<V1>> predicates,
                                                 Action<R> a,
                                                 Extractor<T,R> extractor)

Run both matchers in the supplied tuple against the first two elements of a supplied iterable for matching

 new PatternMatcher()
                .matchOfMatchers(tuple( equalTo("-l"),
                                                                 anything()),
                                                        lang -> language  = lang,Extractors.<String>at(1) )
                .match(tuple("-l","java"));
        
        assertThat(language,is("java"));
 

Parameters:

predicates - Tuple of 2 hamcrest matchers

a - Action to be triggered on successful match, will receive data via the extractor

extractor - Extractor to extract data out of incoming iterable after matchers have matched

Returns:

New Pattern Matcher

caseOfPredicates

public <T,R,V,V1> PatternMatcher caseOfPredicates(Two<java.util.function.Predicate<V>,java.util.function.Predicate<V1>> predicates,
                                                  Action<R> a,
                                                  Extractor<T,R> extractor)

Run both predicates in the supplied tuple against the first two elements of a supplied iterable for matching

 new PatternMatcher()
                .caseOfPredicates(tuple( v ->  v.equals("-l") ||  v.equals("---lang"),
                                                                 v->true),
                                                        lang -> language  =lang,Extractors.<String>at(1) )
                .match(tuple("-l","java"));
        
        assertThat(language,is("java"));
 
 

Parameters:

predicates - Tuple of 2 predicates

a - Action to be triggered on successful match, will receive data via the extractor

extractor - Extractor to extract data out of incoming iterable after predicates have matched

Returns:

New Pattern Matcher

caseOfTuple

public <T,R> PatternMatcher caseOfTuple(java.lang.Iterable predicates,
                                        Action<R> a,
                                        Extractor<T,R> extractor)

Match against a tuple of predicates (or prototype values, or hamcrest matchers). Each predicate will match against an element in an iterable.

 new PatternMatcher()
                .caseOfTuple(tuple(p( v ->  v.equals("-l") ||  v.equals("---lang")),
                                                                 p(v->true)),
                                                        lang -> language  =lang,Extractors.<String>at(1) )
                .match(tuple("-l","java"));
        
        assertThat(language,is("java"));
 

Parameters:

predicates - Predicates to match with

a - Action triggered if predicates hold

extractor -

Returns:

matchOfTuple

public <T,R> PatternMatcher matchOfTuple(java.lang.Iterable predicates,
                                         Action<R> a,
                                         Extractor<T,R> extractor)

selectFromChain

public <V,X> PatternMatcher selectFromChain(java.util.stream.Stream<? extends ChainOfResponsibility<V,X>> stream)

selectFrom

public <V,X> PatternMatcher selectFrom(java.util.stream.Stream<Two<java.util.function.Predicate<V>,java.util.function.Function<V,X>>> stream)

inCaseOfManyType

public <T,V,X> PatternMatcher inCaseOfManyType(java.util.function.Predicate master,
                                               ActionWithReturn<T,X> a,
                                               java.util.function.Predicate<V>... predicates)

inCaseOfMany

public <V,X> PatternMatcher inCaseOfMany(ActionWithReturn<java.util.List<V>,X> a,
                                         java.util.function.Predicate<V>... predicates)

inMatchOfMany

public <V,X> PatternMatcher inMatchOfMany(ActionWithReturn<java.util.List<V>,X> a,
                                          org.hamcrest.Matcher<V>... predicates)

inMatchOfMatchers

public <T,R,V,V1,X> PatternMatcher inMatchOfMatchers(Two<org.hamcrest.Matcher<V>,org.hamcrest.Matcher<V1>> predicates,
                                                     ActionWithReturn<R,X> a,
                                                     Extractor<T,R> extractor)

inCaseOfPredicates

public <T,R,V,V1,X> PatternMatcher inCaseOfPredicates(Two<java.util.function.Predicate<V>,java.util.function.Predicate<V1>> predicates,
                                                      ActionWithReturn<R,X> a,
                                                      Extractor<T,R> extractor)

inCaseOfStream

public <T,R,X> PatternMatcher inCaseOfStream(java.util.stream.Stream<java.util.function.Predicate> predicates,
                                             ActionWithReturn<R,X> a,
                                             Extractor<T,R> extractor)

inMatchOfSeq

public <T,R,X> PatternMatcher inMatchOfSeq(java.util.stream.Stream<org.hamcrest.Matcher> predicates,
                                           ActionWithReturn<R,X> a,
                                           Extractor<T,R> extractor)

caseOfType

public <V,X> PatternMatcher caseOfType(Action<V> a)

matchOf

public <V> PatternMatcher matchOf(org.hamcrest.Matcher<V> match,
                                  Action<V> a)

caseOf

public <V> PatternMatcher caseOf(java.util.function.Predicate<V> match,
                                 Action<V> a)

caseOfThenExtract

public <R,V,T> PatternMatcher caseOfThenExtract(java.util.function.Predicate<V> match,
                                                Action<R> a,
                                                Extractor<T,R> extractor)

matchOfThenExtract

public <R,V,T> PatternMatcher matchOfThenExtract(org.hamcrest.Matcher<V> match,
                                                 Action<V> a,
                                                 Extractor<T,R> extractor)

caseOf

public <R,V,T> PatternMatcher caseOf(Extractor<T,R> ext,
                                     java.util.function.Predicate<R> match,
                                     Action<V> a)

matchOf

public <R,V,T> PatternMatcher matchOf(Extractor<T,R> ext,
                                      org.hamcrest.Matcher<R> match,
                                      Action<V> a)

inCaseOfValue

public <V,X> PatternMatcher inCaseOfValue(V value,
                                          ActionWithReturn<V,X> a)

inCaseOfType

public <V,X> PatternMatcher inCaseOfType(ActionWithReturn<V,X> a)

inCaseOf

public <V,X> PatternMatcher inCaseOf(java.util.function.Predicate<V> match,
                                     ActionWithReturn<V,X> a)

inCaseOfThenExtract

public <R,T,X> PatternMatcher inCaseOfThenExtract(java.util.function.Predicate<T> match,
                                                  ActionWithReturn<R,X> a,
                                                  Extractor<T,R> extractor)

inCaseOf

public <R,V,T,X> PatternMatcher inCaseOf(Extractor<T,R> ext,
                                         java.util.function.Predicate<V> match,
                                         ActionWithReturn<V,X> a)

inCaseOfType

public <R,V,T,X> PatternMatcher inCaseOfType(Extractor<T,R> ext,
                                             ActionWithReturn<V,X> a)

inCaseOfValue

public <R,V,T,X> PatternMatcher inCaseOfValue(V value,
                                              Extractor<T,R> ext,
                                              ActionWithReturn<V,X> a)

inMatchOf

public <V,X> PatternMatcher inMatchOf(org.hamcrest.Matcher<V> match,
                                      ActionWithReturn<V,X> a)

hamcrest

inMatchOfThenExtract

public <R,T,X> PatternMatcher inMatchOfThenExtract(org.hamcrest.Matcher<T> match,
                                                   ActionWithReturn<R,X> a,
                                                   Extractor<T,R> extractor)

inMatchOf

public <R,V,T,X> PatternMatcher inMatchOf(Extractor<T,R> ext,
                                          org.hamcrest.Matcher<V> match,
                                          ActionWithReturn<V,X> a)