Get the destination class path.

@param  string  $name
@return string
172750
protected function getPath($name)
    {
        $name = str_replace($this->container->getNamespace(), '', $name);

        return $this->container['path'] .DS .str_replace('\\', DS, $name) .'.php';
    }
1341994
public function instance($name)
    {
        // If the class name starts with a dot, then find the class in the same class path as the caller
        if(substr($name, 0, 1) == '.')
        {
            $name = $this->getJaxonClassPath() . $name;
        }
        // The class namespace is prepended to the class name
        elseif(substr($name, 0, 1) == ':' && ($namespace = $this->getJaxonNamespace()))
        {
            $name = str_replace('\\', '.', trim($namespace, '\\')) . '.' . substr($name, 1);
        }
        return jaxon()->sentry()->instance($name);
    }
1199644
protected function getPath($name)
    {
        $name = Str::replaceFirst($this->rootNamespace(), '', $name);

        return $this->laravel['path'].'/'.str_replace('\\', '/', $name).'.php';
    }
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;
    }
746346
public function getThemePath($name)
    {
        $theme = $this->manager->getRepository("ClarolineCoreBundle:Theme\Theme")->findOneBy(array('name' => $name));

        if ($theme) {
            return $theme->getPath();
        }

        return "";
    }
672933
public function getClassName($name)
    {
        if (!isset($this->mapping[$name])) {
            throw new \InvalidArgumentException(sprintf('Could not find "%s"', $name));
        }

        return $this->mapping[$name];
    }
1265602
protected function getPathFromExtensionName(string $name): ?string
    {
        $finder = $this->app->make('orchestra.extension.finder');
        $files = $this->app->make('files');

        if ($name === 'app') {
            $basePath = $this->app->basePath();
        } else {
            $basePath = \rtrim($this->app->make('orchestra.extension')->option($name, 'path'), '/');
            $basePath = $finder->resolveExtensionPath($basePath);
        }

        $paths = ["{$basePath}/public", "{$basePath}/resources/public"];

        foreach ($paths as $path) {
            if ($files->isDirectory($path)) {
                return $path;
            }
        }

        return null;
    }
1120110
protected function resolvePath($name)
    {
        try {
            $path = RelativePath::fromString($name);
        } catch (NonRelativePathException $exception) {
            $path = AbsolutePath::fromString($name);
        }
        $resultPath = $this->rootPath->resolve($path);

        return $resultPath->normalize()->string();
    }
1262375
private function getBasePathForClass($name, $namespace, $path)
    {
        $namespace   = str_replace('\\', '/', $namespace);
        $search      = str_replace('\\', '/', $path);
        $destination = str_replace('/' . $namespace, '', $search, $c);

        if ($c !== 1) {
            throw new RuntimeException(sprintf('Can\'t find base path for "%s" (path: "%s", destination: "%s").', $name, $path, $destination));
        }

        return $destination;
    }
660627
public function getClassName(string $name) : string
    {
        $name = str_replace("/", "\\", $name);
        $name = explode("\\", $name);
        $name = array_pop($name);
        $name = $this->removeNoneAlpherNumeric($name);
        return $name;
    }
923975
public function findPublicPath($name)
    {
        $path = $this->prefixPublicPath($name);

        if ($this->files->exists($path))
        {
            return $path;
        }
    }
1280042
public function getConfigurationPath($name = null)
    {
        if (! $name) {
            $appConfigDir = $this->basePath('configs').'/';

            if (file_exists($appConfigDir)) {
                return $appConfigDir;
            } elseif (file_exists($path = __DIR__.'/configs/')) {
                return $path;
            }
        } else {
            $appConfigPath = $this->basePath('configs').'/'.$name.'.php';
            if (file_exists($appConfigPath)) {
                return $appConfigPath;
            } elseif (file_exists($path = __DIR__.'/configs/'.$name.'.php')) {
                return $path;
            }
        }
    }
262889
protected function getPath($name)
    {
        $name = isset($this->map[$name]) ? $this->map[$name] : $name;

        return "{$this->basePath}/{$name}.svg";
    }
887466
public function getPath($name)
    {
        if (!isset($this->config[$name]['prototype_path'])) {
            throw new \Exception(sprintf('Path for "%s" not found', $name));
        }

        return $this->config[$name]['prototype_path'];
    }
623271
public function getPath($name)
    {
        return \array_key_exists($name, $this->paths) ? $this->paths[$name] : null;
    }
932549
public static function getModelClass($name)
    {
        // If the name contains a backslash it is already fully qualified. However in some cases
        // a model might be replaced by a new class and so we must first look to see if this model is
        // mapped and if so return it's replacement instead.
        if (stripos($name, "\\") !== false) {
            $newName = self::getModelNameFromClass($name);

            if ($newName === null) {
                // $name hasn't been registered as a model object. Play safe and return the
                // same class name passed to us.
                return '\\' . ltrim($name, '\\');
            }

            $name = $newName;
        }

        if (self::$modelClassesCache == null) {
            self::$modelClassesCache = [];

            $schemas = self::getAllSchemas();

            self::$modelNamesCache = [];

            foreach ($schemas as $schema) {
                self::$modelClassesCache = array_merge(self::$modelClassesCache, $schema->models);
                self::$modelNamesCache = array_merge(self::$modelNamesCache, $schema->modelClassNames);
            }
        }

        if (isset(self::$modelClassesCache[$name])) {
            return '\\' . ltrim(self::$modelClassesCache[$name], '\\');
        }

        return null;
    }
574736
protected static function _GetSeesionClassLayerPath ($name = [], $class_path = null) {
		$classes_layer_path = [
			'fw2',
			'classes',
			$class_path ?: static::class
		];
		return array_merge($classes_layer_path, Arrays::AdjustArray($name));
	}