Application

Get the class name of the first parameter of the given Closure.

Get the class names of the first parameter of the given Closure, including union types.

Get the class names / types of the parameters of the given Closure.

Get the class names / types of the return type of the given Closure.

Define a contextual binding.

Define a contextual binding based on an attribute.

Determine if the given abstract type has been bound.

Determine if the given abstract type has been bound.

The facade system calls has() before get() to check if a service is resolvable. With auto-singleton semantics, any concrete class can be resolved, so has() must return true for existing classes.

Determine if the given abstract type has been resolved.

Determine if a given type is shared.

Determine if a given type has an explicit shared lifetime.

Determine if a given abstract is a scoped binding.

Determine if the object is a resolved scoped instance in this coroutine.

Determine if a scoped binding has already been resolved in this coroutine.

Scoped instances live in coroutine-local context, so this is false at the start of every request even for a binding resolved many times before. Callers that would only inspect an instance can use this to avoid paying for a full resolution — and the construction it implies — when nothing in the request asked for one.

Only the scoped resolution path writes this context key, so its presence already implies the binding is scoped; singletons, auto-singletons and transient bindings never produce one. An instance() registration that replaced a scoped binding also counts: it supersedes the scoped lifetime during resolution — tests swap scoped services this way — so an existing instance must be reported as resolved rather than skipped.

Determine if the container holds a worker-shared instance for the given type.

Determine if a ReflectionClass has scoping attributes applied.

Determine if a given string is an alias.

Register a binding with the container.

Bindings persist on the worker-lifetime container; runtime use races across coroutines and changes resolution for every subsequent request.

Register one binding and its lifecycle.

Get the Closure to be used when building a type.

Determine if the container has a method binding.

Bind a callback to resolve with Container::call.

Method bindings persist on the worker-lifetime container and affect every subsequent Container::call() for the bound method.

Get the method to be bound in class@method format.

Get the method binding for the given method.

Add a contextual binding to the container.

Contextual bindings persist on the worker-lifetime container; runtime use races across coroutines and changes dependency resolution for every subsequent build of the concrete.

Register a binding if it hasn't already been registered.

Conditional bindings mutate the worker-lifetime container for every subsequent request.

Register a shared binding in the container.

Singleton bindings persist on the worker-lifetime container; runtime use races across coroutines and changes shared resolution for every subsequent request.

Register a shared binding if it hasn't already been registered.

Conditional singleton bindings mutate the worker-lifetime container for every subsequent request.

Register a scoped binding in the container.

Scoped binding definitions persist on the worker-lifetime container; only their resolved instances are coroutine-scoped.

Register a scoped binding if it hasn't already been registered.

Conditional scoped bindings mutate the worker-lifetime container for every subsequent request.

Register a binding with the container based on the given Closure's return types.

"Extend" an abstract type in the container.

The extender persists in the container's $extenders array for the worker lifetime and runs on every subsequent resolution of $abstract.

Register an existing instance as shared in the container.

Replaces a worker-lifetime shared instance; runtime use races across coroutines and changes the object returned to every subsequent resolver.

Remove an alias from the contextual binding alias cache.

Assign a set of tags to a given binding.

Tags persist on the worker-lifetime container and affect every subsequent tagged() resolution.

Resolve all of the bindings for a given tag.

Alias a type to a different name.

Aliases persist on the worker-lifetime container; runtime use races across coroutines and changes resolution for every subsequent request.

Bind a new callback to an abstract's rebind event.

Rebinding callbacks persist on the worker-lifetime container and run whenever the abstract is rebound later in the worker.

Refresh an instance on the given target and method.

Registers a rebinding callback on the worker-lifetime container; runtime use leaks the callback across later rebindings.

Fire the "rebound" callbacks for the given abstract type.

Get the rebound callbacks for a given type.

Wrap the given closure such that its dependencies will be injected when executed.

Call the given Closure / class@method and inject its dependencies.

Get the class name for the given callback, if one can be determined.

Closures are handled directly in call() before this method is reached, so this only needs to handle non-closure callable types.

Get a closure to resolve the given type from the container.

An alias function name for make().

Resolve the given type from the container.

Resolve the given type with a transient implicit lifetime.

Explicit lifetimes remain authoritative.

No description

Resolve the given type from the container.

Determine whether this miss can publish a worker-shared instance.

Wait for a shared resolution without introducing a coordinator cycle.

Determine whether the resolution owner is an ancestor of a coroutine.

Determine whether adding a container wait edge would close a cycle.

