java.lang.Object
- com.apple.foundationdb.record.query.plan.temp.matching.BaseMatcher<T>
- - com.apple.foundationdb.record.query.plan.temp.matching.ComputingMatcher<T,M,R>

Type Parameters:

T - the element type

M - the type that the MatchFunction produces Iterables of

R - the result type

All Implemented Interfaces:

GenericMatcher<BoundMatch<R>>
```
public class ComputingMatcher<T,M,R>
extends BaseMatcher<T>
implements GenericMatcher<BoundMatch<R>>
```
This class implements a GenericMatcher which matches two sets of elements of type T to compute a result of type Iterable<BoundMatch<R>>. Individual elements are matched by means of a MatchFunction which produces an (intermediate) Iterable of type M for each pair of matching elements. In order to match this set against the other set, we need to find matching pairs of elements for each element identified by BaseMatcher.getAliases(). The intermediate iterables of type M produced by the matching function get accumulated across all such matching pairs to produce an Iterable of type R using a MatchAccumulator.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`Iterator<BoundMatch<R>>`	`enumerate(EnumeratingIterator<CorrelationIdentifier> iterator, List<CorrelationIdentifier> otherPermutation)`	Method to enumerate the permutations on this side against the permutation of the other side in order to form matches (bijective mappings between the permutations).
`Iterable<BoundMatch<R>>`	`match()`	Match using the method `enumerate(com.apple.foundationdb.record.query.plan.temp.EnumeratingIterator<com.apple.foundationdb.record.query.plan.temp.CorrelationIdentifier>, java.util.List<com.apple.foundationdb.record.query.plan.temp.CorrelationIdentifier>)` as `EnumerationFunction`.
`static <T,M,R> GenericMatcher<BoundMatch<R>>`	`onAliasDependencies(AliasMap boundAliasesMap, Collection<? extends T> elements, Function<T,CorrelationIdentifier> elementToAliasFn, Function<T,Set<CorrelationIdentifier>> dependsOnFn, Collection<? extends T> otherElements, Function<T,CorrelationIdentifier> otherElementToAliasFn, Function<T,Set<CorrelationIdentifier>> otherDependsOnFn, MatchFunction<T,M> matchFunction, Supplier<MatchAccumulator<M,R>> matchAccumulatorSupplier)`	Static factory method to create a generic matcher using element type `T`.
`protected Iterable<List<CorrelationIdentifier>>`	`otherCombinations(List<CorrelationIdentifier> otherPermutation, int limitInclusive)`
`static <M> MatchAccumulator<M,EnumeratingIterable<M>>`	`productAccumulator()`	Method that returns an `MatchAccumulator` that accumulates `Iterable`s of type `M` and finally produces an `EnumeratingIterable` of type `M` that is the cross product of all elements of the respective `Iterable`s.

Methods inherited from class com.apple.foundationdb.record.query.plan.temp.matching.BaseMatcher
computeAliases, computeAliasToElementMap, computeDependsOnMap, computeDependsOnMapWithAliases, getAliases, getAliasToElementMap, getBoundAliasesMap, getDependsOnMap, getElementToAliasFn, getOtherAliases, getOtherAliasToElementMap, getOtherDependsOnMap, getOtherElementToAliasFn, isIsomorphic, mapDependenciesToOther, match

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

Method Detail

match
```
@Nonnull
public Iterable<BoundMatch<R>> match()
```
Match using the method enumerate(com.apple.foundationdb.record.query.plan.temp.EnumeratingIterator<com.apple.foundationdb.record.query.plan.temp.CorrelationIdentifier>, java.util.List<com.apple.foundationdb.record.query.plan.temp.CorrelationIdentifier>) as EnumerationFunction.

Specified by:

match in interface GenericMatcher<T>

Returns:

an iterable of match results.

otherCombinations

@Nonnull
protected Iterable<List<CorrelationIdentifier>> otherCombinations(List<CorrelationIdentifier> otherPermutation,
                                                                  int limitInclusive)

Specified by:: otherCombinations in class BaseMatcher<T>

