FuzzySearch (fuzzywuzzy 1.2.0 API)

java.lang.Object
- me.xdrop.fuzzywuzzy.FuzzySearch

```
public class FuzzySearch
extends Object
```
FuzzySearch facade class

Constructor Summary

Constructors
Constructor Description

FuzzySearch()

Constructors
Constructor	Description
`FuzzySearch()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static List<ExtractedResult>`	`extractAll(String query, Collection<String> choices)`	Creates a list of `ExtractedResult` which contain all the choices with their corresponding score where higher is more similar
`static List<ExtractedResult>`	`extractAll(String query, Collection<String> choices, int cutoff)`	Creates a list of `ExtractedResult` which contain all the choices with their corresponding score where higher is more similar
`static List<ExtractedResult>`	`extractAll(String query, Collection<String> choices, Applicable func)`	Creates a list of `ExtractedResult` which contain all the choices with their corresponding score where higher is more similar
`static List<ExtractedResult>`	`extractAll(String query, Collection<String> choices, Applicable func, int cutoff)`	Creates a list of `ExtractedResult` which contain all the choices with their corresponding score where higher is more similar
`static <T> List<BoundExtractedResult<T>>`	`extractAll(String query, Collection<T> choices, ToStringFunction<T> toStringFunction)`	Creates a list of `ExtractedResult` which contain all the choices with their corresponding score where higher is more similar
`static <T> List<BoundExtractedResult<T>>`	`extractAll(String query, Collection<T> choices, ToStringFunction<T> toStringFunction, int cutoff)`	Creates a list of `ExtractedResult` which contain all the choices with their corresponding score where higher is more similar
`static <T> List<BoundExtractedResult<T>>`	`extractAll(String query, Collection<T> choices, ToStringFunction<T> toStringFunction, Applicable func)`	Creates a list of `ExtractedResult` which contain all the choices with their corresponding score where higher is more similar
`static <T> List<BoundExtractedResult<T>>`	`extractAll(String query, Collection<T> choices, ToStringFunction<T> toStringFunction, Applicable func, int cutoff)`	Creates a list of `ExtractedResult` which contain all the choices with their corresponding score where higher is more similar
`static ExtractedResult`	`extractOne(String query, Collection<String> choices)`	Find the single best match above a score in a list of choices.
`static ExtractedResult`	`extractOne(String query, Collection<String> choices, Applicable func)`	Find the single best match above a score in a list of choices.
`static <T> BoundExtractedResult<T>`	`extractOne(String query, Collection<T> choices, ToStringFunction<T> toStringFunction)`	Find the single best match above a score in a list of choices.
`static <T> BoundExtractedResult<T>`	`extractOne(String query, Collection<T> choices, ToStringFunction<T> toStringFunction, Applicable func)`	Find the single best match above a score in a list of choices.
`static List<ExtractedResult>`	`extractSorted(String query, Collection<String> choices)`	Creates a sorted list of `ExtractedResult` which contain all the choices with their corresponding score where higher is more similar
`static List<ExtractedResult>`	`extractSorted(String query, Collection<String> choices, int cutoff)`	Creates a sorted list of `ExtractedResult` which contain all the choices with their corresponding score where higher is more similar
`static List<ExtractedResult>`	`extractSorted(String query, Collection<String> choices, Applicable func)`	Creates a sorted list of `ExtractedResult` which contain all the choices with their corresponding score where higher is more similar
`static List<ExtractedResult>`	`extractSorted(String query, Collection<String> choices, Applicable func, int cutoff)`	Creates a sorted list of `ExtractedResult` which contain all the choices with their corresponding score where higher is more similar
`static <T> List<BoundExtractedResult<T>>`	`extractSorted(String query, Collection<T> choices, ToStringFunction<T> toStringFunction)`	Creates a sorted list of `ExtractedResult` which contain all the choices with their corresponding score where higher is more similar
`static <T> List<BoundExtractedResult<T>>`	`extractSorted(String query, Collection<T> choices, ToStringFunction<T> toStringFunction, int cutoff)`	Creates a sorted list of `ExtractedResult` which contain all the choices with their corresponding score where higher is more similar
`static <T> List<BoundExtractedResult<T>>`	`extractSorted(String query, Collection<T> choices, ToStringFunction<T> toStringFunction, Applicable func)`	Creates a sorted list of `ExtractedResult` which contain all the choices with their corresponding score where higher is more similar
`static <T> List<BoundExtractedResult<T>>`	`extractSorted(String query, Collection<T> choices, ToStringFunction<T> toStringFunction, Applicable func, int cutoff)`	Creates a sorted list of `ExtractedResult` which contain all the choices with their corresponding score where higher is more similar
`static List<ExtractedResult>`	`extractTop(String query, Collection<String> choices, int limit)`	Creates a sorted list of `ExtractedResult` which contain the top @param limit most similar choices
`static List<ExtractedResult>`	`extractTop(String query, Collection<String> choices, int limit, int cutoff)`	Creates a sorted list of `ExtractedResult` which contain the top @param limit most similar choices
`static List<ExtractedResult>`	`extractTop(String query, Collection<String> choices, Applicable func, int limit)`	Creates a sorted list of `ExtractedResult` which contain the top @param limit most similar choices
`static List<ExtractedResult>`	`extractTop(String query, Collection<String> choices, Applicable func, int limit, int cutoff)`	Creates a sorted list of `ExtractedResult` which contain the top @param limit most similar choices
`static <T> List<BoundExtractedResult<T>>`	`extractTop(String query, Collection<T> choices, ToStringFunction<T> toStringFunction, int limit)`	Creates a sorted list of `ExtractedResult` which contain the top @param limit most similar choices
`static <T> List<BoundExtractedResult<T>>`	`extractTop(String query, Collection<T> choices, ToStringFunction<T> toStringFunction, int limit, int cutoff)`	Creates a sorted list of `ExtractedResult` which contain the top @param limit most similar choices
`static <T> List<BoundExtractedResult<T>>`	`extractTop(String query, Collection<T> choices, ToStringFunction<T> toStringFunction, Applicable func, int limit)`	Creates a sorted list of `ExtractedResult` which contain the top @param limit most similar choices
`static <T> List<BoundExtractedResult<T>>`	`extractTop(String query, Collection<T> choices, ToStringFunction<T> toStringFunction, Applicable func, int limit, int cutoff)`	Creates a sorted list of `ExtractedResult` which contain the top @param limit most similar choices
`static int`	`partialRatio(String s1, String s2)`	Inconsistent substrings lead to problems in matching.
`static int`	`partialRatio(String s1, String s2, ToStringFunction<String> stringFunction)`	Inconsistent substrings lead to problems in matching.
`static int`	`ratio(String s1, String s2)`	Calculates a Levenshtein simple ratio between the strings.
`static int`	`ratio(String s1, String s2, ToStringFunction<String> stringFunction)`	Calculates a Levenshtein simple ratio between the strings.
`static int`	`tokenSetPartialRatio(String s1, String s2)`	Splits the strings into tokens and computes intersections and remainders between the tokens of the two strings.
`static int`	`tokenSetPartialRatio(String s1, String s2, ToStringFunction<String> stringFunction)`	Splits the strings into tokens and computes intersections and remainders between the tokens of the two strings.
`static int`	`tokenSetRatio(String s1, String s2)`	Splits the strings into tokens and computes intersections and remainders between the tokens of the two strings.
`static int`	`tokenSetRatio(String s1, String s2, ToStringFunction<String> stringFunction)`	Splits the strings into tokens and computes intersections and remainders between the tokens of the two strings.
`static int`	`tokenSortPartialRatio(String s1, String s2)`	Find all alphanumeric tokens in the string and sort those tokens and then take ratio of resulting joined strings.
`static int`	`tokenSortPartialRatio(String s1, String s2, ToStringFunction<String> stringFunction)`	Find all alphanumeric tokens in the string and sort those tokens and then take ratio of resulting joined strings.
`static int`	`tokenSortRatio(String s1, String s2)`	Find all alphanumeric tokens in the string and sort those tokens and then take ratio of resulting joined strings.
`static int`	`tokenSortRatio(String s1, String s2, ToStringFunction<String> stringFunction)`	Find all alphanumeric tokens in the string and sort those tokens and then take ratio of resulting joined strings.
`static int`	`weightedRatio(String s1, String s2)`	Calculates a weighted ratio between the different algorithms for best results
`static int`	`weightedRatio(String s1, String s2, ToStringFunction<String> stringFunction)`	Calculates a weighted ratio between the different algorithms for best results

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