Get the concrete type for a given abstract.

Get the concrete binding for an abstract from the BindWhen or Bind attributes.

Resolve the concrete from the Bind and BindWhen attributes in declaration order.

Get the contextual concrete binding for the given abstract.

Get the resolution state for the current coroutine.

Get or create the mutable resolution state for the current coroutine.

Get this container's coroutine context key for the given entry.

Get the current build stack without creating resolution state.

Find the concrete binding for the given abstract in the contextual binding array.

Determine if the given concrete is buildable.

Get the cached build recipe for the given concrete class.

Compute the build recipe for the given concrete class.

Analyzes the class via reflection and caches the result as a BuildRecipe. This happens once per class per worker lifetime, avoiding repeated reflection on every build() call.

Instantiate a concrete instance with the given parameter overrides.

Bypasses all binding lookups and the auto-singleton cache, so the returned instance is always freshly constructed. Class-typed dependencies are still resolved via the container.

Resolve the contextual constructor parameters of a class within its build context.

Contextual bindings for the class apply to dependencies the attributes resolve, and each parameter's attribute callbacks fire here. Pass the values to buildWith() as overrides so they are not resolved again. Variadic parameters are skipped, because an override is passed as one argument; the container resolves them when the class is built.

Instantiate a concrete instance of the given type.

Build a concrete as part of container resolution.

Instantiate a concrete instance of the given self building type.

Resolve all constructor parameters using cached recipe metadata.

Resolve a non-class hinted primitive dependency.

Resolve a class based dependency from the container.

Resolve a class based variadic dependency from the container.

Resolve a dependency based on an attribute.

Throw an exception that the concrete is not instantiable.

Throw an exception for an unresolvable primitive.

Register a new before resolving callback for all types.

The callback persists on the worker-lifetime container and runs before every matching future resolution.

Register a new resolving callback.

The callback persists on the worker-lifetime container and runs during every matching future resolution.

Register a new after resolving callback for all types.

The callback persists on the worker-lifetime container and runs after every matching future resolution.

Register a new after resolving attribute callback for all types.

The callback persists on the worker-lifetime container and runs after every future resolution with the matching attribute.

Fire all of the before resolving callbacks.

Fire an array of callbacks with an object.

Fire all of the resolving callbacks.

Fire all of the after resolving callbacks.

Fire all of the after resolving attribute callbacks.

Fire all callbacks that match the given abstract or object type.

Fire an array of callbacks with an object.

Get the class name or closure object ID the container is currently resolving.

Get the container's bindings.

Get the alias for an abstract if available.

Get the extender callbacks for a given type.

Remove all of the extender callbacks for a given type.

Clears worker-lifetime extender callbacks; concurrent resolutions may diverge depending on whether they resolved before or after the removal.

Drop all of the stale instances and aliases.

Forget every cached instance for an abstract without changing its lifecycle.

Remove a resolved instance from the instance cache.

Clears a worker-lifetime shared instance and current coroutine scoped instance; concurrent coroutines may still hold references that next resolution will not share.

Clear all of the instances from the container.

Clears worker-lifetime shared instances and all scoped context entries known to this container; concurrent coroutines may still hold references that next resolution will not share.

Clear all of the scoped instances from the container.

Clears this container's scoped instances in the current coroutine; runtime use can invalidate scoped services while the request is still using them.

Set the callback which determines the current container environment.

The resolver persists on the worker-lifetime container and is used by every currentEnvironmentIs() call.

Determine the environment for the container.

Flush the container of all bindings and resolved instances.

Clears the worker-lifetime application registry; runtime use breaks every concurrent resolution in the worker.

Give the cloned container its own coroutine context entries.

Like its shared instances, the clone starts with the scoped instances resolved in the current coroutine, but forgetting or replacing them on one container leaves the other's untouched.

Get the globally available instance of the container.

Set the shared instance of the container.

Replaces the process-wide container singleton; runtime use races across coroutines and breaks every facade/global container lookup.

Flush all static state.

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 handle calls to the class.

No description

Check that the runtime environment is properly configured.

Configure and create a new application builder instance.

The builder's provider list persists in a static property used when the application registers its providers.

Infer the application's base directory from the environment.

Precedence is $_ENV, $_SERVER, Env repository, then Composer. Hypervel checks $_SERVER and Env so test helpers and worker environments can provide APP_BASE_PATH without writing to $_ENV.

Get the version number of the application.

Register the basic bindings into the container.

