in case of that namespace exists but not defined as array
[ 'Path\To\NameSpace' => 'Path\To\Resource' ]

@param string $name Name Of Resource
762967
protected function _t_loader_namespacestack_fixResourceList($name)
    {
        if (!is_array($this->_t_loader_namespacestack_Namespaces[$name]))
            $this->_t_loader_namespacestack_Namespaces[$name] = array(
                $this->_t_loader_namespacestack_Namespaces[$name]
            );
    }
497700
public function setName($name) {
        $this->name = $name;
        $arg = pathinfo($name, PATHINFO_EXTENSION);
        if (!empty($arg)) {
            $this->extension = $arg;
        }
        return $this;
    }
109300
public function define($name, $path)
    {
        $name = $this->normalizeName($name);

        if (strpos($path, "%$name%") !== false) {
            throw new \InvalidArgumentException('Paths cannot reference themselves.');
        }

        $this->paths[$name] = $path;
    }
440256
protected function findNamedPathView($name)
    {
        list($namespace, $view) = $this->getNamespaceSegments($name);

        return $this->findInPaths($view, $this->hints[$namespace]);
    }
913699
public function path($name, $folder = false)
    {

        // the current namespace prefix
        $prefix = $name;

        // work backwards through the namespace names of the fully-qualified
        // class name to find a mapped file name
        while (false !== $pos = strrpos($prefix, '\\')) {

            // retain the trailing namespace separator in the prefix
            $prefix = substr($name, 0, $pos + 1);

            // the rest is the relative class name
            $relative_class = substr($name, $pos + 1);

            // try to load a mapped file for the prefix and relative class
            $mapped_file = $this->loadMappedFile($prefix, $relative_class, $folder);
            if ($mapped_file) {
                return $mapped_file;
            }

            // remove the trailing namespace separator for the next iteration
            // of strrpos()
            $prefix = rtrim($prefix, '\\');
        }

        // never found a mapped file
        return false;
    }
850796
public function setName($name)
    {
        $this->name = $name;
        if ($this->node) {
            $this->node->name = $name;
        }
    }
101181
public function addPath(string $path, string $namespace = null): void
    {
        $namespace = $namespace ?: FileViewFinder::DEFAULT_NAMESPACE;
        $this->finder->addPath($path, $namespace);
    }
978721
protected function parseName($name)
    {
        $rootNamespace = $this->getLaravelRootNamespace();

        if (Str::startsWith($name, $rootNamespace)) {

            return $name;
        }

        $name = $this->sanitizedPath($name);

        return $this->parseName($this->getDefaultNamespace(trim($rootNamespace, '\\')) . '\\' . $name);
    }
950406
public function get_namespace($name = null)
    {
        $ns = $this->namespace;

        if ($name) {
            // an alias for BC
            if ($name == 'prefix') {
                $name = 'prefix_in';
            }

            return isset($ns[$name]) ? $ns[$name] : null;
        }

        unset($ns['prefix_in'], $ns['prefix_out']);

        return $ns;
    }
1205576
public function renameTo($name)
	{
		if (strpos($name, DIRECTORY_SEPARATOR) !== 0)
		{
			$name = pathinfo($this->path, PATHINFO_DIRNAME).DIRECTORY_SEPARATOR.$name;
		}

		if ( ! pathinfo($name, PATHINFO_EXTENSION))
		{
			$name .= '.'.pathinfo($this->path, PATHINFO_EXTENSION);
		}

		if ($result = rename($this->path, $name))
		{
			$this->path = realpath($name);
		}

		return $result;
	}
1190415
public function setFlashNamespace($name)
	{
		$this->config['flash_namespace'] = (string) $name;

		$this->flash->setNamespace($this->config['flash_namespace']);
	}
849886
protected function parseNamespacedName($name)
    {
        $segments = explode(static::HINT_PATH_DELIMITER, $name);
        if (count($segments) != 2) {
            throw new InvalidArgumentException("View [$name] has an invalid name.");
        }
        if (!isset($this->paths[$segments[0]]) || count($this->paths[$segments[0]]) < 1) {
            throw new InvalidArgumentException("No path defined for namespace [{$segments[0]}].");
        }
        return $segments;
    }
768041
public function validateSpaces($name)
    {
        $string = $this->removeSpaces($name);
        if ($string == $name) {
            return $name;
        } else {
            throw new \InvalidArgumentException(
                sprintf(
                    'The name "%s" is invalid, spaces between words are not allowed.',
                    $name
                )
            );
        }
    }
768868
public function setNamespace( string $name, array $meta = null ) {

    // 'converter' enables text file conversion, 'format' is used to create files with the correct extension
    if( $meta !== null && ( empty( $meta[ 'converter' ] ) || empty( $meta[ 'format' ] ) ) ) {
      throw new \LogicException( "There must be a 'converter' and a 'format' in the namespace meta" );
    }

    return parent::setNamespace( $name, $meta );
  }
49620
public static function extractNamespaceFromQualifiedName($name)
    {
        if (($pos = strrpos($name, '\\')) !== false) {
            return substr($name, 0, $pos);
        } else {
            return null;
        }
    }
514158
public function directoryExists(string $name)
    {
        if(!$this->_isLoaded) {
            $this->load();
        }

        return in_array($name, $this->_directories);
    }
871279
public function removeResource ($name)
	{
		
		if (isset ($this->resources[$name]))
		{
			
			unset ($this->resources[$name]);
			
			if (isset ($this->$name))
			{
				unset ($this->$name);
			}
				
		}
		
	}