Constructor Detail
- FuzzySearch
```
public FuzzySearch()
```

Method Detail

ratio
```
public static int ratio(String s1,
                        String s2)
```
Calculates a Levenshtein simple ratio between the strings. This is indicates a measure of similarity

Parameters:

s1 - Input string

s2 - Input string

Returns:

The simple ratio

ratio
```
public static int ratio(String s1,
                        String s2,
                        ToStringFunction<String> stringFunction)
```
Calculates a Levenshtein simple ratio between the strings. This is indicates a measure of similarity

Parameters:

s1 - Input string

s2 - Input string

stringFunction - Functor which transforms strings before calculating the ratio

Returns:

The simple ratio

partialRatio
```
public static int partialRatio(String s1,
                               String s2)
```
Inconsistent substrings lead to problems in matching. This ratio uses a heuristic called "best partial" for when two strings are of noticeably different lengths.

Parameters:

s1 - Input string

s2 - Input string

Returns:

The partial ratio

partialRatio
```
public static int partialRatio(String s1,
                               String s2,
                               ToStringFunction<String> stringFunction)
```
Inconsistent substrings lead to problems in matching. This ratio uses a heuristic called "best partial" for when two strings are of noticeably different lengths.

Parameters:

s1 - Input string

s2 - Input string

stringFunction - Functor which transforms strings before calculating the ratio

