Lumen IDE Helper
<?php | |
/** | |
* A helper file for Laravel 5, to provide autocomplete information to your IDE | |
* Generated for Laravel Lumen (5.1.1) (Laravel Components 5.1.*) on 2015-08-18. | |
* | |
* @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"); | |
class App extends \Illuminate\Support\Facades\App{ | |
/** | |
* Get the version number of the application. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function version(){ | |
return \Laravel\Lumen\Application::version(); | |
} | |
/** | |
* Get or check the current application environment. | |
* | |
* @param mixed | |
* @return string | |
* @static | |
*/ | |
public static function environment(){ | |
return \Laravel\Lumen\Application::environment(); | |
} | |
/** | |
* Determine if the application is currently down for maintenance. | |
* | |
* @return bool | |
* @static | |
*/ | |
public static function isDownForMaintenance(){ | |
return \Laravel\Lumen\Application::isDownForMaintenance(); | |
} | |
/** | |
* Register all of the configured providers. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function registerConfiguredProviders(){ | |
\Laravel\Lumen\Application::registerConfiguredProviders(); | |
} | |
/** | |
* Get the path to the cached "compiled.php" file. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getCachedCompilePath(){ | |
return \Laravel\Lumen\Application::getCachedCompilePath(); | |
} | |
/** | |
* Get the path to the cached services.json file. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getCachedServicesPath(){ | |
return \Laravel\Lumen\Application::getCachedServicesPath(); | |
} | |
/** | |
* 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 \Laravel\Lumen\Application::register($provider, $options, $force); | |
} | |
/** | |
* Register a deferred provider and service. | |
* | |
* @param string $provider | |
* @param string $service | |
* @return void | |
* @static | |
*/ | |
public static function registerDeferredProvider($provider, $service = null){ | |
\Laravel\Lumen\Application::registerDeferredProvider($provider, $service); | |
} | |
/** | |
* Boot the application's service providers. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function boot(){ | |
\Laravel\Lumen\Application::boot(); | |
} | |
/** | |
* Register a new boot listener. | |
* | |
* @param mixed $callback | |
* @return void | |
* @static | |
*/ | |
public static function booting($callback){ | |
\Laravel\Lumen\Application::booting($callback); | |
} | |
/** | |
* Register a new "booted" listener. | |
* | |
* @param mixed $callback | |
* @return void | |
* @static | |
*/ | |
public static function booted($callback){ | |
\Laravel\Lumen\Application::booted($callback); | |
} | |
/** | |
* 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()){ | |
\Laravel\Lumen\Application::abort($code, $message, $headers); | |
} | |
/** | |
* Resolve the given type from the container. | |
* | |
* @param string $abstract | |
* @param array $parameters | |
* @return mixed | |
* @static | |
*/ | |
public static function make($abstract, $parameters = array()){ | |
return \Laravel\Lumen\Application::make($abstract, $parameters); | |
} | |
/** | |
* Load a configuration file into the application. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function configure($name){ | |
\Laravel\Lumen\Application::configure($name); | |
} | |
/** | |
* Register the facades for the application. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function withFacades(){ | |
\Laravel\Lumen\Application::withFacades(); | |
} | |
/** | |
* Load the Eloquent library for the application. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function withEloquent(){ | |
\Laravel\Lumen\Application::withEloquent(); | |
} | |
/** | |
* Register a set of routes with a set of shared attributes. | |
* | |
* @param array $attributes | |
* @param \Closure $callback | |
* @return void | |
* @static | |
*/ | |
public static function group($attributes, $callback){ | |
\Laravel\Lumen\Application::group($attributes, $callback); | |
} | |
/** | |
* Register a route with the application. | |
* | |
* @param string $uri | |
* @param mixed $action | |
* @return $this | |
* @static | |
*/ | |
public static function get($uri, $action){ | |
return \Laravel\Lumen\Application::get($uri, $action); | |
} | |
/** | |
* Register a route with the application. | |
* | |
* @param string $uri | |
* @param mixed $action | |
* @return $this | |
* @static | |
*/ | |
public static function post($uri, $action){ | |
return \Laravel\Lumen\Application::post($uri, $action); | |
} | |
/** | |
* Register a route with the application. | |
* | |
* @param string $uri | |
* @param mixed $action | |
* @return $this | |
* @static | |
*/ | |
public static function put($uri, $action){ | |
return \Laravel\Lumen\Application::put($uri, $action); | |
} | |
/** | |
* Register a route with the application. | |
* | |
* @param string $uri | |
* @param mixed $action | |
* @return $this | |
* @static | |
*/ | |
public static function patch($uri, $action){ | |
return \Laravel\Lumen\Application::patch($uri, $action); | |
} | |
/** | |
* Register a route with the application. | |
* | |
* @param string $uri | |
* @param mixed $action | |
* @return $this | |
* @static | |
*/ | |
public static function delete($uri, $action){ | |
return \Laravel\Lumen\Application::delete($uri, $action); | |
} | |
/** | |
* Register a route with the application. | |
* | |
* @param string $uri | |
* @param mixed $action | |
* @return $this | |
* @static | |
*/ | |
public static function options($uri, $action){ | |
return \Laravel\Lumen\Application::options($uri, $action); | |
} | |
/** | |
* Add a route to the collection. | |
* | |
* @param string $method | |
* @param string $uri | |
* @param mixed $action | |
* @static | |
*/ | |
public static function addRoute($method, $uri, $action){ | |
return \Laravel\Lumen\Application::addRoute($method, $uri, $action); | |
} | |
/** | |
* Add new middleware to the application. | |
* | |
* @param array $middleware | |
* @return $this | |
* @static | |
*/ | |
public static function middleware($middleware){ | |
return \Laravel\Lumen\Application::middleware($middleware); | |
} | |
/** | |
* Define the route middleware for the application. | |
* | |
* @param array $middleware | |
* @return $this | |
* @static | |
*/ | |
public static function routeMiddleware($middleware){ | |
return \Laravel\Lumen\Application::routeMiddleware($middleware); | |
} | |
/** | |
* {@inheritdoc} | |
* | |
* @static | |
*/ | |
public static function handle($request, $type = 1, $catch = true){ | |
return \Laravel\Lumen\Application::handle($request, $type, $catch); | |
} | |
/** | |
* Run the application and send the response. | |
* | |
* @param \Laravel\Lumen\SymfonyRequest|null $request | |
* @return void | |
* @static | |
*/ | |
public static function run($request = null){ | |
\Laravel\Lumen\Application::run($request); | |
} | |
/** | |
* Dispatch the incoming request. | |
* | |
* @param \Laravel\Lumen\SymfonyRequest|null $request | |
* @return \Laravel\Lumen\Response | |
* @static | |
*/ | |
public static function dispatch($request = null){ | |
return \Laravel\Lumen\Application::dispatch($request); | |
} | |
/** | |
* Set the FastRoute dispatcher instance. | |
* | |
* @param \FastRoute\Dispatcher $dispatcher | |
* @return void | |
* @static | |
*/ | |
public static function setDispatcher($dispatcher){ | |
\Laravel\Lumen\Application::setDispatcher($dispatcher); | |
} | |
/** | |
* Prepare the response for sending. | |
* | |
* @param mixed $response | |
* @return \Laravel\Lumen\Response | |
* @static | |
*/ | |
public static function prepareResponse($response){ | |
return \Laravel\Lumen\Application::prepareResponse($response); | |
} | |
/** | |
* Get the current HTTP path info. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getPathInfo(){ | |
return \Laravel\Lumen\Application::getPathInfo(); | |
} | |
/** | |
* Get the base path for the application. | |
* | |
* @param string $path | |
* @return string | |
* @static | |
*/ | |
public static function basePath($path = null){ | |
return \Laravel\Lumen\Application::basePath($path); | |
} | |
/** | |
* Get the storage path for the application. | |
* | |
* @param string $path | |
* @return string | |
* @static | |
*/ | |
public static function storagePath($path = null){ | |
return \Laravel\Lumen\Application::storagePath($path); | |
} | |
/** | |
* Set a custom storage path for the application. | |
* | |
* @param string $path | |
* @return $this | |
* @static | |
*/ | |
public static function useStoragePath($path){ | |
return \Laravel\Lumen\Application::useStoragePath($path); | |
} | |
/** | |
* Get the database path for the application. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function databasePath(){ | |
return \Laravel\Lumen\Application::databasePath(); | |
} | |
/** | |
* Set a custom configuration path for the application. | |
* | |
* @param string $path | |
* @return $this | |
* @static | |
*/ | |
public static function useConfigPath($path){ | |
return \Laravel\Lumen\Application::useConfigPath($path); | |
} | |
/** | |
* Get the resource path for the application. | |
* | |
* @param string $path | |
* @return string | |
* @static | |
*/ | |
public static function resourcePath($path = null){ | |
return \Laravel\Lumen\Application::resourcePath($path); | |
} | |
/** | |
* Set a custom resource path for the application. | |
* | |
* @param string $path | |
* @return $this | |
* @static | |
*/ | |
public static function useResourcePath($path){ | |
return \Laravel\Lumen\Application::useResourcePath($path); | |
} | |
/** | |
* Determine if the application is running in the console. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function runningInConsole(){ | |
return \Laravel\Lumen\Application::runningInConsole(); | |
} | |
/** | |
* Prepare the application to execute a console command. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function prepareForConsoleCommand(){ | |
\Laravel\Lumen\Application::prepareForConsoleCommand(); | |
} | |
/** | |
* Get the raw routes for the application. | |
* | |
* @return array | |
* @static | |
*/ | |
public static function getRoutes(){ | |
return \Laravel\Lumen\Application::getRoutes(); | |
} | |
/** | |
* Set the cached routes. | |
* | |
* @param array $routes | |
* @return void | |
* @static | |
*/ | |
public static function setRoutes($routes){ | |
\Laravel\Lumen\Application::setRoutes($routes); | |
} | |
/** | |
* Get the HTML from the Lumen welcome screen. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function welcome(){ | |
return \Laravel\Lumen\Application::welcome(); | |
} | |
/** | |
* 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 \Laravel\Lumen\Application::when($concrete); | |
} | |
/** | |
* Determine if the given abstract type has been bound. | |
* | |
* @param string $abstract | |
* @return bool | |
* @static | |
*/ | |
public static function bound($abstract){ | |
//Method inherited from \Illuminate\Container\Container | |
return \Laravel\Lumen\Application::bound($abstract); | |
} | |
/** | |
* 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 \Laravel\Lumen\Application::resolved($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 \Laravel\Lumen\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 | |
\Laravel\Lumen\Application::bind($abstract, $concrete, $shared); | |
} | |
/** | |
* Add a contextual binding to the container. | |
* | |
* @param string $concrete | |
* @param string $abstract | |
* @param \Closure|string $implementation | |
* @static | |
*/ | |
public static function addContextualBinding($concrete, $abstract, $implementation){ | |
//Method inherited from \Illuminate\Container\Container | |
return \Laravel\Lumen\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 | |
\Laravel\Lumen\Application::bindIf($abstract, $concrete, $shared); | |
} | |
/** | |
* Register a shared binding in the container. | |
* | |
* @param string $abstract | |
* @param \Closure|string|null $concrete | |
* @return void | |
* @static | |
*/ | |
public static function singleton($abstract, $concrete = null){ | |
//Method inherited from \Illuminate\Container\Container | |
\Laravel\Lumen\Application::singleton($abstract, $concrete); | |
} | |
/** | |
* Wrap a Closure such that it is shared. | |
* | |
* @param \Closure $closure | |
* @return \Closure | |
* @static | |
*/ | |
public static function share($closure){ | |
//Method inherited from \Illuminate\Container\Container | |
return \Laravel\Lumen\Application::share($closure); | |
} | |
/** | |
* Bind a shared Closure into the container. | |
* | |
* @param string $abstract | |
* @param \Closure $closure | |
* @return void | |
* @deprecated since version 5.1. Use singleton instead. | |
* @static | |
*/ | |
public static function bindShared($abstract, $closure){ | |
//Method inherited from \Illuminate\Container\Container | |
\Laravel\Lumen\Application::bindShared($abstract, $closure); | |
} | |
/** | |
* "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 | |
\Laravel\Lumen\Application::extend($abstract, $closure); | |
} | |
/** | |
* Register an existing instance as shared in the container. | |
* | |
* @param string $abstract | |
* @param mixed $instance | |
* @return void | |
* @static | |
*/ | |
public static function instance($abstract, $instance){ | |
//Method inherited from \Illuminate\Container\Container | |
\Laravel\Lumen\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 | |
\Laravel\Lumen\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 \Laravel\Lumen\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 | |
\Laravel\Lumen\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 \Laravel\Lumen\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 \Laravel\Lumen\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 \Laravel\Lumen\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 \Laravel\Lumen\Application::call($callback, $parameters, $defaultMethod); | |
} | |
/** | |
* Instantiate a concrete instance of the given type. | |
* | |
* @param string $concrete | |
* @param array $parameters | |
* @return mixed | |
* @throws \Illuminate\Contracts\Container\BindingResolutionException | |
* @static | |
*/ | |
public static function build($concrete, $parameters = array()){ | |
//Method inherited from \Illuminate\Container\Container | |
return \Laravel\Lumen\Application::build($concrete, $parameters); | |
} | |
/** | |
* 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 | |
\Laravel\Lumen\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 | |
\Laravel\Lumen\Application::afterResolving($abstract, $callback); | |
} | |
/** | |
* 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 \Laravel\Lumen\Application::isShared($abstract); | |
} | |
/** | |
* Get the container's bindings. | |
* | |
* @return array | |
* @static | |
*/ | |
public static function getBindings(){ | |
//Method inherited from \Illuminate\Container\Container | |
return \Laravel\Lumen\Application::getBindings(); | |
} | |
/** | |
* 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 | |
\Laravel\Lumen\Application::forgetInstance($abstract); | |
} | |
/** | |
* Clear all of the instances from the container. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function forgetInstances(){ | |
//Method inherited from \Illuminate\Container\Container | |
\Laravel\Lumen\Application::forgetInstances(); | |
} | |
/** | |
* Flush the container of all bindings and resolved instances. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function flush(){ | |
//Method inherited from \Illuminate\Container\Container | |
\Laravel\Lumen\Application::flush(); | |
} | |
/** | |
* Set the globally available instance of the container. | |
* | |
* @return static | |
* @static | |
*/ | |
public static function getInstance(){ | |
//Method inherited from \Illuminate\Container\Container | |
return \Laravel\Lumen\Application::getInstance(); | |
} | |
/** | |
* Set the shared instance of the container. | |
* | |
* @param \Illuminate\Contracts\Container\Container $container | |
* @return void | |
* @static | |
*/ | |
public static function setInstance($container){ | |
//Method inherited from \Illuminate\Container\Container | |
\Laravel\Lumen\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 \Laravel\Lumen\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 \Laravel\Lumen\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 | |
\Laravel\Lumen\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 | |
\Laravel\Lumen\Application::offsetUnset($key); | |
} | |
} | |
class Auth extends \Illuminate\Support\Facades\Auth{ | |
/** | |
* Create an instance of the database driver. | |
* | |
* @return \Illuminate\Auth\Guard | |
* @static | |
*/ | |
public static function createDatabaseDriver(){ | |
return \Illuminate\Auth\AuthManager::createDatabaseDriver(); | |
} | |
/** | |
* Create an instance of the Eloquent driver. | |
* | |
* @return \Illuminate\Auth\Guard | |
* @static | |
*/ | |
public static function createEloquentDriver(){ | |
return \Illuminate\Auth\AuthManager::createEloquentDriver(); | |
} | |
/** | |
* Get the default authentication driver name. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getDefaultDriver(){ | |
return \Illuminate\Auth\AuthManager::getDefaultDriver(); | |
} | |
/** | |
* Set the default authentication driver name. | |
* | |
* @param string $name | |
* @return void | |
* @static | |
*/ | |
public static function setDefaultDriver($name){ | |
\Illuminate\Auth\AuthManager::setDefaultDriver($name); | |
} | |
/** | |
* Get a driver instance. | |
* | |
* @param string $driver | |
* @return mixed | |
* @static | |
*/ | |
public static function driver($driver = null){ | |
//Method inherited from \Illuminate\Support\Manager | |
return \Illuminate\Auth\AuthManager::driver($driver); | |
} | |
/** | |
* Register a custom driver creator Closure. | |
* | |
* @param string $driver | |
* @param \Closure $callback | |
* @return $this | |
* @static | |
*/ | |
public static function extend($driver, $callback){ | |
//Method inherited from \Illuminate\Support\Manager | |
return \Illuminate\Auth\AuthManager::extend($driver, $callback); | |
} | |
/** | |
* Get all of the created "drivers". | |
* | |
* @return array | |
* @static | |
*/ | |
public static function getDrivers(){ | |
//Method inherited from \Illuminate\Support\Manager | |
return \Illuminate\Auth\AuthManager::getDrivers(); | |
} | |
/** | |
* Determine if the current user is authenticated. | |
* | |
* @return bool | |
* @static | |
*/ | |
public static function check(){ | |
return \Illuminate\Auth\Guard::check(); | |
} | |
/** | |
* Determine if the current user is a guest. | |
* | |
* @return bool | |
* @static | |
*/ | |
public static function guest(){ | |
return \Illuminate\Auth\Guard::guest(); | |
} | |
/** | |
* Get the currently authenticated user. | |
* | |
* @return \App\User|null | |
* @static | |
*/ | |
public static function user(){ | |
return \Illuminate\Auth\Guard::user(); | |
} | |
/** | |
* Get the ID for the currently authenticated user. | |
* | |
* @return int|null | |
* @static | |
*/ | |
public static function id(){ | |
return \Illuminate\Auth\Guard::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\Guard::once($credentials); | |
} | |
/** | |
* Validate a user's credentials. | |
* | |
* @param array $credentials | |
* @return bool | |
* @static | |
*/ | |
public static function validate($credentials = array()){ | |
return \Illuminate\Auth\Guard::validate($credentials); | |
} | |
/** | |
* Attempt to authenticate using HTTP Basic Auth. | |
* | |
* @param string $field | |
* @return \Symfony\Component\HttpFoundation\Response|null | |
* @static | |
*/ | |
public static function basic($field = 'email'){ | |
return \Illuminate\Auth\Guard::basic($field); | |
} | |
/** | |
* Perform a stateless HTTP Basic login attempt. | |
* | |
* @param string $field | |
* @return \Symfony\Component\HttpFoundation\Response|null | |
* @static | |
*/ | |
public static function onceBasic($field = 'email'){ | |
return \Illuminate\Auth\Guard::onceBasic($field); | |
} | |
/** | |
* Attempt to authenticate a user using the given credentials. | |
* | |
* @param array $credentials | |
* @param bool $remember | |
* @param bool $login | |
* @return bool | |
* @static | |
*/ | |
public static function attempt($credentials = array(), $remember = false, $login = true){ | |
return \Illuminate\Auth\Guard::attempt($credentials, $remember, $login); | |
} | |
/** | |
* Register an authentication attempt event listener. | |
* | |
* @param mixed $callback | |
* @return void | |
* @static | |
*/ | |
public static function attempting($callback){ | |
\Illuminate\Auth\Guard::attempting($callback); | |
} | |
/** | |
* 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\Guard::login($user, $remember); | |
} | |
/** | |
* Log the given user ID into the application. | |
* | |
* @param mixed $id | |
* @param bool $remember | |
* @return \App\User | |
* @static | |
*/ | |
public static function loginUsingId($id, $remember = false){ | |
return \Illuminate\Auth\Guard::loginUsingId($id, $remember); | |
} | |
/** | |
* Log the given user ID into the application without sessions or cookies. | |
* | |
* @param mixed $id | |
* @return bool | |
* @static | |
*/ | |
public static function onceUsingId($id){ | |
return \Illuminate\Auth\Guard::onceUsingId($id); | |
} | |
/** | |
* Log the user out of the application. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function logout(){ | |
\Illuminate\Auth\Guard::logout(); | |
} | |
/** | |
* Get the cookie creator instance used by the guard. | |
* | |
* @return \Illuminate\Contracts\Cookie\QueueingFactory | |
* @throws \RuntimeException | |
* @static | |
*/ | |
public static function getCookieJar(){ | |
return \Illuminate\Auth\Guard::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\Guard::setCookieJar($cookie); | |
} | |
/** | |
* Get the event dispatcher instance. | |
* | |
* @return \Illuminate\Contracts\Events\Dispatcher | |
* @static | |
*/ | |
public static function getDispatcher(){ | |
return \Illuminate\Auth\Guard::getDispatcher(); | |
} | |
/** | |
* Set the event dispatcher instance. | |
* | |
* @param \Illuminate\Contracts\Events\Dispatcher $events | |
* @return void | |
* @static | |
*/ | |
public static function setDispatcher($events){ | |
\Illuminate\Auth\Guard::setDispatcher($events); | |
} | |
/** | |
* Get the session store used by the guard. | |
* | |
* @return \Illuminate\Session\Store | |
* @static | |
*/ | |
public static function getSession(){ | |
return \Illuminate\Auth\Guard::getSession(); | |
} | |
/** | |
* Get the user provider used by the guard. | |
* | |
* @return \Illuminate\Contracts\Auth\UserProvider | |
* @static | |
*/ | |
public static function getProvider(){ | |
return \Illuminate\Auth\Guard::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\Guard::setProvider($provider); | |
} | |
/** | |
* Return the currently cached user. | |
* | |
* @return \App\User|null | |
* @static | |
*/ | |
public static function getUser(){ | |
return \Illuminate\Auth\Guard::getUser(); | |
} | |
/** | |
* Set the current user. | |
* | |
* @param \Illuminate\Contracts\Auth\Authenticatable $user | |
* @return void | |
* @static | |
*/ | |
public static function setUser($user){ | |
\Illuminate\Auth\Guard::setUser($user); | |
} | |
/** | |
* Get the current request instance. | |
* | |
* @return \Symfony\Component\HttpFoundation\Request | |
* @static | |
*/ | |
public static function getRequest(){ | |
return \Illuminate\Auth\Guard::getRequest(); | |
} | |
/** | |
* Set the current request instance. | |
* | |
* @param \Symfony\Component\HttpFoundation\Request $request | |
* @return $this | |
* @static | |
*/ | |
public static function setRequest($request){ | |
return \Illuminate\Auth\Guard::setRequest($request); | |
} | |
/** | |
* Get the last user we attempted to authenticate. | |
* | |
* @return \App\User | |
* @static | |
*/ | |
public static function getLastAttempted(){ | |
return \Illuminate\Auth\Guard::getLastAttempted(); | |
} | |
/** | |
* Get a unique identifier for the auth session value. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getName(){ | |
return \Illuminate\Auth\Guard::getName(); | |
} | |
/** | |
* Get the name of the cookie used to store the "recaller". | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getRecallerName(){ | |
return \Illuminate\Auth\Guard::getRecallerName(); | |
} | |
/** | |
* Determine if the user was authenticated via "remember me" cookie. | |
* | |
* @return bool | |
* @static | |
*/ | |
public static function viaRemember(){ | |
return \Illuminate\Auth\Guard::viaRemember(); | |
} | |
} | |
class Bus extends \Illuminate\Support\Facades\Bus{ | |
/** | |
* Marshal a command and dispatch it to its appropriate handler. | |
* | |
* @param mixed $command | |
* @param array $array | |
* @return mixed | |
* @static | |
*/ | |
public static function dispatchFromArray($command, $array){ | |
return \Illuminate\Bus\Dispatcher::dispatchFromArray($command, $array); | |
} | |
/** | |
* Marshal a command and dispatch it to its appropriate handler. | |
* | |
* @param mixed $command | |
* @param \ArrayAccess $source | |
* @param array $extras | |
* @return mixed | |
* @static | |
*/ | |
public static function dispatchFrom($command, $source, $extras = array()){ | |
return \Illuminate\Bus\Dispatcher::dispatchFrom($command, $source, $extras); | |
} | |
/** | |
* Dispatch a command to its appropriate handler. | |
* | |
* @param mixed $command | |
* @param \Closure|null $afterResolving | |
* @return mixed | |
* @static | |
*/ | |
public static function dispatch($command, $afterResolving = null){ | |
return \Illuminate\Bus\Dispatcher::dispatch($command, $afterResolving); | |
} | |
/** | |
* Dispatch a command to its appropriate handler in the current process. | |
* | |
* @param mixed $command | |
* @param \Closure|null $afterResolving | |
* @return mixed | |
* @static | |
*/ | |
public static function dispatchNow($command, $afterResolving = null){ | |
return \Illuminate\Bus\Dispatcher::dispatchNow($command, $afterResolving); | |
} | |
/** | |
* 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); | |
} | |
/** | |
* Get the handler instance for the given command. | |
* | |
* @param mixed $command | |
* @return mixed | |
* @static | |
*/ | |
public static function resolveHandler($command){ | |
return \Illuminate\Bus\Dispatcher::resolveHandler($command); | |
} | |
/** | |
* Get the handler class for the given command. | |
* | |
* @param mixed $command | |
* @return string | |
* @static | |
*/ | |
public static function getHandlerClass($command){ | |
return \Illuminate\Bus\Dispatcher::getHandlerClass($command); | |
} | |
/** | |
* Get the handler method for the given command. | |
* | |
* @param mixed $command | |
* @return string | |
* @static | |
*/ | |
public static function getHandlerMethod($command){ | |
return \Illuminate\Bus\Dispatcher::getHandlerMethod($command); | |
} | |
/** | |
* Register command-to-handler mappings. | |
* | |
* @param array $commands | |
* @return void | |
* @static | |
*/ | |
public static function maps($commands){ | |
\Illuminate\Bus\Dispatcher::maps($commands); | |
} | |
/** | |
* Register a fallback mapper callback. | |
* | |
* @param \Closure $mapper | |
* @return void | |
* @static | |
*/ | |
public static function mapUsing($mapper){ | |
\Illuminate\Bus\Dispatcher::mapUsing($mapper); | |
} | |
/** | |
* Map the command to a handler within a given root namespace. | |
* | |
* @param mixed $command | |
* @param string $commandNamespace | |
* @param string $handlerNamespace | |
* @return string | |
* @static | |
*/ | |
public static function simpleMapping($command, $commandNamespace, $handlerNamespace){ | |
return \Illuminate\Bus\Dispatcher::simpleMapping($command, $commandNamespace, $handlerNamespace); | |
} | |
/** | |
* 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); | |
} | |
} | |
class DB extends \Illuminate\Support\Facades\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(); | |
} | |
/** | |
* Set the default connection name. | |
* | |
* @param string $name | |
* @return void | |
* @static | |
*/ | |
public static function setDefaultConnection($name){ | |
\Illuminate\Database\DatabaseManager::setDefaultConnection($name); | |
} | |
/** | |
* Register an extension connection resolver. | |
* | |
* @param string $name | |
* @param callable $resolver | |
* @return void | |
* @static | |
*/ | |
public static function extend($name, $resolver){ | |
\Illuminate\Database\DatabaseManager::extend($name, $resolver); | |
} | |
/** | |
* Return all of the created connections. | |
* | |
* @return array | |
* @static | |
*/ | |
public static function getConnections(){ | |
return \Illuminate\Database\DatabaseManager::getConnections(); | |
} | |
/** | |
* Get a schema builder instance for the connection. | |
* | |
* @return \Illuminate\Database\Schema\MySqlBuilder | |
* @static | |
*/ | |
public static function getSchemaBuilder(){ | |
return \Illuminate\Database\MySqlConnection::getSchemaBuilder(); | |
} | |
/** | |
* Set the query grammar to the default implementation. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function useDefaultQueryGrammar(){ | |
//Method inherited from \Illuminate\Database\Connection | |
\Illuminate\Database\MySqlConnection::useDefaultQueryGrammar(); | |
} | |
/** | |
* Set the schema grammar to the default implementation. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function useDefaultSchemaGrammar(){ | |
//Method inherited from \Illuminate\Database\Connection | |
\Illuminate\Database\MySqlConnection::useDefaultSchemaGrammar(); | |
} | |
/** | |
* Set the query post processor to the default implementation. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function useDefaultPostProcessor(){ | |
//Method inherited from \Illuminate\Database\Connection | |
\Illuminate\Database\MySqlConnection::useDefaultPostProcessor(); | |
} | |
/** | |
* Begin a fluent query against a database table. | |
* | |
* @param string $table | |
* @return \Illuminate\Database\Query\Builder | |
* @static | |
*/ | |
public static function table($table){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::table($table); | |
} | |
/** | |
* Get a new raw query expression. | |
* | |
* @param mixed $value | |
* @return \Illuminate\Database\Query\Expression | |
* @static | |
*/ | |
public static function raw($value){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::raw($value); | |
} | |
/** | |
* Run a select statement and return a single result. | |
* | |
* @param string $query | |
* @param array $bindings | |
* @return mixed | |
* @static | |
*/ | |
public static function selectOne($query, $bindings = array()){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::selectOne($query, $bindings); | |
} | |
/** | |
* Run a select statement against the database. | |
* | |
* @param string $query | |
* @param array $bindings | |
* @return array | |
* @static | |
*/ | |
public static function selectFromWriteConnection($query, $bindings = array()){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::selectFromWriteConnection($query, $bindings); | |
} | |
/** | |
* Run a select statement against the database. | |
* | |
* @param string $query | |
* @param array $bindings | |
* @param bool $useReadPdo | |
* @return array | |
* @static | |
*/ | |
public static function select($query, $bindings = array(), $useReadPdo = true){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::select($query, $bindings, $useReadPdo); | |
} | |
/** | |
* Run an insert statement against the database. | |
* | |
* @param string $query | |
* @param array $bindings | |
* @return bool | |
* @static | |
*/ | |
public static function insert($query, $bindings = array()){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::insert($query, $bindings); | |
} | |
/** | |
* Run an update statement against the database. | |
* | |
* @param string $query | |
* @param array $bindings | |
* @return int | |
* @static | |
*/ | |
public static function update($query, $bindings = array()){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::update($query, $bindings); | |
} | |
/** | |
* Run a delete statement against the database. | |
* | |
* @param string $query | |
* @param array $bindings | |
* @return int | |
* @static | |
*/ | |
public static function delete($query, $bindings = array()){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::delete($query, $bindings); | |
} | |
/** | |
* Execute an SQL statement and return the boolean result. | |
* | |
* @param string $query | |
* @param array $bindings | |
* @return bool | |
* @static | |
*/ | |
public static function statement($query, $bindings = array()){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::statement($query, $bindings); | |
} | |
/** | |
* Run an SQL statement and get the number of rows affected. | |
* | |
* @param string $query | |
* @param array $bindings | |
* @return int | |
* @static | |
*/ | |
public static function affectingStatement($query, $bindings = array()){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::affectingStatement($query, $bindings); | |
} | |
/** | |
* Run a raw, unprepared query against the PDO connection. | |
* | |
* @param string $query | |
* @return bool | |
* @static | |
*/ | |
public static function unprepared($query){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::unprepared($query); | |
} | |
/** | |
* Prepare the query bindings for execution. | |
* | |
* @param array $bindings | |
* @return array | |
* @static | |
*/ | |
public static function prepareBindings($bindings){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::prepareBindings($bindings); | |
} | |
/** | |
* Execute a Closure within a transaction. | |
* | |
* @param \Closure $callback | |
* @return mixed | |
* @throws \Throwable | |
* @static | |
*/ | |
public static function transaction($callback){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::transaction($callback); | |
} | |
/** | |
* Start a new database transaction. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function beginTransaction(){ | |
//Method inherited from \Illuminate\Database\Connection | |
\Illuminate\Database\MySqlConnection::beginTransaction(); | |
} | |
/** | |
* Commit the active database transaction. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function commit(){ | |
//Method inherited from \Illuminate\Database\Connection | |
\Illuminate\Database\MySqlConnection::commit(); | |
} | |
/** | |
* Rollback the active database transaction. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function rollBack(){ | |
//Method inherited from \Illuminate\Database\Connection | |
\Illuminate\Database\MySqlConnection::rollBack(); | |
} | |
/** | |
* Get the number of active transactions. | |
* | |
* @return int | |
* @static | |
*/ | |
public static function transactionLevel(){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::transactionLevel(); | |
} | |
/** | |
* Execute the given callback in "dry run" mode. | |
* | |
* @param \Closure $callback | |
* @return array | |
* @static | |
*/ | |
public static function pretend($callback){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::pretend($callback); | |
} | |
/** | |
* Log a query in the connection's query log. | |
* | |
* @param string $query | |
* @param array $bindings | |
* @param float|null $time | |
* @return void | |
* @static | |
*/ | |
public static function logQuery($query, $bindings, $time = null){ | |
//Method inherited from \Illuminate\Database\Connection | |
\Illuminate\Database\MySqlConnection::logQuery($query, $bindings, $time); | |
} | |
/** | |
* Register a database query listener with the connection. | |
* | |
* @param \Closure $callback | |
* @return void | |
* @static | |
*/ | |
public static function listen($callback){ | |
//Method inherited from \Illuminate\Database\Connection | |
\Illuminate\Database\MySqlConnection::listen($callback); | |
} | |
/** | |
* Get a Doctrine Schema Column instance. | |
* | |
* @param string $table | |
* @param string $column | |
* @return \Doctrine\DBAL\Schema\Column | |
* @static | |
*/ | |
public static function getDoctrineColumn($table, $column){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::getDoctrineColumn($table, $column); | |
} | |
/** | |
* Get the Doctrine DBAL schema manager for the connection. | |
* | |
* @return \Doctrine\DBAL\Schema\AbstractSchemaManager | |
* @static | |
*/ | |
public static function getDoctrineSchemaManager(){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::getDoctrineSchemaManager(); | |
} | |
/** | |
* Get the Doctrine DBAL database connection instance. | |
* | |
* @return \Doctrine\DBAL\Connection | |
* @static | |
*/ | |
public static function getDoctrineConnection(){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::getDoctrineConnection(); | |
} | |
/** | |
* Get the current PDO connection. | |
* | |
* @return \PDO | |
* @static | |
*/ | |
public static function getPdo(){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::getPdo(); | |
} | |
/** | |
* Get the current PDO connection used for reading. | |
* | |
* @return \PDO | |
* @static | |
*/ | |
public static function getReadPdo(){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::getReadPdo(); | |
} | |
/** | |
* Set the PDO connection. | |
* | |
* @param \PDO|null $pdo | |
* @return $this | |
* @static | |
*/ | |
public static function setPdo($pdo){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::setPdo($pdo); | |
} | |
/** | |
* Set the PDO connection used for reading. | |
* | |
* @param \PDO|null $pdo | |
* @return $this | |
* @static | |
*/ | |
public static function setReadPdo($pdo){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::setReadPdo($pdo); | |
} | |
/** | |
* Set the reconnect instance on the connection. | |
* | |
* @param callable $reconnector | |
* @return $this | |
* @static | |
*/ | |
public static function setReconnector($reconnector){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::setReconnector($reconnector); | |
} | |
/** | |
* Get the database connection name. | |
* | |
* @return string|null | |
* @static | |
*/ | |
public static function getName(){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::getName(); | |
} | |
/** | |
* Get an option from the configuration options. | |
* | |
* @param string $option | |
* @return mixed | |
* @static | |
*/ | |
public static function getConfig($option){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::getConfig($option); | |
} | |
/** | |
* Get the PDO driver name. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getDriverName(){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::getDriverName(); | |
} | |
/** | |
* Get the query grammar used by the connection. | |
* | |
* @return \Illuminate\Database\Query\Grammars\Grammar | |
* @static | |
*/ | |
public static function getQueryGrammar(){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::getQueryGrammar(); | |
} | |
/** | |
* Set the query grammar used by the connection. | |
* | |
* @param \Illuminate\Database\Query\Grammars\Grammar $grammar | |
* @return void | |
* @static | |
*/ | |
public static function setQueryGrammar($grammar){ | |
//Method inherited from \Illuminate\Database\Connection | |
\Illuminate\Database\MySqlConnection::setQueryGrammar($grammar); | |
} | |
/** | |
* Get the schema grammar used by the connection. | |
* | |
* @return \Illuminate\Database\Schema\Grammars\Grammar | |
* @static | |
*/ | |
public static function getSchemaGrammar(){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::getSchemaGrammar(); | |
} | |
/** | |
* Set the schema grammar used by the connection. | |
* | |
* @param \Illuminate\Database\Schema\Grammars\Grammar $grammar | |
* @return void | |
* @static | |
*/ | |
public static function setSchemaGrammar($grammar){ | |
//Method inherited from \Illuminate\Database\Connection | |
\Illuminate\Database\MySqlConnection::setSchemaGrammar($grammar); | |
} | |
/** | |
* Get the query post processor used by the connection. | |
* | |
* @return \Illuminate\Database\Query\Processors\Processor | |
* @static | |
*/ | |
public static function getPostProcessor(){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::getPostProcessor(); | |
} | |
/** | |
* Set the query post processor used by the connection. | |
* | |
* @param \Illuminate\Database\Query\Processors\Processor $processor | |
* @return void | |
* @static | |
*/ | |
public static function setPostProcessor($processor){ | |
//Method inherited from \Illuminate\Database\Connection | |
\Illuminate\Database\MySqlConnection::setPostProcessor($processor); | |
} | |
/** | |
* Get the event dispatcher used by the connection. | |
* | |
* @return \Illuminate\Contracts\Events\Dispatcher | |
* @static | |
*/ | |
public static function getEventDispatcher(){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::getEventDispatcher(); | |
} | |
/** | |
* Set the event dispatcher instance on the connection. | |
* | |
* @param \Illuminate\Contracts\Events\Dispatcher $events | |
* @return void | |
* @static | |
*/ | |
public static function setEventDispatcher($events){ | |
//Method inherited from \Illuminate\Database\Connection | |
\Illuminate\Database\MySqlConnection::setEventDispatcher($events); | |
} | |
/** | |
* Determine if the connection in a "dry run". | |
* | |
* @return bool | |
* @static | |
*/ | |
public static function pretending(){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::pretending(); | |
} | |
/** | |
* Get the default fetch mode for the connection. | |
* | |
* @return int | |
* @static | |
*/ | |
public static function getFetchMode(){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::getFetchMode(); | |
} | |
/** | |
* Set the default fetch mode for the connection. | |
* | |
* @param int $fetchMode | |
* @return int | |
* @static | |
*/ | |
public static function setFetchMode($fetchMode){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::setFetchMode($fetchMode); | |
} | |
/** | |
* Get the connection query log. | |
* | |
* @return array | |
* @static | |
*/ | |
public static function getQueryLog(){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::getQueryLog(); | |
} | |
/** | |
* Clear the query log. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function flushQueryLog(){ | |
//Method inherited from \Illuminate\Database\Connection | |
\Illuminate\Database\MySqlConnection::flushQueryLog(); | |
} | |
/** | |
* Enable the query log on the connection. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function enableQueryLog(){ | |
//Method inherited from \Illuminate\Database\Connection | |
\Illuminate\Database\MySqlConnection::enableQueryLog(); | |
} | |
/** | |
* Disable the query log on the connection. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function disableQueryLog(){ | |
//Method inherited from \Illuminate\Database\Connection | |
\Illuminate\Database\MySqlConnection::disableQueryLog(); | |
} | |
/** | |
* Determine whether we're logging queries. | |
* | |
* @return bool | |
* @static | |
*/ | |
public static function logging(){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::logging(); | |
} | |
/** | |
* Get the name of the connected database. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getDatabaseName(){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::getDatabaseName(); | |
} | |
/** | |
* Set the name of the connected database. | |
* | |
* @param string $database | |
* @return string | |
* @static | |
*/ | |
public static function setDatabaseName($database){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::setDatabaseName($database); | |
} | |
/** | |
* Get the table prefix for the connection. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getTablePrefix(){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::getTablePrefix(); | |
} | |
/** | |
* Set the table prefix in use by the connection. | |
* | |
* @param string $prefix | |
* @return void | |
* @static | |
*/ | |
public static function setTablePrefix($prefix){ | |
//Method inherited from \Illuminate\Database\Connection | |
\Illuminate\Database\MySqlConnection::setTablePrefix($prefix); | |
} | |
/** | |
* Set the table prefix and return the grammar. | |
* | |
* @param \Illuminate\Database\Grammar $grammar | |
* @return \Illuminate\Database\Grammar | |
* @static | |
*/ | |
public static function withTablePrefix($grammar){ | |
//Method inherited from \Illuminate\Database\Connection | |
return \Illuminate\Database\MySqlConnection::withTablePrefix($grammar); | |
} | |
} | |
class Cache extends \Illuminate\Support\Facades\Cache{ | |
/** | |
* Get a cache store instance by name. | |
* | |
* @param string|null $name | |
* @return mixed | |
* @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); | |
} | |
/** | |
* 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 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 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 \DateTime|int $minutes | |
* @return void | |
* @static | |
*/ | |
public static function put($key, $value, $minutes){ | |
\Illuminate\Cache\Repository::put($key, $value, $minutes); | |
} | |
/** | |
* Store an item in the cache if the key does not exist. | |
* | |
* @param string $key | |
* @param mixed $value | |
* @param \DateTime|int $minutes | |
* @return bool | |
* @static | |
*/ | |
public static function add($key, $value, $minutes){ | |
return \Illuminate\Cache\Repository::add($key, $value, $minutes); | |
} | |
/** | |
* 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 \DateTime|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); | |
} | |
/** | |
* Get the default cache time. | |
* | |
* @return int | |
* @static | |
*/ | |
public static function getDefaultCacheTime(){ | |
return \Illuminate\Cache\Repository::getDefaultCacheTime(); | |
} | |
/** | |
* Set the default cache time in minutes. | |
* | |
* @param int $minutes | |
* @return void | |
* @static | |
*/ | |
public static function setDefaultCacheTime($minutes){ | |
\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(); | |
} | |
/** | |
* 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 callable $macro | |
* @return void | |
* @static | |
*/ | |
public static function macro($name, $macro){ | |
\Illuminate\Cache\Repository::macro($name, $macro); | |
} | |
/** | |
* 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); | |
} | |
/** | |
* Increment the value of an item in the cache. | |
* | |
* @param string $key | |
* @param mixed $value | |
* @return int | |
* @static | |
*/ | |
public static function increment($key, $value = 1){ | |
return \Illuminate\Cache\FileStore::increment($key, $value); | |
} | |
/** | |
* Decrement the value of an item in the cache. | |
* | |
* @param string $key | |
* @param mixed $value | |
* @return int | |
* @static | |
*/ | |
public static function decrement($key, $value = 1){ | |
return \Illuminate\Cache\FileStore::decrement($key, $value); | |
} | |
/** | |
* Remove all items from the cache. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function flush(){ | |
\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 Cookie extends \Illuminate\Support\Facades\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 | |
* @return \Symfony\Component\HttpFoundation\Cookie | |
* @static | |
*/ | |
public static function make($name, $value, $minutes = 0, $path = null, $domain = null, $secure = false, $httpOnly = true){ | |
return \Illuminate\Cookie\CookieJar::make($name, $value, $minutes, $path, $domain, $secure, $httpOnly); | |
} | |
/** | |
* 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 | |
* @return \Symfony\Component\HttpFoundation\Cookie | |
* @static | |
*/ | |
public static function forever($name, $value, $path = null, $domain = null, $secure = false, $httpOnly = true){ | |
return \Illuminate\Cookie\CookieJar::forever($name, $value, $path, $domain, $secure, $httpOnly); | |
} | |
/** | |
* 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 mixed | |
* @return void | |
* @static | |
*/ | |
public static function queue(){ | |
\Illuminate\Cookie\CookieJar::queue(); | |
} | |
/** | |
* Remove a cookie from the queue. | |
* | |
* @param string $name | |
* @static | |
*/ | |
public static function unqueue($name){ | |
return \Illuminate\Cookie\CookieJar::unqueue($name); | |
} | |
/** | |
* Set the default path and domain for the jar. | |
* | |
* @param string $path | |
* @param string $domain | |
* @return $this | |
* @static | |
*/ | |
public static function setDefaultPathAndDomain($path, $domain){ | |
return \Illuminate\Cookie\CookieJar::setDefaultPathAndDomain($path, $domain); | |
} | |
/** | |
* 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 extends \Illuminate\Support\Facades\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); | |
} | |
/** | |
* Encrypt the given value. | |
* | |
* @param string $value | |
* @return string | |
* @static | |
*/ | |
public static function encrypt($value){ | |
return \Illuminate\Encryption\Encrypter::encrypt($value); | |
} | |
/** | |
* Decrypt the given value. | |
* | |
* @param string $payload | |
* @return string | |
* @static | |
*/ | |
public static function decrypt($payload){ | |
return \Illuminate\Encryption\Encrypter::decrypt($payload); | |
} | |
} | |
class Event extends \Illuminate\Support\Facades\Event{ | |
/** | |
* Register an event listener with the dispatcher. | |
* | |
* @param string|array $events | |
* @param mixed $listener | |
* @param int $priority | |
* @return void | |
* @static | |
*/ | |
public static function listen($events, $listener, $priority = 0){ | |
\Illuminate\Events\Dispatcher::listen($events, $listener, $priority); | |
} | |
/** | |
* Determine if a given event has listeners. | |
* | |
* @param string $eventName | |
* @return bool | |
* @static | |
*/ | |
public static function hasListeners($eventName){ | |
return \Illuminate\Events\Dispatcher::hasListeners($eventName); | |
} | |
/** | |
* Register an event and payload to be fired later. | |
* | |
* @param string $event | |
* @param array $payload | |
* @return void | |
* @static | |
*/ | |
public static function push($event, $payload = array()){ | |
\Illuminate\Events\Dispatcher::push($event, $payload); | |
} | |
/** | |
* Register an event subscriber with the dispatcher. | |
* | |
* @param object|string $subscriber | |
* @return void | |
* @static | |
*/ | |
public static function subscribe($subscriber){ | |
\Illuminate\Events\Dispatcher::subscribe($subscriber); | |
} | |
/** | |
* Fire an event until the first non-null response is returned. | |
* | |
* @param string|object $event | |
* @param array $payload | |
* @return mixed | |
* @static | |
*/ | |
public static function until($event, $payload = array()){ | |
return \Illuminate\Events\Dispatcher::until($event, $payload); | |
} | |
/** | |
* Flush a set of pushed events. | |
* | |
* @param string $event | |
* @return void | |
* @static | |
*/ | |
public static function flush($event){ | |
\Illuminate\Events\Dispatcher::flush($event); | |
} | |
/** | |
* Get the event that is currently firing. | |
* | |
* @return string | |
* @static | |
*/ | |
public static function firing(){ | |
return \Illuminate\Events\Dispatcher::firing(); | |
} | |
/** | |
* Fire an event and call the listeners. | |
* | |
* @param string|object $event | |
* @param mixed $payload | |
* @param bool $halt | |
* @return array|null | |
* @static | |
*/ | |
public static function fire($event, $payload = array(), $halt = false){ | |
return \Illuminate\Events\Dispatcher::fire($event, $payload, $halt); | |
} | |
/** | |
* Get all of the listeners for a given event name. | |
* | |
* @param string $eventName | |
* @return array | |
* @static | |
*/ | |
public static function getListeners($eventName){ | |
return \Illuminate\Events\Dispatcher::getListeners($eventName); | |
} | |
/** | |
* Register an event listener with the dispatcher. | |
* | |
* @param mixed $listener | |
* @return mixed | |
* @static | |
*/ | |
public static function makeListener($listener){ | |
return \Illuminate\Events\Dispatcher::makeListener($listener); | |
} | |
/** | |
* Create a class based listener using the IoC container. | |
* | |
* @param mixed $listener | |
* @return \Closure | |
* @static | |
*/ | |
public static function createClassListener($listener){ | |
return \Illuminate\Events\Dispatcher::createClassListener($listener); | |
} | |
/** | |
* Remove a set of listeners from the dispatcher. | |
* | |
* @param string $event | |
* @return void | |
* @static | |
*/ | |
public static function forget($event){ | |
\Illuminate\Events\Dispatcher::forget($event); | |
} | |
/** | |
* Forget all of the pushed listeners. | |
* | |
* @return void | |
* @static | |
*/ | |
public static function forgetPushed(){ | |
\Illuminate\Events\Dispatcher::forgetPushed(); | |
} | |
/** | |
* Set the queue resolver implementation. | |
* | |
* @param callable $resolver | |
* @return $this | |
* @static | |
*/ | |
public static function setQueueResolver($resolver){ | |
return \Illuminate\Events\Dispatcher::setQueueResolver($resolver); | |
} | |
} | |
class Hash extends \Illuminate\Support\Facades\Hash{ | |
/** | |
* Hash the given value. | |
* | |
* @param string $value | |
* @param array $options | |
* @return string | |
* @throws \RuntimeException | |
* @static | |
*/ | |
public static function make($value, $options = array()){ | |
return \Illuminate\Hashing\BcryptHasher::make($value, $options); | |
} | |
/** | |
* Check the given plain value against a hash. | |
* | |
* @param string $value | |
* @param string $hashedValue | |
* @param array $options | |
* @return bool | |
* @static | |
*/ | |
public static function check($value, $hashedValue, $options = array()){ | |
return \Illuminate\Hashing\BcryptHasher::check($value, $hashedValue, $options); | |
} | |
/** | |
* Check if the given hash has been hashed using the given options. | |
* | |
* @param string $hashedValue | |
* @param array $options | |
* @return bool | |
* @static | |
*/ | |
public static function needsRehash($hashedValue, $options = array()){ | |
return \Illuminate\Hashing\BcryptHasher::needsRehash($hashedValue, $options); | |
} | |
/** | |
* Set the default password work factor. | |
* | |
* @param int $rounds | |
* @return $this | |
* @static | |
*/ | |
public static function setRounds($rounds){ | |
return \Illuminate\Hashing\BcryptHasher::setRounds($rounds); | |
} | |
} | |
class Log extends \Illuminate\Support\Facades\Log{ | |
/** | |
* Adds a log record at the DEBUG level. | |
* | |
* @param string $message The log message | |
* @param array $context The log context | |
* @return Boolean Whether the record has been processed | |
* @static | |
*/ | |
public static function debug($message, $context = array()){ | |
return \Monolog\Logger::debug($message, $context); | |
} | |
/** | |
* Adds a log record at the INFO level. | |
* | |
* @param string $message The log message | |
* @param array $context The log context | |
* @return Boolean Whether the record has been processed | |
* @static | |
*/ | |
public static function info($message, $context = array()){ | |
return \Monolog\Logger::info($message, $context); | |
} | |
/** | |
* Adds a log record at the NOTICE level. | |
* | |
* @param string $message The log message | |
* @param array $context The log context | |
* @return Boolean Whether the record has been processed | |
* @static | |
*/ | |
public static function notice($message, $context = array()){ | |
return \Monolog\Logger::notice($message, $context); | |
} | |
/** | |
* Adds a log record at the WARNING level. | |
* | |
* @param string $message The log message | |
* @param array $context The log context | |
* @return Boolean Whether the record has been processed | |
* @static | |
*/ | |
public static function warning($message, $context = array()){ | |
return \Monolog\Logger::warning($message, $context); | |
} | |
/** | |
* Adds a log record at the ERROR level. | |
* | |
* @param string $message The log message | |
* @param array $context The log context | |
* @return Boolean Whether the record has been processed | |
* @static | |
*/ | |
public static function error($message, $context = array()){ | |
return \Monolog\Logger::error($message, $context); | |
} | |
/** | |
* Adds a log record at the CRITICAL level. | |
* | |
* @param string $message The log message | |
* @param array $context The log context | |
* @return Boolean Whether the record has been processed | |
* @static | |
*/ | |
public static function critical($message, $context = array()){ | |
return \Monolog\Logger::critical($message, $context); | |
} | |
/** | |
* Adds a log record at the ALERT level. | |
* | |
* @param string $message The log message | |
* @param array $context The log context | |
* @return Boolean Whether the record has been processed | |
* @static | |
*/ | |
public static function alert($message, $context = array()){ | |
return \Monolog\Logger::alert($message, $context); | |
} | |
/** | |
* Adds a log record at the EMERGENCY level. | |
* | |
* @param string $message The log message | |
* @param array $context The log context | |
* @return Boolean Whether the record has been processed | |
* @static | |
*/ | |
public static function emergency($message, $context = array()){ | |
return \Monolog\Logger::emergency($message, $context); | |
} | |
/** | |
* | |
* | |
* @return string | |
* @static | |
*/ | |
public static function getName(){ | |
return \Monolog\Logger::getName(); | |
} | |
/** | |
* Pushes a handler on to the stack. | |
* | |
* @param \Monolog\HandlerInterface $handler | |
* @return $this | |
* @static | |
*/ | |
public static function pushHandler($handler){ | |
return \Monolog\Logger::pushHandler($handler); | |
} | |
/** | |
* Pops a handler from the stack | |
* | |
* @return \Monolog\HandlerInterface | |
* @static | |
*/ | |
public static function popHandler(){ | |
return \Monolog\Logger::popHandler(); | |
} | |
/** | |
* Set handlers, replacing all existing ones. | |
* | |
* If a map is passed, keys will be ignored. | |
* | |
* @param \Monolog\HandlerInterface[] $handlers | |
* @return $this | |
* @static | |
*/ | |
public static function setHandlers($handlers){ | |
return \Monolog\Logger::setHandlers($handlers); | |
} | |
/** | |
* | |
* | |
* @return \Monolog\HandlerInterface[] | |
* @static | |
*/ | |
public static function getHandlers(){ | |
return \Monolog\Logger::getHandlers(); | |
} | |
/** | |
* Adds a processor on to the stack. | |
* | |
* @param callable $callback | |
* @return $this | |
* @static | |
*/ | |
public static function pushProcessor($callback){ | |
return \Monolog\Logger::pushProcessor($callback); | |
} | |
/** | |
* Removes the processor on top of the stack and returns it. | |
* | |
* @return callable | |
* @static | |
*/ | |
public static function popProcessor(){ | |
return \Monolog\Logger::popProcessor(); | |
} | |
/** | |
* | |
* | |
* @return callable[] | |
* @static | |
*/ | |
public static function getProcessors(){ | |
return \Monolog\Logger::getProcessors(); | |
} | |
/** | |
* Adds a log record. | |
* | |
* @param integer $level The logging level | |
* @param string $message The log message | |
* @param array $context The log context | |
* @return Boolean Whether the record has been processed | |
* @static | |
*/ | |
public static function addRecord($level, $message, $context = array()){ | |
return \Monolog\Logger::addRecord($level, $message, $context); | |
} | |
/** | |
* Adds a log record at the DEBUG level. | |
* | |
* @param string $message The log message | |
* @param array $context The log context | |
* @return Boolean Whether the record has been processed | |
* @static | |
*/ | |
public static function addDebug($message, $context = array()){ | |
return \Monolog\Logger::addDebug($message, $context); | |
} | |
/** | |
* Adds a log record at the INFO level. | |
* | |
* @param string $message The log message | |
* @param array $context The log context | |
* @return Boolean Whether the record has been processed | |
* @static | |
*/ | |
public static function addInfo($message, $context = array()){ | |
return \Monolog\Logger::addInfo($message, $context); | |
} | |
/** | |
* Adds a log record at the NOTICE level. | |
* | |
* @param string $message The log message | |
* @param array $context The log context | |
* @return Boolean Whether the record has been processed | |
* @static | |
*/ | |
public static function addNotice($message, $context = array()){ | |
return \Monolog\Logger::addNotice($message, $context); | |
} | |
/** | |
* Adds a log record at the WARNING level. | |
* | |
* @param string $message The log message | |
* @param array $context The log context | |
* @return Boolean Whether the record has been processed | |
* @static | |
*/ | |
public static function addWarning($message, $context = array()){ | |
return \Monolog\Logger::addWarning($message, $context); | |
} | |
/** | |
* Adds a log record at the ERROR level. | |
* | |
* @param string $message The log message | |
* @param array $context The log context | |
* @return Boolean Whether the record has been processed | |
* @static | |
*/ | |
public static function addError($message, $context = array()){ | |
return \Monolog\Logger::addError($message, $context); | |
} | |
/** | |
* Adds a log record at the CRITICAL level. | |
* | |
* @param string $message The log message | |
* @param array $context The log context | |
* @return Boolean Whether the record has been processed | |
* @static | |
*/ | |
public static function addCritical($message, $context = array()){ | |
return \Monolog\Logger::addCritical($message, $context); | |
} | |
/** | |
* Adds a log record at the ALERT level. | |
* | |
* @param string $message The log message | |
* @param array $context The log context | |
* @return Boolean Whether the record has been processed | |
* @static | |
*/ | |
public static function addAlert($message, $context = array()){ | |
return \Monolog\Logger:: |