Get a stack determiner instance.

@return  \BenConstable\Localize\Determiners\Stack
429289
protected function createStackDriver()
    {
        $determiners = (new Collection((array) $this->app['config']['localize-middleware']['driver']))
            ->filter(function ($driver) {
                return $driver !== 'stack';
            })
            ->map(function ($driver) {
                return $this->driver($driver)->setFallback(null);
            });

        return (new Determiners\Stack($determiners))
            ->setFallback($this->app['config']['app']['fallback_locale']);
    }
240847
public function getFallbackLocale(): self
    {
        if ($this->variant !== null) {
            return $this->withVariant(null);
        }

        if ($this->region !== null) {
            return $this->withRegion(null);
        }

        if ($this->script !== null) {
            return $this->withScript(null);
        }

        return $this;
    }
581327
public function getResolver()
    {
        if (! $this->resolver instanceof Resolver\AggregateResolver) {
            $this->resolver = new Resolver\AggregateResolver();
            $this->resolver->attach(new Resolver\DefaultResolver(), 0);
        }
        return $this->resolver;
    }
1162877
protected function popsInnerIterator()
    {
        if (null === $this->popsInnerIterator) {
            $this->popsInnerIterator = $this->popsCreateInnerIterator();
        }

        return $this->popsInnerIterator;
    }
1025444
public function getParentLocale() {
        if ($this->_parent) {
            return $this->_parent;
        }

        if (!$this->hasConfig('parent')) {
            return null;
        }

        $parent = new Locale($this->getConfig('parent'));
        $parent->initialize();

        // Merge parent config
        $this->addConfig($this->allConfig() + $parent->allConfig());

        $this->_parent = $parent;

        return $parent;
    }
1196682
public function getCallInstance()
    {
        if ($this->callInstance !== false) {
            return $this->callInstance;
        }

        if (is_array($this->call) && isset($this->call[0]) && is_object($this->call[0])) {
            $this->callInstance = $this->call[0];
            return $this->callInstance;
        }

        if (is_object($this->call) && method_exists($this->call, '__invoke')){
            $this->callInstance = $this->call;
            return $this->callInstance;
        }

        if ($this->isFunction() || $this->isStaticMethod()) {
            $this->callInstance = null;
            return $this->callInstance;
        }

        $this->callInstance = $this->resolveCallInstance($this->getCallClass());

        return $this->callInstance;
    }
402823
protected function getHandlerStack()
    {
        $handlerStack = HandlerStack::create($this->getHandler());

        $this->configureHandlerStack($handlerStack);

        return $handlerStack;
    }
579261
public function getResolver()
    {
        if (null !== $this->typeResolver) {
            return $this->typeResolver;
        }

        $classResolver = $this->getDefaultTypeResolverClass();
        $r = new ReflectionClass($classResolver);
        $resolver = $r->newInstance();
        $this->typeResolver = $resolver;

        return $this->typeResolver;
    }
113021
protected function createSessionDriver()
    {
        $determiner = new Determiners\Session(
            $this->app['config']['localize-middleware']['session']
        );

        $determiner->setFallback($this->app['config']['app']['fallback_locale']);

        return $determiner;
    }
398393
public function getInheritedElement()
    {
        /** @var ClassDescriptor|InterfaceDescriptor|null $associatedClass */
        $associatedClass = $this->getParent();

        if (($associatedClass instanceof ClassDescriptor || $associatedClass instanceof InterfaceDescriptor)
            && ($associatedClass->getParent() instanceof ClassDescriptor
                || $associatedClass->getParent() instanceof InterfaceDescriptor
            )
        ) {
            /** @var ClassDescriptor|InterfaceDescriptor $parentClass */
            $parentClass = $associatedClass->getParent();

            return $parentClass->getProperties()->get($this->getName());
        }

        return null;
    }
164679
public function nest()
    {
        // Nest config
        $manifest = clone $this->getManifest();

        // Create new blank loader with new stack (top level nesting)
        $newLoader = new static;
        $newLoader->pushManifest($manifest);

        // Activate new loader
        return $newLoader->activate();
    }
34517
protected function popsCreateInnerIterator()
    {
        if ($this->popsValue() instanceof Iterator) {
            $iterator = $this->popsValue();
        } elseif ($this->popsValue() instanceof IteratorAggregate) {
            $iterator = $this->popsValue()->getIterator();
        } else {
            throw new LogicException(
                'Proxied object is not an instance of Traversable'
            );
        }

        return $iterator;
    }
1205420
public static function getStackByType($type)
    {
        foreach (self::getStacks() as $stack) {
            if ($stack->isType($type)) {
                return $stack;
            }
        }
        return new Stacks\NullStack();
    }
1350319
protected function createStack()
    {
        $stack = new \SplStack();
        $stack->setIteratorMode(\SplDoublyLinkedList::IT_MODE_LIFO | \SplDoublyLinkedList::IT_MODE_KEEP);

        return $stack;
    }
542187
private function getParser()
    {
        if (null === $this->parser) {
            $this->parser = new Parser;
            $this->fixUniqueHeaders();
            $this->parser->setText($this->toString());
        }
        return $this->parser;
    }
883511
public function getResolver(){
		if(!isset($this->resolver)){
			$this->resolver = new MultiTypeResolver($this->container, getcwd());
		}
		return $this->resolver;
	}
111159
private function getCloneablesMap()
    {
        $cachedInstantiators = $this->getInstantiatorsMap();
        $that                = $this;

        return self::$cachedCloneables = self::$cachedCloneables
            ?: new CallbackLazyMap(function ($className) use ($cachedInstantiators, $that) {
                /* @var $factory Closure */
                $factory    = $cachedInstantiators->$className;
                $instance   = $factory();

                if (! $that->isSafeToClone(new ReflectionClass($className))) {
                    return null;
                }

                return $instance;
            });
    }