Returns:

The partial ratio

tokenSortPartialRatio
```
public static int tokenSortPartialRatio(String s1,
                                        String s2)
```
Find all alphanumeric tokens in the string and sort those tokens and then take ratio of resulting joined strings.

Parameters:

s1 - Input string

s2 - Input string

Returns:

The partial ratio of the strings

tokenSortPartialRatio
```
public static int tokenSortPartialRatio(String s1,
                                        String s2,
                                        ToStringFunction<String> stringFunction)
```
Find all alphanumeric tokens in the string and sort those tokens and then take ratio of resulting joined strings.

Parameters:

s1 - Input string

s2 - Input string

stringFunction - Functor which transforms strings before calculating the ratio

Returns:

The partial ratio of the strings

tokenSortRatio
```
public static int tokenSortRatio(String s1,
                                 String s2)
```
Find all alphanumeric tokens in the string and sort those tokens and then take ratio of resulting joined strings.

Parameters:

s1 - Input string

s2 - Input string

Returns:

The full ratio of the strings

tokenSortRatio
```
public static int tokenSortRatio(String s1,
                                 String s2,
                                 ToStringFunction<String> stringFunction)
```
Find all alphanumeric tokens in the string and sort those tokens and then take ratio of resulting joined strings.

Parameters:

s1 - Input string

s2 - Input string

stringFunction - Functor which transforms strings before calculating the ratio

Returns:

The full ratio of the strings

tokenSetRatio
```
public static int tokenSetRatio(String s1,
                                String s2)
```
Splits the strings into tokens and computes intersections and remainders between the tokens of the two strings. A comparison string is then built up and is compared using the simple ratio algorithm. Useful for strings where words appear redundantly.

Parameters:

s1 - Input string

s2 - Input string

Returns:

The ratio of similarity

tokenSetRatio
```
public static int tokenSetRatio(String s1,
                                String s2,
                                ToStringFunction<String> stringFunction)
```
Splits the strings into tokens and computes intersections and remainders between the tokens of the two strings. A comparison string is then built up and is compared using the simple ratio algorithm. Useful for strings where words appear redundantly.

Parameters:

s1 - Input string

s2 - Input string

stringFunction - Functor which transforms strings before calculating the ratio

Returns:

The ratio of similarity

tokenSetPartialRatio
```
public static int tokenSetPartialRatio(String s1,
                                       String s2)
```
Splits the strings into tokens and computes intersections and remainders between the tokens of the two strings. A comparison string is then built up and is compared using the simple ratio algorithm. Useful for strings where words appear redundantly.

Parameters:

s1 - Input string

s2 - Input string

Returns:

The ratio of similarity

tokenSetPartialRatio
```
public static int tokenSetPartialRatio(String s1,
                                       String s2,
                                       ToStringFunction<String> stringFunction)
```
Splits the strings into tokens and computes intersections and remainders between the tokens of the two strings. A comparison string is then built up and is compared using the simple ratio algorithm. Useful for strings where words appear redundantly.

