/_ide_helper.php
Last active Dec 10, 2019
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); | |
| } | |
| /** | |