Register all of the base service providers.

Run the given array of bootstrap classes.

Register a callback to run before a bootstrapper.

Register a callback to run after a bootstrapper.

Register a callback to run after loading the environment.

Determine if the application has been bootstrapped before.

Set the base path for the application.

Rebinds path instances on the singleton container; runtime use races across coroutines and breaks every concurrent path resolution.

Bind all of the application paths in the container.

Rebinds path instances on the singleton container; runtime use races across coroutines and breaks every concurrent path resolution.

Get the path to the application "app" directory.

Set the application directory.

The configured path and its container binding are shared by every request in the worker.

Get the base path of the Hypervel installation.

Get the path to the bootstrap directory.

Set the bootstrap file directory.

The configured path and its container binding are shared by every request in the worker.

Get the path to the service provider list in the bootstrap directory.

Get the path to the application configuration files.

Set the configuration directory.

The configured path and its container binding are shared by every request in the worker.

Get the path to the database directory.

Set the database directory.

The configured path and its container binding are shared by every request in the worker.

Get the path to the language files.

Set the language file directory.

The configured path and its container binding are shared by every request in the worker.

Get the path to the public directory.

Set the public / web directory.

The configured path and its container binding are shared by every request in the worker.

Get the path to the resources directory.

Get the path to the views directory.

This method returns the first configured path in the array of view paths.

Get the path to the storage directory.

Set the storage directory.

The configured path and its container binding are shared by every request in the worker.

Get the path to the environment file directory.

Set the directory for the environment file.

The configured path is shared by every request in the worker.

Set the environment file to be loaded during bootstrapping.

The configured filename is shared by every request in the worker.

Get the environment file the application is using.

Get the fully-qualified path to the environment file.

Determine if the application configuration is cached.

Get the path to the configuration cache file.

Get the path to the cached packages.php file.

Determine if the application routes are cached.

Get the path to the routes cache file.

Determine if the application events are cached.

Get the path to the events cache file.

Normalize a relative or absolute path to a cache file.

Add new prefix to list of absolute path prefixes.

The prefix persists on the application singleton and affects cache-path resolution for every request in the worker.

Join the given paths together.

Get or check the current application environment.

Determine if the application is in the local environment.

Determine if the application is in the production environment.

Detect the application's current environment.

The detected environment is shared by every request in the worker.

Determine if the application is running in the console.

In Swoole, PHP_SAPI is always 'cli', so this defaults to true. The server command sets it to false before starting the HTTP server, and workers inherit that value.

Determine if the application is running any of the given console commands.

Set whether the application is running in the console.

The flag persists on the singleton Application for the worker lifetime and is read by every runningInConsole() check across all coroutines.

Determine if the application is running unit tests.

Determine if the application is running with debug mode enabled.

Get an instance of the maintenance mode manager implementation.

Determine if the application is currently down for maintenance.

Handle the incoming Artisan command.

Determine if the framework's base configuration should be merged.

Indicate that the framework's base configuration should not be merged.

The setting changes configuration bootstrap behavior for the entire worker.

Determine if middleware has been disabled for the application.

Register a new registered listener.

The callback persists in the Application's registeredCallbacks array and fires once per service provider registration during boot.

Register all of the configured providers.

Providers are loaded in three tiers:

1. Framework providers (Hypervel* from app.providers) — always first
2. Discovered providers (from composer packages) — sorted by priority
3. Application providers (non-Hypervel* from app.providers) — always last

The providers' bindings persist on the application for every subsequent request in the worker.

Discover service providers from installed composer packages.

Sort providers by their priority property in descending order.

Higher priority values are loaded first. Providers with the same priority preserve their original order (stable sort).

Register a service provider with the application.

The provider's bindings persist on the application for every subsequent request in the worker.

Get the registered service provider instance if it exists.

Get the registered service provider instances if any exist.

Resolve a service provider instance from the class name.

Mark the given provider as registered.

Determine if the application has booted.

Boot the application's service providers.

Boot the given service provider.

Register a new boot listener.

The callback fires once during application boot; runtime use after boot stores the closure on the singleton Application with no future boot to listen for.

Register a new "booted" listener.

If the app has already booted, the callback fires immediately and is never invoked again, but remains stored on the singleton Application for the worker lifetime.

Register a terminating callback with the application.

Callbacks persist for the worker's lifetime and fire on every subsequent request — per-request use leaks the closure and anything it captures across every request the worker handles. Use defer() for per-request "after the response" cleanup.

Terminate the application.