Parameters:

s1 - Input string

s2 - Input string

stringFunction - Functor which transforms strings before calculating the ratio

Returns:

The ratio of similarity

weightedRatio
```
public static int weightedRatio(String s1,
                                String s2)
```
Calculates a weighted ratio between the different algorithms for best results

Parameters:

s1 - Input string

s2 - Input string

Returns:

The ratio of similarity

weightedRatio
```
public static int weightedRatio(String s1,
                                String s2,
                                ToStringFunction<String> stringFunction)
```
Calculates a weighted ratio between the different algorithms for best results

Parameters:

s1 - Input string

s2 - Input string

stringFunction - Functor which transforms strings before calculating the ratio

Returns:

The ratio of similarity

extractTop

public static List<ExtractedResult> extractTop(String query,
                                               Collection<String> choices,
                                               Applicable func,
                                               int limit,
                                               int cutoff)

Creates a sorted list of ExtractedResult which contain the top @param limit most similar choices

Parameters:: query - The query string; choices - A list of choices; func - The scoring function
Returns:: A list of the results

extractTop
```
public static List<ExtractedResult> extractTop(String query,
                                               Collection<String> choices,
                                               int limit,
                                               int cutoff)
```
Creates a sorted list of ExtractedResult which contain the top @param limit most similar choices

Parameters:

query - The query string

choices - A list of choices

limit - Limits the number of results and speeds up the search (k-top heap sort) is used

cutoff - Rejects any entries with score below this

Returns:

A list of the results

extractTop

public static List<ExtractedResult> extractTop(String query,
                                               Collection<String> choices,
                                               Applicable func,
                                               int limit)

Creates a sorted list of ExtractedResult which contain the top @param limit most similar choices

Parameters:: query - The query string; choices - A list of choices; func - The scoring function; limit - The number of results to return
Returns:: A list of the results

extractTop

public static List<ExtractedResult> extractTop(String query,
                                               Collection<String> choices,
                                               int limit)

Creates a sorted list of ExtractedResult which contain the top @param limit most similar choices

Parameters:: query - The query string; choices - A list of choices; limit - The number of results to return
Returns:: A list of the results

extractSorted

public static List<ExtractedResult> extractSorted(String query,
                                                  Collection<String> choices,
                                                  Applicable func)

Creates a sorted list of ExtractedResult which contain all the choices with their corresponding score where higher is more similar

Parameters:: query - The query string; choices - A list of choices; func - The scoring function
Returns:: A list of the results

extractSorted

public static List<ExtractedResult> extractSorted(String query,
                                                  Collection<String> choices,
                                                  Applicable func,
                                                  int cutoff)

Creates a sorted list of ExtractedResult which contain all the choices with their corresponding score where higher is more similar

Parameters:: query - The query string; choices - A list of choices; func - The scoring function; cutoff - Keep only scores above cutoff
Returns:: A list of the results

extractSorted
```
public static List<ExtractedResult> extractSorted(String query,
                                                  Collection<String> choices)
```
Creates a sorted list of ExtractedResult which contain all the choices with their corresponding score where higher is more similar

Parameters:

query - The query string

choices - A list of choices

Returns:

A list of the results

extractSorted

public static List<ExtractedResult> extractSorted(String query,
                                                  Collection<String> choices,
                                                  int cutoff)

Creates a sorted list of ExtractedResult which contain all the choices with their corresponding score where higher is more similar

Parameters:: query - The query string; choices - A list of choices; cutoff - Keep only scores above cutoff
Returns:: A list of the results

extractAll

public static List<ExtractedResult> extractAll(String query,
                                               Collection<String> choices,
                                               Applicable func)

Creates a list of ExtractedResult which contain all the choices with their corresponding score where higher is more similar

Parameters:: query - The query string; choices - A list of choices; func - The scoring function
Returns:: A list of the results

extractAll

public static List<ExtractedResult> extractAll(String query,
                                               Collection<String> choices,
                                               Applicable func,
                                               int cutoff)

Creates a list of ExtractedResult which contain all the choices with their corresponding score where higher is more similar