enumerate
```
@Nonnull
public Iterator<BoundMatch<R>> enumerate(@Nonnull
                                         EnumeratingIterator<CorrelationIdentifier> iterator,
                                         @Nonnull
                                         List<CorrelationIdentifier> otherPermutation)
```
Method to enumerate the permutations on this side against the permutation of the other side in order to form matches (bijective mappings between the permutations). The match function is called for each pair of elements (for a match attempt). If the match function returns a non-empty Iterable the pair is recorded as a matching pair. We attempt to find a matching pair (one from this side; one from the other side) for each element identified by BaseMatcher.getAliases(). For each individual new such pair that is found, the method MatchAccumulator.accumulate(java.lang.Iterable<M>) is called. Once a set of bindings is established for all aliases in BaseMatcher.getAliases() this method then calls MatchAccumulator.finish() to produce an iterable of type R.

Parameters:

iterator - an enumerating iterable for the permutations on this side

otherPermutation - one permutation (that is not violating dependencies, constraints, etc.) of the other side

Returns:

an Iterator of match results (of type BoundMatch<R>)

onAliasDependencies

@Nonnull
public static <T,M,R> GenericMatcher<BoundMatch<R>> onAliasDependencies(@Nonnull
                                                                                    AliasMap boundAliasesMap,
                                                                                    @Nonnull
                                                                                    Collection<? extends T> elements,
                                                                                    @Nonnull
                                                                                    Function<T,CorrelationIdentifier> elementToAliasFn,
                                                                                    @Nonnull
                                                                                    Function<T,Set<CorrelationIdentifier>> dependsOnFn,
                                                                                    @Nonnull
                                                                                    Collection<? extends T> otherElements,
                                                                                    @Nonnull
                                                                                    Function<T,CorrelationIdentifier> otherElementToAliasFn,
                                                                                    @Nonnull
                                                                                    Function<T,Set<CorrelationIdentifier>> otherDependsOnFn,
                                                                                    @Nonnull
                                                                                    MatchFunction<T,M> matchFunction,
                                                                                    @Nonnull
                                                                                    Supplier<MatchAccumulator<M,R>> matchAccumulatorSupplier)

Static factory method to create a generic matcher using element type T. This method is optimized to the case when the dependsOn sets are already given by sets of CorrelationIdentifiers.

Type Parameters:: T - the element type; M - the type that the MatchFunction produces Iterables of; R - r
Parameters:: boundAliasesMap - a map with previously-bound aliases. Any match that is computed and passed back to the client is an amendment of this map, i.e., every resulting match's AliasMap always contains at least the bindings in this map; elements - a collection of elements of type T representing the domain on this side; elementToAliasFn - a function to map elements of type T on this side to correlation identifiers; dependsOnFn - a function from elements to sets of correlation identifiers describing the depends-on relationships between the elements on this side; otherElements - a collection of other elements representing the domain on the other side; otherElementToAliasFn - a function to map elements of type T on the other side to correlation identifiers; otherDependsOnFn - a function from elements to sets of correlation identifiers describing the depends-on relationships between the other elements; matchFunction - a match function that computes an Iterable of type M for each matching pair of elements; matchAccumulatorSupplier - a supplier to create accumulators to accumulate intermediate Iterables of type M into an Iterable of type R
Returns:: a newly created generic matcher of type BoundMatch<R>

productAccumulator
```
@Nonnull
public static <M> MatchAccumulator<M,EnumeratingIterable<M>> productAccumulator()
```
Method that returns an MatchAccumulator that accumulates Iterables of type M and finally produces an EnumeratingIterable of type M that is the cross product of all elements of the respective Iterables.

Type Parameters:

M - the type the MatchFunction produces Iterables of

Returns:

a newly created accumulator

Class ComputingMatcher<T,​M,​R>

Method Summary

Methods inherited from class com.apple.foundationdb.record.query.plan.temp.matching.BaseMatcher

Methods inherited from class java.lang.Object

Method Detail

match

otherCombinations

enumerate

onAliasDependencies

productAccumulator

Class ComputingMatcher<T,M,R>