Set the default guard driver the factory should serve.

@param  string  $name
@return void
559706
public function shouldUse($name)
    {
        $this->setDefaultDriver($name);

        $this->userResolver = function ($name = null)
        {
            return $this->guard($name)->user();
        };
    }
220231
private function buildDriver($name, array $driver)
    {
        return $this->drivers[$name] = new $driver['driver'](
            Arr::get($driver, 'options.'.$this->getDefaultOption(), [])
        );
    }
641173
public function store(string $name = '', $force = false): Driver
    {
        if ('' !== $name && 'complex' == $this->config['type']) {
            return $this->connect($this->config[$name], $force);
        }

        return $this->init();
    }
650609
private function bakeApiController(string $name) : void
    {
        $apiPaths = $this->getTargetApiPath();
        $this->pathFragment = $apiPaths['fragment'];

        $this->bake($name, 'Controller/Api/controller', array_merge(['name' => $name], $apiPaths), 'Controller');
    }
112277
public function groupName(string $name): void
    {
        $parts = array_map(
            function ($n) {
                return Inflector::humanize(Inflector::underscore(str_replace('Controller', '', $n)));
            },
            explode('\\', $name)
        );

        /*
        removes empty array entries
         */
        $parts = array_filter($parts);

        /*
        get just the controller and plugin names
         */
        $parts = array_slice($parts, -2);

        $name = implode(' :: ', $parts);

        $this->set('groupName', $name);
    }
1038378
private function bakeFeature(string $name) : void
    {
        $this->pathFragment = 'Feature/Type/Module/';

        $this->bake($name, 'Feature/feature', ['name' => $name], 'Feature');
    }
1221162
public function make($name = null, Provider $memory = null)
    {
        if ($name === null) {
            $name = 'default';
        }

        if (!isset($this->drivers[$name])) {
            $this->drivers[$name] = new Authorization($this->auth, $name, $memory);
        }

        return $this->drivers[$name];
    }
708533
public function setDefaultDriverName($name)
    {
        $name = strtolower($name);

        if (!isset($this->drivers[$name])) {
            throw new \InvalidArgumentException(sprintf('Driver "%s" is not registered.', $name));
        }

        $this->defaultDriverName = $name;
    }
1011633
private function bakeController(string $name) : void
    {
        $this->pathFragment = 'Controller/';

        $this->bake($name, 'Controller/controller', ['name' => $name], 'Controller');
    }
93199
public function disableSearchOperator($name)
    {
        if (isset($this->_config['operators'][$name])) {
            $this->_config['operators'][":{$name}"] = $this->_config['operators'][$name];
            unset($this->_config['operators'][$name]);
        }
    }
199482
public function disable($name)
    {
        $enabled = $this->getEnabled();

        if (($k = array_search($name, $enabled)) === false) {
            return;
        }

        $extension = $this->getExtension($name);

        $this->dispatcher->dispatch(new Disabling($extension));

        unset($enabled[$k]);

        $this->setEnabled($enabled);

        $extension->disable($this->app);

        $this->dispatcher->dispatch(new Disabled($extension));
    }
886095
static public function setActiveName ($name)
    {
        $model = self::where('name',$name)->first();
        if ($model)
        {
            self::$active_model = $model;
        }
    }
1323351
protected function initialize(string $name): void
    {
        $rawDefault = $this->loadCache('default.raw');
        if (!$rawDefault) {
            $rawDefault = new Endpoint(self::DEFAULT_ENDPOINT);

            foreach ($this->loaders as $loader) {
                $loader->loadDefinitions($rawDefault);
            }

            $this->saveCache('default.raw', $rawDefault);
        }

        if (!isset(self::$endpoints[$name])) {
            //copy from raw to specific endpoint
            self::$endpoints[$name] = new Endpoint($name);
            self::$endpoints[$name]->setTypes($rawDefault->allTypes());
            self::$endpoints[$name]->setMutations($rawDefault->allMutations());
            self::$endpoints[$name]->setQueries($rawDefault->allQueries());
            self::$endpoints[$name]->setSubscriptions($rawDefault->allSubscriptions());

            $this->compile(self::$endpoints[$name]);
        }

        $this->saveCache($name, self::$endpoints[$name]);
    }
910132
public function enableHandler($name)
    {
        if ($this->debug) {
            $debugArgs = new Args([
                'name'    => $name,
                'source'  => 'core:event:debug',
                'level'   => E_NOTICE,
            ]);
            $this->fire(':onEnableHandler:', $debugArgs);
        }
        unset($this->disabledEvents[$name]);
    }
1062418
public function stopMeasure(string $name): void
    {
        if (App::$Debug) {
            App::$Debug->stopMeasure($name);
        }
    }
176803
public function forgetDriver($name = null)
    {
        $name = $name ?? $this->getDefaultDriver();

        foreach ((array) $name as $cacheName) {
            if (isset($this->stores[$cacheName])) {
                unset($this->stores[$cacheName]);
            }
        }

        return $this;
    }
1056248
public function assertIsInjectable(string $name)
    {
        $injectable = true;

        $message = "The class '$name' couldn't be automatically injected.";

        try {
            $class = $this->makeInjectableClass($name);
            $this->assertInstanceOf($name, $class->getInjectedObject());
        } catch (Exception $e) {
            $injectable = false;
            if ($msg = $e->getMessage()) {
                $message .= " $msg";
            }
        }

        $this->assertTrue($injectable, $message);
    }