Parameters:: query - The query string; choices - A list of choices; func - The scoring function; cutoff - Keep only scores above cutoff
Returns:: A list of the results

extractAll
```
public static List<ExtractedResult> extractAll(String query,
                                               Collection<String> choices)
```
Creates a list of ExtractedResult which contain all the choices with their corresponding score where higher is more similar

Parameters:

query - The query string

choices - A list of choices

Returns:

A list of the results

extractAll
```
public static List<ExtractedResult> extractAll(String query,
                                               Collection<String> choices,
                                               int cutoff)
```
Creates a list of ExtractedResult which contain all the choices with their corresponding score where higher is more similar

Parameters:

query - The query string

choices - A list of choices

cutoff - Keep only scores above cutoff

Returns:

A list of the results

extractOne

public static ExtractedResult extractOne(String query,
                                         Collection<String> choices,
                                         Applicable func)

Find the single best match above a score in a list of choices.

Parameters:: query - A string to match against; choices - A list of choices; func - Scoring function
Returns:: An object containing the best match and it's score

extractOne
```
public static ExtractedResult extractOne(String query,
                                         Collection<String> choices)
```
Find the single best match above a score in a list of choices.

Parameters:

query - A string to match against

choices - A list of choices

Returns:

An object containing the best match and it's score

extractTop

public static <T> List<BoundExtractedResult<T>> extractTop(String query,
                                                           Collection<T> choices,
                                                           ToStringFunction<T> toStringFunction,
                                                           Applicable func,
                                                           int limit,
                                                           int cutoff)

Creates a sorted list of ExtractedResult which contain the top @param limit most similar choices

Parameters:: query - The query string; choices - A list of choices; toStringFunction - The ToStringFunction to be applied to all choices.; func - The scoring function
Returns:: A list of the results

extractTop

public static <T> List<BoundExtractedResult<T>> extractTop(String query,
                                                           Collection<T> choices,
                                                           ToStringFunction<T> toStringFunction,
                                                           int limit,
                                                           int cutoff)

Creates a sorted list of ExtractedResult which contain the top @param limit most similar choices

Parameters:: query - The query string; choices - A list of choices; toStringFunction - The ToStringFunction to be applied to all choices.; limit - Limits the number of results and speeds up the search (k-top heap sort) is used; cutoff - Rejects any entries with score below this
Returns:: A list of the results

extractTop

public static <T> List<BoundExtractedResult<T>> extractTop(String query,
                                                           Collection<T> choices,
                                                           ToStringFunction<T> toStringFunction,
                                                           Applicable func,
                                                           int limit)

Creates a sorted list of ExtractedResult which contain the top @param limit most similar choices

Parameters:: query - The query string; choices - A list of choices; toStringFunction - The ToStringFunction to be applied to all choices.; func - The scoring function; limit - The number of results to return
Returns:: A list of the results

extractTop

public static <T> List<BoundExtractedResult<T>> extractTop(String query,
                                                           Collection<T> choices,
                                                           ToStringFunction<T> toStringFunction,
                                                           int limit)

Creates a sorted list of ExtractedResult which contain the top @param limit most similar choices

Parameters:: query - The query string; choices - A list of choices; toStringFunction - The ToStringFunction to be applied to all choices.; limit - The number of results to return
Returns:: A list of the results

extractSorted

public static <T> List<BoundExtractedResult<T>> extractSorted(String query,
                                                              Collection<T> choices,
                                                              ToStringFunction<T> toStringFunction,
                                                              Applicable func)

Creates a sorted list of ExtractedResult which contain all the choices with their corresponding score where higher is more similar

Parameters:: query - The query string; choices - A list of choices; toStringFunction - The ToStringFunction to be applied to all choices.; func - The scoring function
Returns:: A list of the results

extractSorted

public static <T> List<BoundExtractedResult<T>> extractSorted(String query,
                                                              Collection<T> choices,
                                                              ToStringFunction<T> toStringFunction,
                                                              Applicable func,
                                                              int cutoff)

Creates a sorted list of ExtractedResult which contain all the choices with their corresponding score where higher is more similar

Parameters:: query - The query string; choices - A list of choices; toStringFunction - The ToStringFunction to be applied to all choices.; func - The scoring function; cutoff - Keep only scores above cutoff
Returns:: A list of the results

extractSorted

