Laravel IDE Helper for Netbeans / PhpStorm / Sublime Text 2 CodeIntel, generated using https://github.com/barryvdh/laravel-ide-helper
<?php | |
/** | |
* A helper file for Laravel 5, to provide autocomplete information to your IDE | |
* Generated for Laravel 5.5.13 on 2017-09-28. | |
* | |
* @author Barry vd. Heuvel <barryvdh@gmail.com> | |
* @see https://github.com/barryvdh/laravel-ide-helper | |
*/ | |
namespace { | |
exit("This file should not be included, only analyzed by your IDE"); | |
} | |
namespace Illuminate\Support\Facades { | |
class App { | |
/** | |
* Get the version number of the application. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function version() | |
{ | |
return \Illuminate\Foundation\Application::version(); | |
} | |
/** | |
* Run the given array of bootstrap classes. | |
* | |
* @param array $bootstrappers | |
* @return void | |
* @static | |
*/ | |
public static function bootstrapWith($bootstrappers) | |
{ | |
\Illuminate\Foundation\Application::bootstrapWith($bootstrappers); | |
} | |
/** | |
* Register a callback to run after loading the environment. | |
* | |
* @param \Closure $callback | |
* @return void | |
* @static | |
*/ | |
public static function afterLoadingEnvironment($callback) | |
{ | |
\Illuminate\Foundation\Application::afterLoadingEnvironment($callback); | |
} | |
/** | |
* Register a callback to run before a bootstrapper. | |
* | |
* @param string $bootstrapper | |
* @param \Closure $callback | |
* @return void | |
* @static | |
*/ | |
public static function beforeBootstrapping($bootstrapper, $callback) | |
{ | |
\Illuminate\Foundation\Application::beforeBootstrapping($bootstrapper, $callback); | |
} | |
/** | |
* Register a callback to run after a bootstrapper. | |
* | |
* @param string $bootstrapper | |
* @param \Closure $callback | |
* @return void | |
* @static | |
*/ | |
public static function afterBootstrapping($bootstrapper, $callback) | |
{ | |
\Illuminate\Foundation\Application::afterBootstrapping($bootstrapper, $callback); | |
} | |
/** | |
* Determine if the application has been bootstrapped before. | |
* | |
* @return bool | |
* @static | |
*/ | |
public static function hasBeenBootstrapped() | |
{ | |
return \Illuminate\Foundation\Application::hasBeenBootstrapped(); | |
} | |
/** | |
* Set the base path for the application. | |
* | |
* @param string $basePath | |
* @return $this | |
* @static | |
*/ | |
public static function setBasePath($basePath) | |
{ | |
return \Illuminate\Foundation\Application::setBasePath($basePath); | |
} | |
/** | |
* Get the path to the application "app" directory. | |
* | |
* @param string $path Optionally, a path to append to the app path | |
* @return string | |
* @static | |
*/ | |
public static function path($path = '') | |
{ | |
return \Illuminate\Foundation\Application::path($path); | |
} | |
/** | |
* Get the base path of the Laravel installation. | |
* | |
* @param string $path Optionally, a path to append to the base path | |
* @return string | |
* @static | |
*/ | |
public static function basePath($path = '') | |
{ | |
return \Illuminate\Foundation\Application::basePath($path); | |
} | |
/** | |
* Get the path to the bootstrap directory. | |
* | |
* @param string $path Optionally, a path to append to the bootstrap path | |
* @return string | |
* @static | |
*/ | |
public static function bootstrapPath($path = '') | |
{ | |
return \Illuminate\Foundation\Application::bootstrapPath($path); | |
} | |
/** | |
* Get the path to the application configuration files. | |
* | |
* @param string $path Optionally, a path to append to the config path | |
* @return string | |
* @static | |
*/ | |
public static function configPath($path = '') | |
{ | |
return \Illuminate\Foundation\Application::configPath($path); | |
} | |
/** | |
* Get the path to the database directory. | |
* | |
* @param string $path Optionally, a path to append to the database path | |
* @return string | |
* @static | |
*/ | |
public static function databasePath($path = '') | |
{ | |
return \Illuminate\Foundation\Application::databasePath($path); | |
} | |
/** | |
* Set the database directory. | |
* | |
* @param string $path | |
* @return $this | |
* @static | |
*/ | |
public static function useDatabasePath($path) | |
{ | |
return \Illuminate\Foundation\Application::useDatabasePath($path); | |
} | |
/** | |
* Get the path to the language files. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function langPath() | |
{ | |
return \Illuminate\Foundation\Application::langPath(); | |
} | |
/** | |
* Get the path to the public / web directory. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function publicPath() | |
{ | |
return \Illuminate\Foundation\Application::publicPath(); | |
} | |
/** | |
* Get the path to the storage directory. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function storagePath() | |
{ | |
return \Illuminate\Foundation\Application::storagePath(); | |
} | |
/** | |
* Set the storage directory. | |
* | |
* @param string $path | |
* @return $this | |
* @static | |
*/ | |
public static function useStoragePath($path) | |
{ | |
return \Illuminate\Foundation\Application::useStoragePath($path); | |
} | |
/** | |
* Get the path to the resources directory. | |
* | |
* @param string $path | |
* @return string | |
* @static | |
*/ | |
public static function resourcePath($path = '') | |
{ | |
return \Illuminate\Foundation\Application::resourcePath($path); | |
} | |
/** | |
* Get the path to the environment file directory. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function environmentPath() | |
{ | |
return \Illuminate\Foundation\Application::environmentPath(); | |
} | |
/** | |
* Set the directory for the environment file. | |
* | |
* @param string $path | |
* @return $this | |
* @static | |
*/ | |
public static function useEnvironmentPath($path) | |
{ | |
return \Illuminate\Foundation\Application::useEnvironmentPath($path); | |
} | |
/** | |
* Set the environment file to be loaded during bootstrapping. | |
* | |
* @param string $file | |
* @return $this | |
* @static | |
*/ | |
public static function loadEnvironmentFrom($file) | |
{ | |
return \Illuminate\Foundation\Application::loadEnvironmentFrom($file); | |
} | |
/** | |
* Get the environment file the application is using. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function environmentFile() | |
{ | |
return \Illuminate\Foundation\Application::environmentFile(); | |
} | |
/** | |
* Get the fully qualified path to the environment file. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function environmentFilePath() | |
{ | |
return \Illuminate\Foundation\Application::environmentFilePath(); | |
} | |
/** | |
* Get or check the current application environment. | |
* | |
* @return string|bool | |
* @static | |
*/ | |
public static function environment() | |
{ | |
return \Illuminate\Foundation\Application::environment(); | |
} | |
/** | |
* Determine if application is in local environment. | |
* | |
* @return bool | |
* @static | |
*/ | |
public static function isLocal() | |
{ | |
return \Illuminate\Foundation\Application::isLocal(); | |
} | |
/** | |
* Detect the application's current environment. | |
* | |
* @param \Closure $callback | |
* @return string | |
* @static | |
*/ | |
public static function detectEnvironment($callback) | |
{ | |
return \Illuminate\Foundation\Application::detectEnvironment($callback); | |
} | |
/** | |
* Determine if we are running in the console. | |
* | |
* @return bool | |
* @static | |
*/ | |
public static function runningInConsole() | |
{ | |
return \Illuminate\Foundation\Application::runningInConsole(); | |
} | |
/** | |
* Determine if we are running unit tests. | |
* | |
* @return bool | |
* @static | |
*/ | |
public static function runningUnitTests() | |
{ | |
return \Illuminate\Foundation\Application::runningUnitTests(); | |
} | |
/** | |
* Register all of the configured providers. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function registerConfiguredProviders() | |
{ | |
\Illuminate\Foundation\Application::registerConfiguredProviders(); | |
} | |
/** | |
* Register a service provider with the application. | |
* | |
* @param \Illuminate\Support\ServiceProvider|string $provider | |
* @param array $options | |
* @param bool $force | |
* @return \Illuminate\Support\ServiceProvider | |
* @static | |
*/ | |
public static function register($provider, $options = array(), $force = false) | |
{ | |
return \Illuminate\Foundation\Application::register($provider, $options, $force); | |
} | |
/** | |
* Get the registered service provider instance if it exists. | |
* | |
* @param \Illuminate\Support\ServiceProvider|string $provider | |
* @return \Illuminate\Support\ServiceProvider|null | |
* @static | |
*/ | |
public static function getProvider($provider) | |
{ | |
return \Illuminate\Foundation\Application::getProvider($provider); | |
} | |
/** | |
* Resolve a service provider instance from the class name. | |
* | |
* @param string $provider | |
* @return \Illuminate\Support\ServiceProvider | |
* @static | |
*/ | |
public static function resolveProvider($provider) | |
{ | |
return \Illuminate\Foundation\Application::resolveProvider($provider); | |
} | |
/** | |
* Load and boot all of the remaining deferred providers. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function loadDeferredProviders() | |
{ | |
\Illuminate\Foundation\Application::loadDeferredProviders(); | |
} | |
/** | |
* Load the provider for a deferred service. | |
* | |
* @param string $service | |
* @return void | |
* @static | |
*/ | |
public static function loadDeferredProvider($service) | |
{ | |
\Illuminate\Foundation\Application::loadDeferredProvider($service); | |
} | |
/** | |
* Register a deferred provider and service. | |
* | |
* @param string $provider | |
* @param string|null $service | |
* @return void | |
* @static | |
*/ | |
public static function registerDeferredProvider($provider, $service = null) | |
{ | |
\Illuminate\Foundation\Application::registerDeferredProvider($provider, $service); | |
} | |
/** | |
* Resolve the given type from the container. | |
* | |
* (Overriding Container::make) | |
* | |
* @param string $abstract | |
* @param array $parameters | |
* @return mixed | |
* @static | |
*/ | |
public static function make($abstract, $parameters = array()) | |
{ | |
return \Illuminate\Foundation\Application::make($abstract, $parameters); | |
} | |
/** | |
* Determine if the given abstract type has been bound. | |
* | |
* (Overriding Container::bound) | |
* | |
* @param string $abstract | |
* @return bool | |
* @static | |
*/ | |
public static function bound($abstract) | |
{ | |
return \Illuminate\Foundation\Application::bound($abstract); | |
} | |
/** | |
* Determine if the application has booted. | |
* | |
* @return bool | |
* @static | |
*/ | |
public static function isBooted() | |
{ | |
return \Illuminate\Foundation\Application::isBooted(); | |
} | |
/** | |
* Boot the application's service providers. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function boot() | |
{ | |
\Illuminate\Foundation\Application::boot(); | |
} | |
/** | |
* Register a new boot listener. | |
* | |
* @param mixed $callback | |
* @return void | |
* @static | |
*/ | |
public static function booting($callback) | |
{ | |
\Illuminate\Foundation\Application::booting($callback); | |
} | |
/** | |
* Register a new "booted" listener. | |
* | |
* @param mixed $callback | |
* @return void | |
* @static | |
*/ | |
public static function booted($callback) | |
{ | |
\Illuminate\Foundation\Application::booted($callback); | |
} | |
/** | |
* {@inheritdoc} | |
* | |
* @static | |
*/ | |
public static function handle($request, $type = 1, $catch = true) | |
{ | |
return \Illuminate\Foundation\Application::handle($request, $type, $catch); | |
} | |
/** | |
* Determine if middleware has been disabled for the application. | |
* | |
* @return bool | |
* @static | |
*/ | |
public static function shouldSkipMiddleware() | |
{ | |
return \Illuminate\Foundation\Application::shouldSkipMiddleware(); | |
} | |
/** | |
* Get the path to the cached services.php file. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getCachedServicesPath() | |
{ | |
return \Illuminate\Foundation\Application::getCachedServicesPath(); | |
} | |
/** | |
* Get the path to the cached packages.php file. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getCachedPackagesPath() | |
{ | |
return \Illuminate\Foundation\Application::getCachedPackagesPath(); | |
} | |
/** | |
* Determine if the application configuration is cached. | |
* | |
* @return bool | |
* @static | |
*/ | |
public static function configurationIsCached() | |
{ | |
return \Illuminate\Foundation\Application::configurationIsCached(); | |
} | |
/** | |
* Get the path to the configuration cache file. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getCachedConfigPath() | |
{ | |
return \Illuminate\Foundation\Application::getCachedConfigPath(); | |
} | |
/** | |
* Determine if the application routes are cached. | |
* | |
* @return bool | |
* @static | |
*/ | |
public static function routesAreCached() | |
{ | |
return \Illuminate\Foundation\Application::routesAreCached(); | |
} | |
/** | |
* Get the path to the routes cache file. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getCachedRoutesPath() | |
{ | |
return \Illuminate\Foundation\Application::getCachedRoutesPath(); | |
} | |
/** | |
* Determine if the application is currently down for maintenance. | |
* | |
* @return bool | |
* @static | |
*/ | |
public static function isDownForMaintenance() | |
{ | |
return \Illuminate\Foundation\Application::isDownForMaintenance(); | |
} | |
/** | |
* Throw an HttpException with the given data. | |
* | |
* @param int $code | |
* @param string $message | |
* @param array $headers | |
* @return void | |
* @throws \Symfony\Component\HttpKernel\Exception\HttpException | |
* @static | |
*/ | |
public static function abort($code, $message = '', $headers = array()) | |
{ | |
\Illuminate\Foundation\Application::abort($code, $message, $headers); | |
} | |
/** | |
* Register a terminating callback with the application. | |
* | |
* @param \Closure $callback | |
* @return $this | |
* @static | |
*/ | |
public static function terminating($callback) | |
{ | |
return \Illuminate\Foundation\Application::terminating($callback); | |
} | |
/** | |
* Terminate the application. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function terminate() | |
{ | |
\Illuminate\Foundation\Application::terminate(); | |
} | |
/** | |
* Get the service providers that have been loaded. | |
* | |
* @return array | |
* @static | |
*/ | |
public static function getLoadedProviders() | |
{ | |
return \Illuminate\Foundation\Application::getLoadedProviders(); | |
} | |
/** | |
* Get the application's deferred services. | |
* | |
* @return array | |
* @static | |
*/ | |
public static function getDeferredServices() | |
{ | |
return \Illuminate\Foundation\Application::getDeferredServices(); | |
} | |
/** | |
* Set the application's deferred services. | |
* | |
* @param array $services | |
* @return void | |
* @static | |
*/ | |
public static function setDeferredServices($services) | |
{ | |
\Illuminate\Foundation\Application::setDeferredServices($services); | |
} | |
/** | |
* Add an array of services to the application's deferred services. | |
* | |
* @param array $services | |
* @return void | |
* @static | |
*/ | |
public static function addDeferredServices($services) | |
{ | |
\Illuminate\Foundation\Application::addDeferredServices($services); | |
} | |
/** | |
* Determine if the given service is a deferred service. | |
* | |
* @param string $service | |
* @return bool | |
* @static | |
*/ | |
public static function isDeferredService($service) | |
{ | |
return \Illuminate\Foundation\Application::isDeferredService($service); | |
} | |
/** | |
* Configure the real-time facade namespace. | |
* | |
* @param string $namespace | |
* @return void | |
* @static | |
*/ | |
public static function provideFacades($namespace) | |
{ | |
\Illuminate\Foundation\Application::provideFacades($namespace); | |
} | |
/** | |
* Define a callback to be used to configure Monolog. | |
* | |
* @param callable $callback | |
* @return $this | |
* @static | |
*/ | |
public static function configureMonologUsing($callback) | |
{ | |
return \Illuminate\Foundation\Application::configureMonologUsing($callback); | |
} | |
/** | |
* Determine if the application has a custom Monolog configurator. | |
* | |
* @return bool | |
* @static | |
*/ | |
public static function hasMonologConfigurator() | |
{ | |
return \Illuminate\Foundation\Application::hasMonologConfigurator(); | |
} | |
/** | |
* Get the custom Monolog configurator for the application. | |
* | |
* @return callable | |
* @static | |
*/ | |
public static function getMonologConfigurator() | |
{ | |
return \Illuminate\Foundation\Application::getMonologConfigurator(); | |
} | |
/** | |
* Get the current application locale. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getLocale() | |
{ | |
return \Illuminate\Foundation\Application::getLocale(); | |
} | |
/** | |
* Set the current application locale. | |
* | |
* @param string $locale | |
* @return void | |
* @static | |
*/ | |
public static function setLocale($locale) | |
{ | |
\Illuminate\Foundation\Application::setLocale($locale); | |
} | |
/** | |
* Determine if application locale is the given locale. | |
* | |
* @param string $locale | |
* @return bool | |
* @static | |
*/ | |
public static function isLocale($locale) | |
{ | |
return \Illuminate\Foundation\Application::isLocale($locale); | |
} | |
/** | |
* Register the core class aliases in the container. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function registerCoreContainerAliases() | |
{ | |
\Illuminate\Foundation\Application::registerCoreContainerAliases(); | |
} | |
/** | |
* Flush the container of all bindings and resolved instances. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function flush() | |
{ | |
\Illuminate\Foundation\Application::flush(); | |
} | |
/** | |
* Get the application namespace. | |
* | |
* @return string | |
* @throws \RuntimeException | |
* @static | |
*/ | |
public static function getNamespace() | |
{ | |
return \Illuminate\Foundation\Application::getNamespace(); | |
} | |
/** | |
* Define a contextual binding. | |
* | |
* @param string $concrete | |
* @return \Illuminate\Contracts\Container\ContextualBindingBuilder | |
* @static | |
*/ | |
public static function when($concrete) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
return \Illuminate\Foundation\Application::when($concrete); | |
} | |
/** | |
* Returns true if the container can return an entry for the given identifier. | |
* | |
* Returns false otherwise. | |
* | |
* `has($id)` returning true does not mean that `get($id)` will not throw an exception. | |
* It does however mean that `get($id)` will not throw a `NotFoundExceptionInterface`. | |
* | |
* @param string $id Identifier of the entry to look for. | |
* @return bool | |
* @static | |
*/ | |
public static function has($id) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
return \Illuminate\Foundation\Application::has($id); | |
} | |
/** | |
* Determine if the given abstract type has been resolved. | |
* | |
* @param string $abstract | |
* @return bool | |
* @static | |
*/ | |
public static function resolved($abstract) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
return \Illuminate\Foundation\Application::resolved($abstract); | |
} | |
/** | |
* Determine if a given type is shared. | |
* | |
* @param string $abstract | |
* @return bool | |
* @static | |
*/ | |
public static function isShared($abstract) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
return \Illuminate\Foundation\Application::isShared($abstract); | |
} | |
/** | |
* Determine if a given string is an alias. | |
* | |
* @param string $name | |
* @return bool | |
* @static | |
*/ | |
public static function isAlias($name) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
return \Illuminate\Foundation\Application::isAlias($name); | |
} | |
/** | |
* Register a binding with the container. | |
* | |
* @param string|array $abstract | |
* @param \Closure|string|null $concrete | |
* @param bool $shared | |
* @return void | |
* @static | |
*/ | |
public static function bind($abstract, $concrete = null, $shared = false) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
\Illuminate\Foundation\Application::bind($abstract, $concrete, $shared); | |
} | |
/** | |
* Determine if the container has a method binding. | |
* | |
* @param string $method | |
* @return bool | |
* @static | |
*/ | |
public static function hasMethodBinding($method) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
return \Illuminate\Foundation\Application::hasMethodBinding($method); | |
} | |
/** | |
* Bind a callback to resolve with Container::call. | |
* | |
* @param string $method | |
* @param \Closure $callback | |
* @return void | |
* @static | |
*/ | |
public static function bindMethod($method, $callback) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
\Illuminate\Foundation\Application::bindMethod($method, $callback); | |
} | |
/** | |
* Get the method binding for the given method. | |
* | |
* @param string $method | |
* @param mixed $instance | |
* @return mixed | |
* @static | |
*/ | |
public static function callMethodBinding($method, $instance) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
return \Illuminate\Foundation\Application::callMethodBinding($method, $instance); | |
} | |
/** | |
* Add a contextual binding to the container. | |
* | |
* @param string $concrete | |
* @param string $abstract | |
* @param \Closure|string $implementation | |
* @return void | |
* @static | |
*/ | |
public static function addContextualBinding($concrete, $abstract, $implementation) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
\Illuminate\Foundation\Application::addContextualBinding($concrete, $abstract, $implementation); | |
} | |
/** | |
* Register a binding if it hasn't already been registered. | |
* | |
* @param string $abstract | |
* @param \Closure|string|null $concrete | |
* @param bool $shared | |
* @return void | |
* @static | |
*/ | |
public static function bindIf($abstract, $concrete = null, $shared = false) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
\Illuminate\Foundation\Application::bindIf($abstract, $concrete, $shared); | |
} | |
/** | |
* Register a shared binding in the container. | |
* | |
* @param string|array $abstract | |
* @param \Closure|string|null $concrete | |
* @return void | |
* @static | |
*/ | |
public static function singleton($abstract, $concrete = null) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
\Illuminate\Foundation\Application::singleton($abstract, $concrete); | |
} | |
/** | |
* "Extend" an abstract type in the container. | |
* | |
* @param string $abstract | |
* @param \Closure $closure | |
* @return void | |
* @throws \InvalidArgumentException | |
* @static | |
*/ | |
public static function extend($abstract, $closure) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
\Illuminate\Foundation\Application::extend($abstract, $closure); | |
} | |
/** | |
* Register an existing instance as shared in the container. | |
* | |
* @param string $abstract | |
* @param mixed $instance | |
* @return mixed | |
* @static | |
*/ | |
public static function instance($abstract, $instance) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
return \Illuminate\Foundation\Application::instance($abstract, $instance); | |
} | |
/** | |
* Assign a set of tags to a given binding. | |
* | |
* @param array|string $abstracts | |
* @param array|mixed $tags | |
* @return void | |
* @static | |
*/ | |
public static function tag($abstracts, $tags) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
\Illuminate\Foundation\Application::tag($abstracts, $tags); | |
} | |
/** | |
* Resolve all of the bindings for a given tag. | |
* | |
* @param string $tag | |
* @return array | |
* @static | |
*/ | |
public static function tagged($tag) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
return \Illuminate\Foundation\Application::tagged($tag); | |
} | |
/** | |
* Alias a type to a different name. | |
* | |
* @param string $abstract | |
* @param string $alias | |
* @return void | |
* @static | |
*/ | |
public static function alias($abstract, $alias) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
\Illuminate\Foundation\Application::alias($abstract, $alias); | |
} | |
/** | |
* Bind a new callback to an abstract's rebind event. | |
* | |
* @param string $abstract | |
* @param \Closure $callback | |
* @return mixed | |
* @static | |
*/ | |
public static function rebinding($abstract, $callback) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
return \Illuminate\Foundation\Application::rebinding($abstract, $callback); | |
} | |
/** | |
* Refresh an instance on the given target and method. | |
* | |
* @param string $abstract | |
* @param mixed $target | |
* @param string $method | |
* @return mixed | |
* @static | |
*/ | |
public static function refresh($abstract, $target, $method) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
return \Illuminate\Foundation\Application::refresh($abstract, $target, $method); | |
} | |
/** | |
* Wrap the given closure such that its dependencies will be injected when executed. | |
* | |
* @param \Closure $callback | |
* @param array $parameters | |
* @return \Closure | |
* @static | |
*/ | |
public static function wrap($callback, $parameters = array()) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
return \Illuminate\Foundation\Application::wrap($callback, $parameters); | |
} | |
/** | |
* Call the given Closure / class@method and inject its dependencies. | |
* | |
* @param callable|string $callback | |
* @param array $parameters | |
* @param string|null $defaultMethod | |
* @return mixed | |
* @static | |
*/ | |
public static function call($callback, $parameters = array(), $defaultMethod = null) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
return \Illuminate\Foundation\Application::call($callback, $parameters, $defaultMethod); | |
} | |
/** | |
* Get a closure to resolve the given type from the container. | |
* | |
* @param string $abstract | |
* @return \Closure | |
* @static | |
*/ | |
public static function factory($abstract) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
return \Illuminate\Foundation\Application::factory($abstract); | |
} | |
/** | |
* An alias function name for make(). | |
* | |
* @param string $abstract | |
* @param array $parameters | |
* @return mixed | |
* @static | |
*/ | |
public static function makeWith($abstract, $parameters = array()) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
return \Illuminate\Foundation\Application::makeWith($abstract, $parameters); | |
} | |
/** | |
* Finds an entry of the container by its identifier and returns it. | |
* | |
* @param string $id Identifier of the entry to look for. | |
* @throws NotFoundExceptionInterface No entry was found for **this** identifier. | |
* @throws ContainerExceptionInterface Error while retrieving the entry. | |
* @return mixed Entry. | |
* @static | |
*/ | |
public static function get($id) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
return \Illuminate\Foundation\Application::get($id); | |
} | |
/** | |
* Instantiate a concrete instance of the given type. | |
* | |
* @param string $concrete | |
* @return mixed | |
* @throws \Illuminate\Contracts\Container\BindingResolutionException | |
* @static | |
*/ | |
public static function build($concrete) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
return \Illuminate\Foundation\Application::build($concrete); | |
} | |
/** | |
* Register a new resolving callback. | |
* | |
* @param string $abstract | |
* @param \Closure|null $callback | |
* @return void | |
* @static | |
*/ | |
public static function resolving($abstract, $callback = null) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
\Illuminate\Foundation\Application::resolving($abstract, $callback); | |
} | |
/** | |
* Register a new after resolving callback for all types. | |
* | |
* @param string $abstract | |
* @param \Closure|null $callback | |
* @return void | |
* @static | |
*/ | |
public static function afterResolving($abstract, $callback = null) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
\Illuminate\Foundation\Application::afterResolving($abstract, $callback); | |
} | |
/** | |
* Get the container's bindings. | |
* | |
* @return array | |
* @static | |
*/ | |
public static function getBindings() | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
return \Illuminate\Foundation\Application::getBindings(); | |
} | |
/** | |
* Get the alias for an abstract if available. | |
* | |
* @param string $abstract | |
* @return string | |
* @throws \LogicException | |
* @static | |
*/ | |
public static function getAlias($abstract) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
return \Illuminate\Foundation\Application::getAlias($abstract); | |
} | |
/** | |
* Remove all of the extender callbacks for a given type. | |
* | |
* @param string $abstract | |
* @return void | |
* @static | |
*/ | |
public static function forgetExtenders($abstract) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
\Illuminate\Foundation\Application::forgetExtenders($abstract); | |
} | |
/** | |
* Remove a resolved instance from the instance cache. | |
* | |
* @param string $abstract | |
* @return void | |
* @static | |
*/ | |
public static function forgetInstance($abstract) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
\Illuminate\Foundation\Application::forgetInstance($abstract); | |
} | |
/** | |
* Clear all of the instances from the container. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function forgetInstances() | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
\Illuminate\Foundation\Application::forgetInstances(); | |
} | |
/** | |
* Set the globally available instance of the container. | |
* | |
* @return static | |
* @static | |
*/ | |
public static function getInstance() | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
return \Illuminate\Foundation\Application::getInstance(); | |
} | |
/** | |
* Set the shared instance of the container. | |
* | |
* @param \Illuminate\Contracts\Container\Container|null $container | |
* @return static | |
* @static | |
*/ | |
public static function setInstance($container = null) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
return \Illuminate\Foundation\Application::setInstance($container); | |
} | |
/** | |
* Determine if a given offset exists. | |
* | |
* @param string $key | |
* @return bool | |
* @static | |
*/ | |
public static function offsetExists($key) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
return \Illuminate\Foundation\Application::offsetExists($key); | |
} | |
/** | |
* Get the value at a given offset. | |
* | |
* @param string $key | |
* @return mixed | |
* @static | |
*/ | |
public static function offsetGet($key) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
return \Illuminate\Foundation\Application::offsetGet($key); | |
} | |
/** | |
* Set the value at a given offset. | |
* | |
* @param string $key | |
* @param mixed $value | |
* @return void | |
* @static | |
*/ | |
public static function offsetSet($key, $value) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
\Illuminate\Foundation\Application::offsetSet($key, $value); | |
} | |
/** | |
* Unset the value at a given offset. | |
* | |
* @param string $key | |
* @return void | |
* @static | |
*/ | |
public static function offsetUnset($key) | |
{ | |
//Method inherited from \Illuminate\Container\Container | |
\Illuminate\Foundation\Application::offsetUnset($key); | |
} | |
} | |
class Artisan { | |
/** | |
* Run the console application. | |
* | |
* @param \Symfony\Component\Console\Input\InputInterface $input | |
* @param \Symfony\Component\Console\Output\OutputInterface $output | |
* @return int | |
* @static | |
*/ | |
public static function handle($input, $output = null) | |
{ | |
//Method inherited from \Illuminate\Foundation\Console\Kernel | |
return \App\Console\Kernel::handle($input, $output); | |
} | |
/** | |
* Terminate the application. | |
* | |
* @param \Symfony\Component\Console\Input\InputInterface $input | |
* @param int $status | |
* @return void | |
* @static | |
*/ | |
public static function terminate($input, $status) | |
{ | |
//Method inherited from \Illuminate\Foundation\Console\Kernel | |
\App\Console\Kernel::terminate($input, $status); | |
} | |
/** | |
* Register a Closure based command with the application. | |
* | |
* @param string $signature | |
* @param \Closure $callback | |
* @return \Illuminate\Foundation\Console\ClosureCommand | |
* @static | |
*/ | |
public static function command($signature, $callback) | |
{ | |
//Method inherited from \Illuminate\Foundation\Console\Kernel | |
return \App\Console\Kernel::command($signature, $callback); | |
} | |
/** | |
* Register the given command with the console application. | |
* | |
* @param \Symfony\Component\Console\Command\Command $command | |
* @return void | |
* @static | |
*/ | |
public static function registerCommand($command) | |
{ | |
//Method inherited from \Illuminate\Foundation\Console\Kernel | |
\App\Console\Kernel::registerCommand($command); | |
} | |
/** | |
* Run an Artisan console command by name. | |
* | |
* @param string $command | |
* @param array $parameters | |
* @param \Symfony\Component\Console\Output\OutputInterface $outputBuffer | |
* @return int | |
* @static | |
*/ | |
public static function call($command, $parameters = array(), $outputBuffer = null) | |
{ | |
//Method inherited from \Illuminate\Foundation\Console\Kernel | |
return \App\Console\Kernel::call($command, $parameters, $outputBuffer); | |
} | |
/** | |
* Queue the given console command. | |
* | |
* @param string $command | |
* @param array $parameters | |
* @return \Illuminate\Foundation\Bus\PendingDispatch | |
* @static | |
*/ | |
public static function queue($command, $parameters = array()) | |
{ | |
//Method inherited from \Illuminate\Foundation\Console\Kernel | |
return \App\Console\Kernel::queue($command, $parameters); | |
} | |
/** | |
* Get all of the commands registered with the console. | |
* | |
* @return array | |
* @static | |
*/ | |
public static function all() | |
{ | |
//Method inherited from \Illuminate\Foundation\Console\Kernel | |
return \App\Console\Kernel::all(); | |
} | |
/** | |
* Get the output for the last run command. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function output() | |
{ | |
//Method inherited from \Illuminate\Foundation\Console\Kernel | |
return \App\Console\Kernel::output(); | |
} | |
/** | |
* Bootstrap the application for artisan commands. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function bootstrap() | |
{ | |
//Method inherited from \Illuminate\Foundation\Console\Kernel | |
\App\Console\Kernel::bootstrap(); | |
} | |
/** | |
* Set the Artisan application instance. | |
* | |
* @param \Illuminate\Console\Application $artisan | |
* @return void | |
* @static | |
*/ | |
public static function setArtisan($artisan) | |
{ | |
//Method inherited from \Illuminate\Foundation\Console\Kernel | |
\App\Console\Kernel::setArtisan($artisan); | |
} | |
} | |
class Auth { | |
/** | |
* Attempt to get the guard from the local cache. | |
* | |
* @param string $name | |
* @return \Illuminate\Contracts\Auth\Guard|\Illuminate\Contracts\Auth\StatefulGuard | |
* @static | |
*/ | |
public static function guard($name = null) | |
{ | |
return \Illuminate\Auth\AuthManager::guard($name); | |
} | |
/** | |
* Create a session based authentication guard. | |
* | |
* @param string $name | |
* @param array $config | |
* @return \Illuminate\Auth\SessionGuard | |
* @static | |
*/ | |
public static function createSessionDriver($name, $config) | |
{ | |
return \Illuminate\Auth\AuthManager::createSessionDriver($name, $config); | |
} | |
/** | |
* Create a token based authentication guard. | |
* | |
* @param string $name | |
* @param array $config | |
* @return \Illuminate\Auth\TokenGuard | |
* @static | |
*/ | |
public static function createTokenDriver($name, $config) | |
{ | |
return \Illuminate\Auth\AuthManager::createTokenDriver($name, $config); | |
} | |
/** | |
* Get the default authentication driver name. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getDefaultDriver() | |
{ | |
return \Illuminate\Auth\AuthManager::getDefaultDriver(); | |
} | |
/** | |
* Set the default guard driver the factory should serve. | |
* | |
* @param string $name | |
* @return void | |
* @static | |
*/ | |
public static function shouldUse($name) | |
{ | |
\Illuminate\Auth\AuthManager::shouldUse($name); | |
} | |
/** | |
* Set the default authentication driver name. | |
* | |
* @param string $name | |
* @return void | |
* @static | |
*/ | |
public static function setDefaultDriver($name) | |
{ | |
\Illuminate\Auth\AuthManager::setDefaultDriver($name); | |
} | |
/** | |
* Register a new callback based request guard. | |
* | |
* @param string $driver | |
* @param callable $callback | |
* @return $this | |
* @static | |
*/ | |
public static function viaRequest($driver, $callback) | |
{ | |
return \Illuminate\Auth\AuthManager::viaRequest($driver, $callback); | |
} | |
/** | |
* Get the user resolver callback. | |
* | |
* @return \Closure | |
* @static | |
*/ | |
public static function userResolver() | |
{ | |
return \Illuminate\Auth\AuthManager::userResolver(); | |
} | |
/** | |
* Set the callback to be used to resolve users. | |
* | |
* @param \Closure $userResolver | |
* @return $this | |
* @static | |
*/ | |
public static function resolveUsersUsing($userResolver) | |
{ | |
return \Illuminate\Auth\AuthManager::resolveUsersUsing($userResolver); | |
} | |
/** | |
* Register a custom driver creator Closure. | |
* | |
* @param string $driver | |
* @param \Closure $callback | |
* @return $this | |
* @static | |
*/ | |
public static function extend($driver, $callback) | |
{ | |
return \Illuminate\Auth\AuthManager::extend($driver, $callback); | |
} | |
/** | |
* Register a custom provider creator Closure. | |
* | |
* @param string $name | |
* @param \Closure $callback | |
* @return $this | |
* @static | |
*/ | |
public static function provider($name, $callback) | |
{ | |
return \Illuminate\Auth\AuthManager::provider($name, $callback); | |
} | |
/** | |
* Create the user provider implementation for the driver. | |
* | |
* @param string|null $provider | |
* @return \Illuminate\Contracts\Auth\UserProvider|null | |
* @throws \InvalidArgumentException | |
* @static | |
*/ | |
public static function createUserProvider($provider = null) | |
{ | |
return \Illuminate\Auth\AuthManager::createUserProvider($provider); | |
} | |
/** | |
* Get the default user provider name. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getDefaultUserProvider() | |
{ | |
return \Illuminate\Auth\AuthManager::getDefaultUserProvider(); | |
} | |
/** | |
* Get the currently authenticated user. | |
* | |
* @return \App\User|null | |
* @static | |
*/ | |
public static function user() | |
{ | |
return \Illuminate\Auth\SessionGuard::user(); | |
} | |
/** | |
* Get the ID for the currently authenticated user. | |
* | |
* @return int|null | |
* @static | |
*/ | |
public static function id() | |
{ | |
return \Illuminate\Auth\SessionGuard::id(); | |
} | |
/** | |
* Log a user into the application without sessions or cookies. | |
* | |
* @param array $credentials | |
* @return bool | |
* @static | |
*/ | |
public static function once($credentials = array()) | |
{ | |
return \Illuminate\Auth\SessionGuard::once($credentials); | |
} | |
/** | |
* Log the given user ID into the application without sessions or cookies. | |
* | |
* @param mixed $id | |
* @return \App\User|false | |
* @static | |
*/ | |
public static function onceUsingId($id) | |
{ | |
return \Illuminate\Auth\SessionGuard::onceUsingId($id); | |
} | |
/** | |
* Validate a user's credentials. | |
* | |
* @param array $credentials | |
* @return bool | |
* @static | |
*/ | |
public static function validate($credentials = array()) | |
{ | |
return \Illuminate\Auth\SessionGuard::validate($credentials); | |
} | |
/** | |
* Attempt to authenticate using HTTP Basic Auth. | |
* | |
* @param string $field | |
* @param array $extraConditions | |
* @return \Symfony\Component\HttpFoundation\Response|null | |
* @static | |
*/ | |
public static function basic($field = 'email', $extraConditions = array()) | |
{ | |
return \Illuminate\Auth\SessionGuard::basic($field, $extraConditions); | |
} | |
/** | |
* Perform a stateless HTTP Basic login attempt. | |
* | |
* @param string $field | |
* @param array $extraConditions | |
* @return \Symfony\Component\HttpFoundation\Response|null | |
* @static | |
*/ | |
public static function onceBasic($field = 'email', $extraConditions = array()) | |
{ | |
return \Illuminate\Auth\SessionGuard::onceBasic($field, $extraConditions); | |
} | |
/** | |
* Attempt to authenticate a user using the given credentials. | |
* | |
* @param array $credentials | |
* @param bool $remember | |
* @return bool | |
* @static | |
*/ | |
public static function attempt($credentials = array(), $remember = false) | |
{ | |
return \Illuminate\Auth\SessionGuard::attempt($credentials, $remember); | |
} | |
/** | |
* Log the given user ID into the application. | |
* | |
* @param mixed $id | |
* @param bool $remember | |
* @return \App\User|false | |
* @static | |
*/ | |
public static function loginUsingId($id, $remember = false) | |
{ | |
return \Illuminate\Auth\SessionGuard::loginUsingId($id, $remember); | |
} | |
/** | |
* Log a user into the application. | |
* | |
* @param \Illuminate\Contracts\Auth\Authenticatable $user | |
* @param bool $remember | |
* @return void | |
* @static | |
*/ | |
public static function login($user, $remember = false) | |
{ | |
\Illuminate\Auth\SessionGuard::login($user, $remember); | |
} | |
/** | |
* Log the user out of the application. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function logout() | |
{ | |
\Illuminate\Auth\SessionGuard::logout(); | |
} | |
/** | |
* Register an authentication attempt event listener. | |
* | |
* @param mixed $callback | |
* @return void | |
* @static | |
*/ | |
public static function attempting($callback) | |
{ | |
\Illuminate\Auth\SessionGuard::attempting($callback); | |
} | |
/** | |
* Get the last user we attempted to authenticate. | |
* | |
* @return \App\User | |
* @static | |
*/ | |
public static function getLastAttempted() | |
{ | |
return \Illuminate\Auth\SessionGuard::getLastAttempted(); | |
} | |
/** | |
* Get a unique identifier for the auth session value. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getName() | |
{ | |
return \Illuminate\Auth\SessionGuard::getName(); | |
} | |
/** | |
* Get the name of the cookie used to store the "recaller". | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getRecallerName() | |
{ | |
return \Illuminate\Auth\SessionGuard::getRecallerName(); | |
} | |
/** | |
* Determine if the user was authenticated via "remember me" cookie. | |
* | |
* @return bool | |
* @static | |
*/ | |
public static function viaRemember() | |
{ | |
return \Illuminate\Auth\SessionGuard::viaRemember(); | |
} | |
/** | |
* Get the cookie creator instance used by the guard. | |
* | |
* @return \Illuminate\Contracts\Cookie\QueueingFactory | |
* @throws \RuntimeException | |
* @static | |
*/ | |
public static function getCookieJar() | |
{ | |
return \Illuminate\Auth\SessionGuard::getCookieJar(); | |
} | |
/** | |
* Set the cookie creator instance used by the guard. | |
* | |
* @param \Illuminate\Contracts\Cookie\QueueingFactory $cookie | |
* @return void | |
* @static | |
*/ | |
public static function setCookieJar($cookie) | |
{ | |
\Illuminate\Auth\SessionGuard::setCookieJar($cookie); | |
} | |
/** | |
* Get the event dispatcher instance. | |
* | |
* @return \Illuminate\Contracts\Events\Dispatcher | |
* @static | |
*/ | |
public static function getDispatcher() | |
{ | |
return \Illuminate\Auth\SessionGuard::getDispatcher(); | |
} | |
/** | |
* Set the event dispatcher instance. | |
* | |
* @param \Illuminate\Contracts\Events\Dispatcher $events | |
* @return void | |
* @static | |
*/ | |
public static function setDispatcher($events) | |
{ | |
\Illuminate\Auth\SessionGuard::setDispatcher($events); | |
} | |
/** | |
* Get the session store used by the guard. | |
* | |
* @return \Illuminate\Contracts\Session\Session. | |
* @static | |
*/ | |
public static function getSession() | |
{ | |
return \Illuminate\Auth\SessionGuard::getSession(); | |
} | |
/** | |
* Return the currently cached user. | |
* | |
* @return \App\User|null | |
* @static | |
*/ | |
public static function getUser() | |
{ | |
return \Illuminate\Auth\SessionGuard::getUser(); | |
} | |
/** | |
* Set the current user. | |
* | |
* @param \Illuminate\Contracts\Auth\Authenticatable $user | |
* @return $this | |
* @static | |
*/ | |
public static function setUser($user) | |
{ | |
return \Illuminate\Auth\SessionGuard::setUser($user); | |
} | |
/** | |
* Get the current request instance. | |
* | |
* @return \Symfony\Component\HttpFoundation\Request | |
* @static | |
*/ | |
public static function getRequest() | |
{ | |
return \Illuminate\Auth\SessionGuard::getRequest(); | |
} | |
/** | |
* Set the current request instance. | |
* | |
* @param \Symfony\Component\HttpFoundation\Request $request | |
* @return $this | |
* @static | |
*/ | |
public static function setRequest($request) | |
{ | |
return \Illuminate\Auth\SessionGuard::setRequest($request); | |
} | |
/** | |
* Determine if the current user is authenticated. | |
* | |
* @return \App\User | |
* @throws \Illuminate\Auth\AuthenticationException | |
* @static | |
*/ | |
public static function authenticate() | |
{ | |
return \Illuminate\Auth\SessionGuard::authenticate(); | |
} | |
/** | |
* Determine if the current user is authenticated. | |
* | |
* @return bool | |
* @static | |
*/ | |
public static function check() | |
{ | |
return \Illuminate\Auth\SessionGuard::check(); | |
} | |
/** | |
* Determine if the current user is a guest. | |
* | |
* @return bool | |
* @static | |
*/ | |
public static function guest() | |
{ | |
return \Illuminate\Auth\SessionGuard::guest(); | |
} | |
/** | |
* Get the user provider used by the guard. | |
* | |
* @return \Illuminate\Contracts\Auth\UserProvider | |
* @static | |
*/ | |
public static function getProvider() | |
{ | |
return \Illuminate\Auth\SessionGuard::getProvider(); | |
} | |
/** | |
* Set the user provider used by the guard. | |
* | |
* @param \Illuminate\Contracts\Auth\UserProvider $provider | |
* @return void | |
* @static | |
*/ | |
public static function setProvider($provider) | |
{ | |
\Illuminate\Auth\SessionGuard::setProvider($provider); | |
} | |
/** | |
* Register a custom macro. | |
* | |
* @param string $name | |
* @param object|callable $macro | |
* @return void | |
* @static | |
*/ | |
public static function macro($name, $macro) | |
{ | |
\Illuminate\Auth\SessionGuard::macro($name, $macro); | |
} | |
/** | |
* Mix another object into the class. | |
* | |
* @param object $mixin | |
* @return void | |
* @static | |
*/ | |
public static function mixin($mixin) | |
{ | |
\Illuminate\Auth\SessionGuard::mixin($mixin); | |
} | |
/** | |
* Checks if macro is registered. | |
* | |
* @param string $name | |
* @return bool | |
* @static | |
*/ | |
public static function hasMacro($name) | |
{ | |
return \Illuminate\Auth\SessionGuard::hasMacro($name); | |
} | |
} | |
class Blade { | |
/** | |
* Compile the view at the given path. | |
* | |
* @param string $path | |
* @return void | |
* @static | |
*/ | |
public static function compile($path = null) | |
{ | |
\Illuminate\View\Compilers\BladeCompiler::compile($path); | |
} | |
/** | |
* Get the path currently being compiled. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getPath() | |
{ | |
return \Illuminate\View\Compilers\BladeCompiler::getPath(); | |
} | |
/** | |
* Set the path currently being compiled. | |
* | |
* @param string $path | |
* @return void | |
* @static | |
*/ | |
public static function setPath($path) | |
{ | |
\Illuminate\View\Compilers\BladeCompiler::setPath($path); | |
} | |
/** | |
* Compile the given Blade template contents. | |
* | |
* @param string $value | |
* @return string | |
* @static | |
*/ | |
public static function compileString($value) | |
{ | |
return \Illuminate\View\Compilers\BladeCompiler::compileString($value); | |
} | |
/** | |
* Strip the parentheses from the given expression. | |
* | |
* @param string $expression | |
* @return string | |
* @static | |
*/ | |
public static function stripParentheses($expression) | |
{ | |
return \Illuminate\View\Compilers\BladeCompiler::stripParentheses($expression); | |
} | |
/** | |
* Register a custom Blade compiler. | |
* | |
* @param callable $compiler | |
* @return void | |
* @static | |
*/ | |
public static function extend($compiler) | |
{ | |
\Illuminate\View\Compilers\BladeCompiler::extend($compiler); | |
} | |
/** | |
* Get the extensions used by the compiler. | |
* | |
* @return array | |
* @static | |
*/ | |
public static function getExtensions() | |
{ | |
return \Illuminate\View\Compilers\BladeCompiler::getExtensions(); | |
} | |
/** | |
* Register an "if" statement directive. | |
* | |
* @param string $name | |
* @param callable $callback | |
* @return void | |
* @static | |
*/ | |
public static function if($name, $callback) | |
{ | |
\Illuminate\View\Compilers\BladeCompiler::if($name, $callback); | |
} | |
/** | |
* Check the result of a condition. | |
* | |
* @param string $name | |
* @param array $parameters | |
* @return bool | |
* @static | |
*/ | |
public static function check($name, $parameters = null) | |
{ | |
return \Illuminate\View\Compilers\BladeCompiler::check($name, $parameters); | |
} | |
/** | |
* Register a handler for custom directives. | |
* | |
* @param string $name | |
* @param callable $handler | |
* @return void | |
* @static | |
*/ | |
public static function directive($name, $handler) | |
{ | |
\Illuminate\View\Compilers\BladeCompiler::directive($name, $handler); | |
} | |
/** | |
* Get the list of custom directives. | |
* | |
* @return array | |
* @static | |
*/ | |
public static function getCustomDirectives() | |
{ | |
return \Illuminate\View\Compilers\BladeCompiler::getCustomDirectives(); | |
} | |
/** | |
* Set the echo format to be used by the compiler. | |
* | |
* @param string $format | |
* @return void | |
* @static | |
*/ | |
public static function setEchoFormat($format) | |
{ | |
\Illuminate\View\Compilers\BladeCompiler::setEchoFormat($format); | |
} | |
/** | |
* Get the path to the compiled version of a view. | |
* | |
* @param string $path | |
* @return string | |
* @static | |
*/ | |
public static function getCompiledPath($path) | |
{ | |
//Method inherited from \Illuminate\View\Compilers\Compiler | |
return \Illuminate\View\Compilers\BladeCompiler::getCompiledPath($path); | |
} | |
/** | |
* Determine if the view at the given path is expired. | |
* | |
* @param string $path | |
* @return bool | |
* @static | |
*/ | |
public static function isExpired($path) | |
{ | |
//Method inherited from \Illuminate\View\Compilers\Compiler | |
return \Illuminate\View\Compilers\BladeCompiler::isExpired($path); | |
} | |
/** | |
* Compile the default values for the echo statement. | |
* | |
* @param string $value | |
* @return string | |
* @static | |
*/ | |
public static function compileEchoDefaults($value) | |
{ | |
return \Illuminate\View\Compilers\BladeCompiler::compileEchoDefaults($value); | |
} | |
} | |
class Broadcast { | |
/** | |
* Register the routes for handling broadcast authentication and sockets. | |
* | |
* @param array|null $attributes | |
* @return void | |
* @static | |
*/ | |
public static function routes($attributes = null) | |
{ | |
\Illuminate\Broadcasting\BroadcastManager::routes($attributes); | |
} | |
/** | |
* Get the socket ID for the given request. | |
* | |
* @param \Illuminate\Http\Request|null $request | |
* @return string|null | |
* @static | |
*/ | |
public static function socket($request = null) | |
{ | |
return \Illuminate\Broadcasting\BroadcastManager::socket($request); | |
} | |
/** | |
* Begin broadcasting an event. | |
* | |
* @param mixed|null $event | |
* @return \Illuminate\Broadcasting\PendingBroadcast|void | |
* @static | |
*/ | |
public static function event($event = null) | |
{ | |
return \Illuminate\Broadcasting\BroadcastManager::event($event); | |
} | |
/** | |
* Queue the given event for broadcast. | |
* | |
* @param mixed $event | |
* @return void | |
* @static | |
*/ | |
public static function queue($event) | |
{ | |
\Illuminate\Broadcasting\BroadcastManager::queue($event); | |
} | |
/** | |
* Get a driver instance. | |
* | |
* @param string $driver | |
* @return mixed | |
* @static | |
*/ | |
public static function connection($driver = null) | |
{ | |
return \Illuminate\Broadcasting\BroadcastManager::connection($driver); | |
} | |
/** | |
* Get a driver instance. | |
* | |
* @param string $name | |
* @return mixed | |
* @static | |
*/ | |
public static function driver($name = null) | |
{ | |
return \Illuminate\Broadcasting\BroadcastManager::driver($name); | |
} | |
/** | |
* Get the default driver name. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getDefaultDriver() | |
{ | |
return \Illuminate\Broadcasting\BroadcastManager::getDefaultDriver(); | |
} | |
/** | |
* Set the default driver name. | |
* | |
* @param string $name | |
* @return void | |
* @static | |
*/ | |
public static function setDefaultDriver($name) | |
{ | |
\Illuminate\Broadcasting\BroadcastManager::setDefaultDriver($name); | |
} | |
/** | |
* Register a custom driver creator Closure. | |
* | |
* @param string $driver | |
* @param \Closure $callback | |
* @return $this | |
* @static | |
*/ | |
public static function extend($driver, $callback) | |
{ | |
return \Illuminate\Broadcasting\BroadcastManager::extend($driver, $callback); | |
} | |
} | |
class Bus { | |
/** | |
* Dispatch a command to its appropriate handler. | |
* | |
* @param mixed $command | |
* @return mixed | |
* @static | |
*/ | |
public static function dispatch($command) | |
{ | |
return \Illuminate\Bus\Dispatcher::dispatch($command); | |
} | |
/** | |
* Dispatch a command to its appropriate handler in the current process. | |
* | |
* @param mixed $command | |
* @param mixed $handler | |
* @return mixed | |
* @static | |
*/ | |
public static function dispatchNow($command, $handler = null) | |
{ | |
return \Illuminate\Bus\Dispatcher::dispatchNow($command, $handler); | |
} | |
/** | |
* Determine if the given command has a handler. | |
* | |
* @param mixed $command | |
* @return bool | |
* @static | |
*/ | |
public static function hasCommandHandler($command) | |
{ | |
return \Illuminate\Bus\Dispatcher::hasCommandHandler($command); | |
} | |
/** | |
* Retrieve the handler for a command. | |
* | |
* @param mixed $command | |
* @return bool|mixed | |
* @static | |
*/ | |
public static function getCommandHandler($command) | |
{ | |
return \Illuminate\Bus\Dispatcher::getCommandHandler($command); | |
} | |
/** | |
* Dispatch a command to its appropriate handler behind a queue. | |
* | |
* @param mixed $command | |
* @return mixed | |
* @throws \RuntimeException | |
* @static | |
*/ | |
public static function dispatchToQueue($command) | |
{ | |
return \Illuminate\Bus\Dispatcher::dispatchToQueue($command); | |
} | |
/** | |
* Set the pipes through which commands should be piped before dispatching. | |
* | |
* @param array $pipes | |
* @return $this | |
* @static | |
*/ | |
public static function pipeThrough($pipes) | |
{ | |
return \Illuminate\Bus\Dispatcher::pipeThrough($pipes); | |
} | |
/** | |
* Map a command to a handler. | |
* | |
* @param array $map | |
* @return $this | |
* @static | |
*/ | |
public static function map($map) | |
{ | |
return \Illuminate\Bus\Dispatcher::map($map); | |
} | |
} | |
class Cache { | |
/** | |
* Get a cache store instance by name. | |
* | |
* @param string|null $name | |
* @return \Illuminate\Contracts\Cache\Repository | |
* @static | |
*/ | |
public static function store($name = null) | |
{ | |
return \Illuminate\Cache\CacheManager::store($name); | |
} | |
/** | |
* Get a cache driver instance. | |
* | |
* @param string $driver | |
* @return mixed | |
* @static | |
*/ | |
public static function driver($driver = null) | |
{ | |
return \Illuminate\Cache\CacheManager::driver($driver); | |
} | |
/** | |
* Create a new cache repository with the given implementation. | |
* | |
* @param \Illuminate\Contracts\Cache\Store $store | |
* @return \Illuminate\Cache\Repository | |
* @static | |
*/ | |
public static function repository($store) | |
{ | |
return \Illuminate\Cache\CacheManager::repository($store); | |
} | |
/** | |
* Get the default cache driver name. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getDefaultDriver() | |
{ | |
return \Illuminate\Cache\CacheManager::getDefaultDriver(); | |
} | |
/** | |
* Set the default cache driver name. | |
* | |
* @param string $name | |
* @return void | |
* @static | |
*/ | |
public static function setDefaultDriver($name) | |
{ | |
\Illuminate\Cache\CacheManager::setDefaultDriver($name); | |
} | |
/** | |
* Register a custom driver creator Closure. | |
* | |
* @param string $driver | |
* @param \Closure $callback | |
* @return $this | |
* @static | |
*/ | |
public static function extend($driver, $callback) | |
{ | |
return \Illuminate\Cache\CacheManager::extend($driver, $callback); | |
} | |
/** | |
* Determine if an item exists in the cache. | |
* | |
* @param string $key | |
* @return bool | |
* @static | |
*/ | |
public static function has($key) | |
{ | |
return \Illuminate\Cache\Repository::has($key); | |
} | |
/** | |
* Retrieve an item from the cache by key. | |
* | |
* @param string $key | |
* @param mixed $default | |
* @return mixed | |
* @static | |
*/ | |
public static function get($key, $default = null) | |
{ | |
return \Illuminate\Cache\Repository::get($key, $default); | |
} | |
/** | |
* Retrieve multiple items from the cache by key. | |
* | |
* Items not found in the cache will have a null value. | |
* | |
* @param array $keys | |
* @return array | |
* @static | |
*/ | |
public static function many($keys) | |
{ | |
return \Illuminate\Cache\Repository::many($keys); | |
} | |
/** | |
* Obtains multiple cache items by their unique keys. | |
* | |
* @param \Psr\SimpleCache\iterable $keys A list of keys that can obtained in a single operation. | |
* @param mixed $default Default value to return for keys that do not exist. | |
* @return \Psr\SimpleCache\iterable A list of key => value pairs. Cache keys that do not exist or are stale will have $default as value. | |
* @throws \Psr\SimpleCache\InvalidArgumentException | |
* MUST be thrown if $keys is neither an array nor a Traversable, | |
* or if any of the $keys are not a legal value. | |
* @static | |
*/ | |
public static function getMultiple($keys, $default = null) | |
{ | |
return \Illuminate\Cache\Repository::getMultiple($keys, $default); | |
} | |
/** | |
* Retrieve an item from the cache and delete it. | |
* | |
* @param string $key | |
* @param mixed $default | |
* @return mixed | |
* @static | |
*/ | |
public static function pull($key, $default = null) | |
{ | |
return \Illuminate\Cache\Repository::pull($key, $default); | |
} | |
/** | |
* Store an item in the cache. | |
* | |
* @param string $key | |
* @param mixed $value | |
* @param \DateTimeInterface|\DateInterval|float|int $minutes | |
* @return void | |
* @static | |
*/ | |
public static function put($key, $value, $minutes = null) | |
{ | |
\Illuminate\Cache\Repository::put($key, $value, $minutes); | |
} | |
/** | |
* Persists data in the cache, uniquely referenced by a key with an optional expiration TTL time. | |
* | |
* @param string $key The key of the item to store. | |
* @param mixed $value The value of the item to store, must be serializable. | |
* @param null|int|\DateInterval $ttl Optional. The TTL value of this item. If no value is sent and | |
* the driver supports TTL then the library may set a default value | |
* for it or let the driver take care of that. | |
* @return bool True on success and false on failure. | |
* @throws \Psr\SimpleCache\InvalidArgumentException | |
* MUST be thrown if the $key string is not a legal value. | |
* @static | |
*/ | |
public static function set($key, $value, $ttl = null) | |
{ | |
return \Illuminate\Cache\Repository::set($key, $value, $ttl); | |
} | |
/** | |
* Store multiple items in the cache for a given number of minutes. | |
* | |
* @param array $values | |
* @param \DateTimeInterface|\DateInterval|float|int $minutes | |
* @return void | |
* @static | |
*/ | |
public static function putMany($values, $minutes) | |
{ | |
\Illuminate\Cache\Repository::putMany($values, $minutes); | |
} | |
/** | |
* Persists a set of key => value pairs in the cache, with an optional TTL. | |
* | |
* @param \Psr\SimpleCache\iterable $values A list of key => value pairs for a multiple-set operation. | |
* @param null|int|\DateInterval $ttl Optional. The TTL value of this item. If no value is sent and | |
* the driver supports TTL then the library may set a default value | |
* for it or let the driver take care of that. | |
* @return bool True on success and false on failure. | |
* @throws \Psr\SimpleCache\InvalidArgumentException | |
* MUST be thrown if $values is neither an array nor a Traversable, | |
* or if any of the $values are not a legal value. | |
* @static | |
*/ | |
public static function setMultiple($values, $ttl = null) | |
{ | |
return \Illuminate\Cache\Repository::setMultiple($values, $ttl); | |
} | |
/** | |
* Store an item in the cache if the key does not exist. | |
* | |
* @param string $key | |
* @param mixed $value | |
* @param \DateTimeInterface|\DateInterval|float|int $minutes | |
* @return bool | |
* @static | |
*/ | |
public static function add($key, $value, $minutes) | |
{ | |
return \Illuminate\Cache\Repository::add($key, $value, $minutes); | |
} | |
/** | |
* Increment the value of an item in the cache. | |
* | |
* @param string $key | |
* @param mixed $value | |
* @return int|bool | |
* @static | |
*/ | |
public static function increment($key, $value = 1) | |
{ | |
return \Illuminate\Cache\Repository::increment($key, $value); | |
} | |
/** | |
* Decrement the value of an item in the cache. | |
* | |
* @param string $key | |
* @param mixed $value | |
* @return int|bool | |
* @static | |
*/ | |
public static function decrement($key, $value = 1) | |
{ | |
return \Illuminate\Cache\Repository::decrement($key, $value); | |
} | |
/** | |
* Store an item in the cache indefinitely. | |
* | |
* @param string $key | |
* @param mixed $value | |
* @return void | |
* @static | |
*/ | |
public static function forever($key, $value) | |
{ | |
\Illuminate\Cache\Repository::forever($key, $value); | |
} | |
/** | |
* Get an item from the cache, or store the default value. | |
* | |
* @param string $key | |
* @param \DateTimeInterface|\DateInterval|float|int $minutes | |
* @param \Closure $callback | |
* @return mixed | |
* @static | |
*/ | |
public static function remember($key, $minutes, $callback) | |
{ | |
return \Illuminate\Cache\Repository::remember($key, $minutes, $callback); | |
} | |
/** | |
* Get an item from the cache, or store the default value forever. | |
* | |
* @param string $key | |
* @param \Closure $callback | |
* @return mixed | |
* @static | |
*/ | |
public static function sear($key, $callback) | |
{ | |
return \Illuminate\Cache\Repository::sear($key, $callback); | |
} | |
/** | |
* Get an item from the cache, or store the default value forever. | |
* | |
* @param string $key | |
* @param \Closure $callback | |
* @return mixed | |
* @static | |
*/ | |
public static function rememberForever($key, $callback) | |
{ | |
return \Illuminate\Cache\Repository::rememberForever($key, $callback); | |
} | |
/** | |
* Remove an item from the cache. | |
* | |
* @param string $key | |
* @return bool | |
* @static | |
*/ | |
public static function forget($key) | |
{ | |
return \Illuminate\Cache\Repository::forget($key); | |
} | |
/** | |
* Delete an item from the cache by its unique key. | |
* | |
* @param string $key The unique cache key of the item to delete. | |
* @return bool True if the item was successfully removed. False if there was an error. | |
* @throws \Psr\SimpleCache\InvalidArgumentException | |
* MUST be thrown if the $key string is not a legal value. | |
* @static | |
*/ | |
public static function delete($key) | |
{ | |
return \Illuminate\Cache\Repository::delete($key); | |
} | |
/** | |
* Deletes multiple cache items in a single operation. | |
* | |
* @param \Psr\SimpleCache\iterable $keys A list of string-based keys to be deleted. | |
* @return bool True if the items were successfully removed. False if there was an error. | |
* @throws \Psr\SimpleCache\InvalidArgumentException | |
* MUST be thrown if $keys is neither an array nor a Traversable, | |
* or if any of the $keys are not a legal value. | |
* @static | |
*/ | |
public static function deleteMultiple($keys) | |
{ | |
return \Illuminate\Cache\Repository::deleteMultiple($keys); | |
} | |
/** | |
* Wipes clean the entire cache's keys. | |
* | |
* @return bool True on success and false on failure. | |
* @static | |
*/ | |
public static function clear() | |
{ | |
return \Illuminate\Cache\Repository::clear(); | |
} | |
/** | |
* Begin executing a new tags operation if the store supports it. | |
* | |
* @param array|mixed $names | |
* @return \Illuminate\Cache\TaggedCache | |
* @throws \BadMethodCallException | |
* @static | |
*/ | |
public static function tags($names) | |
{ | |
return \Illuminate\Cache\Repository::tags($names); | |
} | |
/** | |
* Get the default cache time. | |
* | |
* @return float|int | |
* @static | |
*/ | |
public static function getDefaultCacheTime() | |
{ | |
return \Illuminate\Cache\Repository::getDefaultCacheTime(); | |
} | |
/** | |
* Set the default cache time in minutes. | |
* | |
* @param float|int $minutes | |
* @return $this | |
* @static | |
*/ | |
public static function setDefaultCacheTime($minutes) | |
{ | |
return \Illuminate\Cache\Repository::setDefaultCacheTime($minutes); | |
} | |
/** | |
* Get the cache store implementation. | |
* | |
* @return \Illuminate\Contracts\Cache\Store | |
* @static | |
*/ | |
public static function getStore() | |
{ | |
return \Illuminate\Cache\Repository::getStore(); | |
} | |
/** | |
* Set the event dispatcher instance. | |
* | |
* @param \Illuminate\Contracts\Events\Dispatcher $events | |
* @return void | |
* @static | |
*/ | |
public static function setEventDispatcher($events) | |
{ | |
\Illuminate\Cache\Repository::setEventDispatcher($events); | |
} | |
/** | |
* Determine if a cached value exists. | |
* | |
* @param string $key | |
* @return bool | |
* @static | |
*/ | |
public static function offsetExists($key) | |
{ | |
return \Illuminate\Cache\Repository::offsetExists($key); | |
} | |
/** | |
* Retrieve an item from the cache by key. | |
* | |
* @param string $key | |
* @return mixed | |
* @static | |
*/ | |
public static function offsetGet($key) | |
{ | |
return \Illuminate\Cache\Repository::offsetGet($key); | |
} | |
/** | |
* Store an item in the cache for the default time. | |
* | |
* @param string $key | |
* @param mixed $value | |
* @return void | |
* @static | |
*/ | |
public static function offsetSet($key, $value) | |
{ | |
\Illuminate\Cache\Repository::offsetSet($key, $value); | |
} | |
/** | |
* Remove an item from the cache. | |
* | |
* @param string $key | |
* @return void | |
* @static | |
*/ | |
public static function offsetUnset($key) | |
{ | |
\Illuminate\Cache\Repository::offsetUnset($key); | |
} | |
/** | |
* Register a custom macro. | |
* | |
* @param string $name | |
* @param object|callable $macro | |
* @return void | |
* @static | |
*/ | |
public static function macro($name, $macro) | |
{ | |
\Illuminate\Cache\Repository::macro($name, $macro); | |
} | |
/** | |
* Mix another object into the class. | |
* | |
* @param object $mixin | |
* @return void | |
* @static | |
*/ | |
public static function mixin($mixin) | |
{ | |
\Illuminate\Cache\Repository::mixin($mixin); | |
} | |
/** | |
* Checks if macro is registered. | |
* | |
* @param string $name | |
* @return bool | |
* @static | |
*/ | |
public static function hasMacro($name) | |
{ | |
return \Illuminate\Cache\Repository::hasMacro($name); | |
} | |
/** | |
* Dynamically handle calls to the class. | |
* | |
* @param string $method | |
* @param array $parameters | |
* @return mixed | |
* @throws \BadMethodCallException | |
* @static | |
*/ | |
public static function macroCall($method, $parameters) | |
{ | |
return \Illuminate\Cache\Repository::macroCall($method, $parameters); | |
} | |
/** | |
* Remove all items from the cache. | |
* | |
* @return bool | |
* @static | |
*/ | |
public static function flush() | |
{ | |
return \Illuminate\Cache\FileStore::flush(); | |
} | |
/** | |
* Get the Filesystem instance. | |
* | |
* @return \Illuminate\Filesystem\Filesystem | |
* @static | |
*/ | |
public static function getFilesystem() | |
{ | |
return \Illuminate\Cache\FileStore::getFilesystem(); | |
} | |
/** | |
* Get the working directory of the cache. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getDirectory() | |
{ | |
return \Illuminate\Cache\FileStore::getDirectory(); | |
} | |
/** | |
* Get the cache key prefix. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getPrefix() | |
{ | |
return \Illuminate\Cache\FileStore::getPrefix(); | |
} | |
} | |
class Config { | |
/** | |
* Determine if the given configuration value exists. | |
* | |
* @param string $key | |
* @return bool | |
* @static | |
*/ | |
public static function has($key) | |
{ | |
return \Illuminate\Config\Repository::has($key); | |
} | |
/** | |
* Get the specified configuration value. | |
* | |
* @param array|string $key | |
* @param mixed $default | |
* @return mixed | |
* @static | |
*/ | |
public static function get($key, $default = null) | |
{ | |
return \Illuminate\Config\Repository::get($key, $default); | |
} | |
/** | |
* Get many configuration values. | |
* | |
* @param array $keys | |
* @return array | |
* @static | |
*/ | |
public static function getMany($keys) | |
{ | |
return \Illuminate\Config\Repository::getMany($keys); | |
} | |
/** | |
* Set a given configuration value. | |
* | |
* @param array|string $key | |
* @param mixed $value | |
* @return void | |
* @static | |
*/ | |
public static function set($key, $value = null) | |
{ | |
\Illuminate\Config\Repository::set($key, $value); | |
} | |
/** | |
* Prepend a value onto an array configuration value. | |
* | |
* @param string $key | |
* @param mixed $value | |
* @return void | |
* @static | |
*/ | |
public static function prepend($key, $value) | |
{ | |
\Illuminate\Config\Repository::prepend($key, $value); | |
} | |
/** | |
* Push a value onto an array configuration value. | |
* | |
* @param string $key | |
* @param mixed $value | |
* @return void | |
* @static | |
*/ | |
public static function push($key, $value) | |
{ | |
\Illuminate\Config\Repository::push($key, $value); | |
} | |
/** | |
* Get all of the configuration items for the application. | |
* | |
* @return array | |
* @static | |
*/ | |
public static function all() | |
{ | |
return \Illuminate\Config\Repository::all(); | |
} | |
/** | |
* Determine if the given configuration option exists. | |
* | |
* @param string $key | |
* @return bool | |
* @static | |
*/ | |
public static function offsetExists($key) | |
{ | |
return \Illuminate\Config\Repository::offsetExists($key); | |
} | |
/** | |
* Get a configuration option. | |
* | |
* @param string $key | |
* @return mixed | |
* @static | |
*/ | |
public static function offsetGet($key) | |
{ | |
return \Illuminate\Config\Repository::offsetGet($key); | |
} | |
/** | |
* Set a configuration option. | |
* | |
* @param string $key | |
* @param mixed $value | |
* @return void | |
* @static | |
*/ | |
public static function offsetSet($key, $value) | |
{ | |
\Illuminate\Config\Repository::offsetSet($key, $value); | |
} | |
/** | |
* Unset a configuration option. | |
* | |
* @param string $key | |
* @return void | |
* @static | |
*/ | |
public static function offsetUnset($key) | |
{ | |
\Illuminate\Config\Repository::offsetUnset($key); | |
} | |
} | |
class Cookie { | |
/** | |
* Create a new cookie instance. | |
* | |
* @param string $name | |
* @param string $value | |
* @param int $minutes | |
* @param string $path | |
* @param string $domain | |
* @param bool $secure | |
* @param bool $httpOnly | |
* @param bool $raw | |
* @param string|null $sameSite | |
* @return \Symfony\Component\HttpFoundation\Cookie | |
* @static | |
*/ | |
public static function make($name, $value, $minutes = 0, $path = null, $domain = null, $secure = false, $httpOnly = true, $raw = false, $sameSite = null) | |
{ | |
return \Illuminate\Cookie\CookieJar::make($name, $value, $minutes, $path, $domain, $secure, $httpOnly, $raw, $sameSite); | |
} | |
/** | |
* Create a cookie that lasts "forever" (five years). | |
* | |
* @param string $name | |
* @param string $value | |
* @param string $path | |
* @param string $domain | |
* @param bool $secure | |
* @param bool $httpOnly | |
* @param bool $raw | |
* @param string|null $sameSite | |
* @return \Symfony\Component\HttpFoundation\Cookie | |
* @static | |
*/ | |
public static function forever($name, $value, $path = null, $domain = null, $secure = false, $httpOnly = true, $raw = false, $sameSite = null) | |
{ | |
return \Illuminate\Cookie\CookieJar::forever($name, $value, $path, $domain, $secure, $httpOnly, $raw, $sameSite); | |
} | |
/** | |
* Expire the given cookie. | |
* | |
* @param string $name | |
* @param string $path | |
* @param string $domain | |
* @return \Symfony\Component\HttpFoundation\Cookie | |
* @static | |
*/ | |
public static function forget($name, $path = null, $domain = null) | |
{ | |
return \Illuminate\Cookie\CookieJar::forget($name, $path, $domain); | |
} | |
/** | |
* Determine if a cookie has been queued. | |
* | |
* @param string $key | |
* @return bool | |
* @static | |
*/ | |
public static function hasQueued($key) | |
{ | |
return \Illuminate\Cookie\CookieJar::hasQueued($key); | |
} | |
/** | |
* Get a queued cookie instance. | |
* | |
* @param string $key | |
* @param mixed $default | |
* @return \Symfony\Component\HttpFoundation\Cookie | |
* @static | |
*/ | |
public static function queued($key, $default = null) | |
{ | |
return \Illuminate\Cookie\CookieJar::queued($key, $default); | |
} | |
/** | |
* Queue a cookie to send with the next response. | |
* | |
* @param array $parameters | |
* @return void | |
* @static | |
*/ | |
public static function queue($parameters = null) | |
{ | |
\Illuminate\Cookie\CookieJar::queue($parameters); | |
} | |
/** | |
* Remove a cookie from the queue. | |
* | |
* @param string $name | |
* @return void | |
* @static | |
*/ | |
public static function unqueue($name) | |
{ | |
\Illuminate\Cookie\CookieJar::unqueue($name); | |
} | |
/** | |
* Set the default path and domain for the jar. | |
* | |
* @param string $path | |
* @param string $domain | |
* @param bool $secure | |
* @param string $sameSite | |
* @return $this | |
* @static | |
*/ | |
public static function setDefaultPathAndDomain($path, $domain, $secure = false, $sameSite = null) | |
{ | |
return \Illuminate\Cookie\CookieJar::setDefaultPathAndDomain($path, $domain, $secure, $sameSite); | |
} | |
/** | |
* Get the cookies which have been queued for the next request. | |
* | |
* @return array | |
* @static | |
*/ | |
public static function getQueuedCookies() | |
{ | |
return \Illuminate\Cookie\CookieJar::getQueuedCookies(); | |
} | |
} | |
class Crypt { | |
/** | |
* Determine if the given key and cipher combination is valid. | |
* | |
* @param string $key | |
* @param string $cipher | |
* @return bool | |
* @static | |
*/ | |
public static function supported($key, $cipher) | |
{ | |
return \Illuminate\Encryption\Encrypter::supported($key, $cipher); | |
} | |
/** | |
* Create a new encryption key for the given cipher. | |
* | |
* @param string $cipher | |
* @return string | |
* @static | |
*/ | |
public static function generateKey($cipher) | |
{ | |
return \Illuminate\Encryption\Encrypter::generateKey($cipher); | |
} | |
/** | |
* Encrypt the given value. | |
* | |
* @param mixed $value | |
* @param bool $serialize | |
* @return string | |
* @throws \Illuminate\Contracts\Encryption\EncryptException | |
* @static | |
*/ | |
public static function encrypt($value, $serialize = true) | |
{ | |
return \Illuminate\Encryption\Encrypter::encrypt($value, $serialize); | |
} | |
/** | |
* Encrypt a string without serialization. | |
* | |
* @param string $value | |
* @return string | |
* @static | |
*/ | |
public static function encryptString($value) | |
{ | |
return \Illuminate\Encryption\Encrypter::encryptString($value); | |
} | |
/** | |
* Decrypt the given value. | |
* | |
* @param mixed $payload | |
* @param bool $unserialize | |
* @return string | |
* @throws \Illuminate\Contracts\Encryption\DecryptException | |
* @static | |
*/ | |
public static function decrypt($payload, $unserialize = true) | |
{ | |
return \Illuminate\Encryption\Encrypter::decrypt($payload, $unserialize); | |
} | |
/** | |
* Decrypt the given string without unserialization. | |
* | |
* @param string $payload | |
* @return string | |
* @static | |
*/ | |
public static function decryptString($payload) | |
{ | |
return \Illuminate\Encryption\Encrypter::decryptString($payload); | |
} | |
/** | |
* Get the encryption key. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getKey() | |
{ | |
return \Illuminate\Encryption\Encrypter::getKey(); | |
} | |
} | |
class DB { | |
/** | |
* Get a database connection instance. | |
* | |
* @param string $name | |
* @return \Illuminate\Database\Connection | |
* @static | |
*/ | |
public static function connection($name = null) | |
{ | |
return \Illuminate\Database\DatabaseManager::connection($name); | |
} | |
/** | |
* Disconnect from the given database and remove from local cache. | |
* | |
* @param string $name | |
* @return void | |
* @static | |
*/ | |
public static function purge($name = null) | |
{ | |
\Illuminate\Database\DatabaseManager::purge($name); | |
} | |
/** | |
* Disconnect from the given database. | |
* | |
* @param string $name | |
* @return void | |
* @static | |
*/ | |
public static function disconnect($name = null) | |
{ | |
\Illuminate\Database\DatabaseManager::disconnect($name); | |
} | |
/** | |
* Reconnect to the given database. | |
* | |
* @param string $name | |
* @return \Illuminate\Database\Connection | |
* @static | |
*/ | |
public static function reconnect($name = null) | |
{ | |
return \Illuminate\Database\DatabaseManager::reconnect($name); | |
} | |
/** | |
* Get the default connection name. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getDefaultConnection() | |
{ | |
return \Illuminate\Database\DatabaseManager::getDefaultConnection(); | |
} | |
/** | |