Functional Interface:

This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.
```
@FunctionalInterface
public interface ContextCalculator
```
Calculates the Contexts applicable for a Contextual.
Implementations of this interface should satisfy the following requirements:
- Context lookups should be fast: lookup methods are likely to be invoked frequently, and should therefore be fast to execute. If determining the current contexts involves a particularly time consuming lookup (database queries, network requests, etc), then such results should be cached ahead of time.
- Context lookups should be thread-safe: lookups will sometimes be performed from "async" threads, and therefore should not access any part of the server only safe for access from a sync context. If necessary, such results should be determined ahead of time and stored in a thread-safe collection for retrieval later.
- Context lookups should not query active contexts: doing so is likely to result in a stack overflow, or thread deadlock. Care should be taken to avoid (indirect) calls to ContextService.contexts() ()}.
Calculators should be registered with the corresponding ContextService using ContextService.registerContextCalculator(ContextCalculator).

Context lookups for instances provided by the platform, (e.g. Player) are delegated to the active ContextService. Plugins wishing to provide contexts for these instances should register calculators here.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods
Modifier and Type	Method	Description
`void`	`accumulateContexts(Cause source, Consumer<Context> accumulator)`	Adds any `Context`s this calculator determines to be applicable to the `target` contextual.
`static ContextCalculator`	`forSingleContext(String key, Function<Cause,String> valueFunction)`	Creates a new `ContextCalculator` that provides a single context.

- Method Detail
  - forSingleContext
```
static ContextCalculator forSingleContext(String key,
                                          Function<Cause,String> valueFunction)
```
    Creates a new ContextCalculator that provides a single context.
    
    Parameters:
    
    key - The key of the context provided by the calculator
    
    valueFunction - The function used to compute the corresponding value for each query. A context will not be "accumulated" if the value returned is null.
    
    Returns:
    
    The resultant calculator
  - accumulateContexts
```
void accumulateContexts(Cause source,
                        Consumer<Context> accumulator)
```
    Adds any Contexts this calculator determines to be applicable to the target contextual.
    Care should be taken to ensure implementations of this method meet the general requirements for ContextCalculator, defined in the class doc.
    
    Calculators should not rely on the state of accumulator during this call, and also shouldn't make calls to remove contexts added by other calculators.
    
    Parameters:
    
    source - The cause stack to draw from for this operation
    
    accumulator - a Set of Contexts this operation will accumulate to.

Interface ContextCalculator

Method Summary

Method Detail

forSingleContext

accumulateContexts