Returns all the third party library paths from the XML file.

@return array
508111
public function getVendorPaths()
    {
        $base  = dirname($this->path);
        $paths = [];
        foreach ($this->xml->xpath('/libraries/library/location') as $location) {
            $location = trim((string) $location, '/');
            $location = $base.'/'.$location;

            if (strpos($location, '*') !== false) {
                $locations = glob($location);
                if (empty($locations)) {
                    throw new \RuntimeException(sprintf('Failed to run glob on path: %s', $location));
                }
                $paths = array_merge($paths, $locations);
            } elseif (!file_exists($location)) {
                throw new \RuntimeException(sprintf('The %s contains a non-existent path: %s', $this->path, $location));
            } else {
                $paths[] = $location;
            }
        }

        return $paths;
    }
809559
public function allPsr4SourcePaths()
    {
        $autoloadPsr4Paths = array();
        foreach ($this->autoloadPsr4() as $namespace => $paths) {
            $autoloadPsr4Paths = array_merge($autoloadPsr4Paths, $paths);
        }

        return $autoloadPsr4Paths;
    }
1230923
protected static function getAllPaths()
    {
        $paths = Cache::read('paths', 'static_pages');

        if (empty($paths)) {
            //Adds all plugins to paths
            $paths = collection(Plugin::all())
                ->map(function ($plugin) {
                    return self::getPluginPath($plugin);
                })
                ->filter(function ($path) {
                    return file_exists($path);
                })
                ->toList();

            //Adds APP to paths
            array_unshift($paths, self::getAppPath());

            Cache::write('paths', $paths, 'static_pages');
        }

        return $paths;
    }
1302572
protected function getMigrationPaths()
    {
        if ($this->input->hasOption('path') && $this->option('path')) {
            return [app()->basePath() . '/' . $this->option('path')];
        }

        // Do not use the migrator paths.
        return [ $this->getMigrationPath() ];
    }
899257
protected function getCallPaths(): array
    {
        $paths = [];
        $backTrace = \debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
        foreach ($backTrace as $value) {
            if (isset($value['file'])) {
                $paths[] = $value['file'];
            }
        }

        return $paths;
    }
682939
protected function _getPaths()
    {
        $directories = $this->_createDirectoryIterator($this->_getRootDir());
        $flattened   = $this->_createRecursiveIteratorIterator($directories);
        $flattened->setMaxDepth($this->_getMaxDepth());
        $filter = $this->_createFilterIterator($flattened, function (SplFileInfo $current, $key, Iterator $iterator) {
            return $this->_filterFile($current);
        });

        return $filter;
    }
589769
public function getPathInfo() {
    /** @var TokenNode $first */
    $first = $this->firstChild();
    $absolute = $first->getType() === T_NS_SEPARATOR;
    $relative = $first->getType() === T_NAMESPACE;
    $parts = $this->getParts();
    return [
      'absolute' => $absolute,
      'relative' => $relative,
      'qualified' => !$absolute && count($parts) > 1,
      'unqualified' => !$absolute && count($parts) === 1,
      'parts' => $parts,
    ];
  }
580077
public function findAll(): array
    {
        $rootPackage = $this->composer->getPackage();
        $dependencies = $this->composer->getRepositoryManager()->getLocalRepository()->getPackages();

        $packagesWithDuplicates = array_merge([$rootPackage], $dependencies);

        return $this->removeDuplicates($packagesWithDuplicates);
    }
