Decorator

Register a custom macro.

Macros persist in a static property for the worker lifetime and apply to every subsequent call on the macroable class.

Mix another object into the class.

Delegates to macro() for each method; registered macros persist in a static property for the worker lifetime.

Check if macro is registered.

Flush the existing macros.

Clears worker-wide macros; concurrent coroutines may resolve different methods depending on timing.

Dynamically handle calls to the class.

Dynamically create a pending feature interaction.

Create a new driver decorator instance.

Feature values are memoized in the current coroutine's PennantState instead of on the decorator, which every request in the worker shares.

Discover and register the application's feature classes.

On a shared store, the definitions persist for the worker lifetime and add every discovered class to all() for subsequent requests.

Define an initial feature flag state resolver.

On a shared store, the definition persists for the worker lifetime and applies to every subsequent request.

Resolve the feature value.

Determine if the resolver can handle the scope.

Reflect the function that resolves a feature.

Determine if the function's scope parameter accepts the scope.

Determine if the type can handle the scope.

Determine if the resolver accepts null scope.

Retrieve the names of all defined features.

Retrieve the names of all stored features.

Get multiple feature flag values.

Get multiple feature flag values that are missing.

Resolve the values of the given features through their before hooks or the driver, and memoize them.

Normalize the features to load.

Retrieve a feature flag's value.

Resolve the before hook value.

Set a feature flag's value.

Set multiple feature flag values.

Create a pending feature interaction for the global scope, ignoring the default scope resolver.

Activate the feature for everyone.

Deactivate the feature for everyone.

Set a feature flag's value for all scopes.

Delete a feature flag's value.

Purge the given feature from storage.

Retrieve the feature's name.

Retrieve the map of feature names to their implementations.

Retrieve the feature's class.

Retrieve the defined features for the given scope.

Resolve the feature name and ensure it is defined.

Determine if the feature should be dynamically defined.

Dynamically define the feature.

Determine if the given feature has a before hook.

Retrieve the implementation feature class for the given feature name.

Resolve the name for a feature class.

Resolve the scope.

Determine if a feature's value is in the cache for the given scope.

Put the given feature's value into the cache.

Remove the given feature's value from the cache.

Forget the values memoized for the connection if its current transaction rolls back.

Values read or written inside a transaction may never be committed.

Get the name of the connection the driver currently uses, or an empty string for drivers without one.

Get the key of the store's current partition.

Retrieve the default scope.

Flush the in-memory cache of feature values.

Only the current coroutine's values are flushed.

Invalidate shared cached database values for the current partition.

Get the underlying feature driver.

Set the container instance used by the decorator.

On a shared store, the container persists for the worker lifetime.