public static <T> List<BoundExtractedResult<T>> extractSorted(String query,
                                                              Collection<T> choices,
                                                              ToStringFunction<T> toStringFunction)

Creates a sorted list of ExtractedResult which contain all the choices with their corresponding score where higher is more similar

Parameters:: query - The query string; choices - A list of choices; toStringFunction - The ToStringFunction to be applied to all choices.
Returns:: A list of the results

extractSorted

public static <T> List<BoundExtractedResult<T>> extractSorted(String query,
                                                              Collection<T> choices,
                                                              ToStringFunction<T> toStringFunction,
                                                              int cutoff)

Creates a sorted list of ExtractedResult which contain all the choices with their corresponding score where higher is more similar

Parameters:: query - The query string; choices - A list of choices; toStringFunction - The ToStringFunction to be applied to all choices.; cutoff - Keep only scores above cutoff
Returns:: A list of the results

extractAll

public static <T> List<BoundExtractedResult<T>> extractAll(String query,
                                                           Collection<T> choices,
                                                           ToStringFunction<T> toStringFunction,
                                                           Applicable func)

Creates a list of ExtractedResult which contain all the choices with their corresponding score where higher is more similar

Parameters:: query - The query string; choices - A list of choices; toStringFunction - The ToStringFunction to be applied to all choices.; func - The scoring function
Returns:: A list of the results

extractAll

public static <T> List<BoundExtractedResult<T>> extractAll(String query,
                                                           Collection<T> choices,
                                                           ToStringFunction<T> toStringFunction,
                                                           Applicable func,
                                                           int cutoff)

Creates a list of ExtractedResult which contain all the choices with their corresponding score where higher is more similar

Parameters:: query - The query string; choices - A list of choices; toStringFunction - The ToStringFunction to be applied to all choices.; func - The scoring function; cutoff - Keep only scores above cutoff
Returns:: A list of the results

extractAll

public static <T> List<BoundExtractedResult<T>> extractAll(String query,
                                                           Collection<T> choices,
                                                           ToStringFunction<T> toStringFunction)

Creates a list of ExtractedResult which contain all the choices with their corresponding score where higher is more similar

Parameters:: query - The query string; choices - A list of choices; toStringFunction - The ToStringFunction to be applied to all choices.
Returns:: A list of the results

extractAll

public static <T> List<BoundExtractedResult<T>> extractAll(String query,
                                                           Collection<T> choices,
                                                           ToStringFunction<T> toStringFunction,
                                                           int cutoff)

Creates a list of ExtractedResult which contain all the choices with their corresponding score where higher is more similar

Parameters:: query - The query string; choices - A list of choices; toStringFunction - The ToStringFunction to be applied to all choices.; cutoff - Keep only scores above cutoff
Returns:: A list of the results

extractOne

public static <T> BoundExtractedResult<T> extractOne(String query,
                                                     Collection<T> choices,
                                                     ToStringFunction<T> toStringFunction,
                                                     Applicable func)

Find the single best match above a score in a list of choices.

Parameters:: query - A string to match against; choices - A list of choices; toStringFunction - The ToStringFunction to be applied to all choices.; func - Scoring function
Returns:: An object containing the best match and it's score

extractOne

public static <T> BoundExtractedResult<T> extractOne(String query,
                                                     Collection<T> choices,
                                                     ToStringFunction<T> toStringFunction)

Find the single best match above a score in a list of choices.

Parameters:: query - A string to match against; choices - A list of choices; toStringFunction - The ToStringFunction to be applied to all choices.
Returns:: An object containing the best match and it's score

Class FuzzySearch

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

FuzzySearch

Method Detail

ratio

ratio

partialRatio

partialRatio

tokenSortPartialRatio

tokenSortPartialRatio

tokenSortRatio

tokenSortRatio

tokenSetRatio

tokenSetRatio

tokenSetPartialRatio

tokenSetPartialRatio

weightedRatio

weightedRatio

extractTop

extractTop

extractTop

extractTop

extractSorted

extractSorted

extractSorted

extractSorted

extractAll

extractAll

extractAll

extractAll

extractOne

extractOne

extractTop

extractTop

extractTop

extractTop

extractSorted

extractSorted

extractSorted

extractSorted

extractAll

extractAll

extractAll

extractAll

extractOne

extractOne