1071061
public function getInfo()
    {
        // try extension.xml first
        if ( is_readable( $XMLFilePath = eZExtension::baseDirectory() . "/{$this->name}/extension.xml" ) )
        {
            $infoFields = array( 'name', 'description', 'version', 'copyright', 'author', 'license', 'info_url' );

            libxml_use_internal_errors( true );
            $xml = simplexml_load_file( $XMLFilePath );
            // xml parsing error
            if ( $xml === false )
            {
                eZDebug::writeError( libxml_get_errors(), "ezpExtension({$this->name})::getInfo()" );
                return null;
            }
            $return = array();
            $metadataNode = $xml->metadata;

            // standard extension metadata
            foreach ( $infoFields as $field )
            {
                if ( (string)$metadataNode->$field !== '' )
                    $return[$field] = (string)$metadataNode->$field;
            }

            // 3rd party software
            if ( !$metadataNode->software->uses )
                return $return;

            $index = 1;
            foreach ( $metadataNode->software->uses as $software )
            {
                $label = "Includes the following third-party software";
                if ( $index > 1 )
                    $label .= " (" . $index . ")";

                foreach ( $infoFields as $field )
                {
                    if ( (string)$software->$field !== '' )
                        $return[$label][$field] = (string)$software->$field;
                }
                $index++;
            }

            return $return;
        }
        // then try ezinfo.php, for backwards compatibility
        elseif ( is_readable( $infoFilePath = eZExtension::baseDirectory() . "/{$this->name}/ezinfo.php" ) )
        {
            include_once( $infoFilePath );
            $className = $this->name . 'Info';
            if ( is_callable( array( $className, 'info' ) ) )
            {
                $result = call_user_func_array( array( $className, 'info' ), array() );
                if ( is_array( $result ) )
                {
                    return $result;
                }
            }
        }
        else
        {
            return null;
        }
    }
506442
public function getPathTree(): array
    {
        $tree = [];
        foreach ($this->getTree() as $branch) {
            $tree[] = Path::make($branch);
        }

        return $tree;
    }
302254
private function getLaravelPaths()
    {
        $is54 = version_compare(\Illuminate\Foundation\Application::VERSION, '5.4.0', '>');
        $paths = [
            'app' => $this->app[ 'path' ],
            'envFile' => $this->app->environmentFilePath(),
            'env' => $this->app->environmentPath(),
            'cached' => [
                'compile' => $is54 ? null : $this->app->getCachedCompilePath(),
                'config' => $this->app->getCachedConfigPath(),
                'routes' => $this->app->getCachedRoutesPath(),
                'services' => $this->app->getCachedServicesPath(),
            ],
        ];
        foreach (['base', 'lang', 'config', 'public', 'storage', 'database', 'bootstrap'] as $key) {
            $paths[ $key ] = $this->app[ 'path.'.$key ];
        }
        $paths[ 'resource' ] = resource_path();

        return $paths;
    }
722614
protected function get_paths() {
		return [
			WP_LANG_DIR . '/' . $this->textdomain . '-' . get_locale() . '.mo',
			dirname( KIRKI_PLUGIN_FILE ) . '/languages/' . $this->textdomain . '-' . get_locale() . '.mo',
		];
	}
1328985
public function getPaths()
    {
        Deprecated::method(3.0);

        if ($this->pathsProxy === null) {
            $this->pathsProxy = new PathsProxy($this);
        }

        return $this->pathsProxy;
    }
901477
public function getRuntimePath()
    {
        $paths = [];
        foreach ($this->getRuntime() as $key => $value) {
            if (in_array($key, ['hook', 'libraries', 'stylesheets', 'mediaFiles', 'icon', 'src'])) {
                $paths[$key] = preg_replace('/^' . $this->getTypeIdentifier() . '/', '.', $value);
            }
        }
        return $paths;
    }
351660
public function getScanPaths() : array
    {
        $paths = $this->paths;

        $paths[] = $this->getPath();

        if ($this->config('scan.enabled')) {
            $paths = array_merge($paths, $this->config('scan.paths'));
        }

        $paths = array_map(function ($path) {
            return ends_with($path, '/*') ? $path : str_finish($path, '/*');
        }, $paths);

        return $paths;
    }
900109
def _get_paths(self):
        """"""
        ret = []
        ret += ['%s/library/' % os.path.dirname(os.path.dirname(__file__))]        
        
        ret += self._extra_dirs
        for basedir in _basedirs:
            fullpath = os.path.join(basedir, self.subdir)
            if fullpath not in ret:
                ret.append(fullpath)
        ret += self.config.split(os.pathsep)
        ret += self._get_package_path()
        return ret
1305198
public function getTemplateRootPaths()
    {
        if ($this->templateRootPaths !== []) {
            return $this->templateRootPaths;
        }

        if ($this->templateRootPathPattern === null) {
            return [];
        }

        $templateRootPath = $this->templateRootPathPattern;
        if (isset($this->patternReplacementVariables['packageKey'])) {
            $templateRootPath = str_replace('@packageResourcesPath', 'resource://' . $this->patternReplacementVariables['packageKey'], $templateRootPath);
        }

        return [$templateRootPath];
    }