Provides libraries paths based on config values
@return array
506087
public function getLibraries()
    {
        $config = \Altamira\Config::getInstance();
        $libraryToPath = array(
                \Altamira\JsWriter\Flot::LIBRARY    =>    $config['js.flotlib'],
                \Altamira\JsWriter\JqPlot::LIBRARY  =>    $config['js.jqplotlib']
                );
        $libraryKeys = array_unique( array_keys( $this->libraries ) );
        $libraryPaths = array();
        
        foreach ($libraryKeys as $key) {
            $libraryPaths[] = $libraryToPath[$key];
        }
        
        return $libraryPaths;
    }
12079
public function allSourcePaths()
    {
        return array_merge(
            $this->allPsr4SourcePaths(),
            $this->allPsr0SourcePaths(),
            $this->autoloadClassmap(),
            $this->autoloadFiles(),
            $this->includePath()
        );
    }
533515
public function findGeneralConfiguration(): array
    {
        /** @var array[] $configurationSets */
        $configurationSets = [[]];

        $modules = $this->packageRepository->findModules();
        foreach ($modules as $module) {
            $extra = $module->getExtra();
            $this->validateGeneralConfigurationSectionInExtra($extra);
            if (!isset($extra['phplist/core']['configuration'])) {
                continue;
            }

            $configurationSets[] = $extra['phplist/core']['configuration'];
        }

        return /** @scrutinizer ignore-call */ array_replace_recursive(...$configurationSets);
    }
731309
public function updatePaths()
    {
        if (isset($this->configs['paths'])) {
            $paths = Loader::getInstance()->getPaths();
            foreach ($this->configs['paths'] as $key => $file) {
                $file = str_replace('@PEAR-DIR@', $paths['php_dir'], $file);
                $file = str_replace('@DATA-DIR@', $paths['data_dir'], $file);
                $this->configs['paths'][$key] = $file;
            }
        }
        return $this;
    }
1323811
protected function paths()
    {
        $paths = array('APPPATH' => $this->constants['APPPATH']);

        $paths['VENDOR'] = $this->constants['VENDOR'];

        $paths['VIEWPATH'] = $this->constants['VIEWPATH'];

        foreach ((array) $paths as $key => $value) {
            $defined = defined($key);

            $defined || define($key, $value);
        }

        defined('BASEPATH') || $this->basepath();
    }
368254
public function getPaths() : array
    {
        $templatePaths = [];

        $paths = $this->template->getFinder()->getPaths();
        $hints = $this->template->getFinder()->getHints();

        foreach ($paths as $path) {
            $templatePaths[] = new TemplatePath($path);
        }

        foreach ($hints as $namespace => $path) {
            $templatePaths[] = new TemplatePath($namespace, $path);
        }

        return $templatePaths;
    }
183949
protected function getResolvedPaths()
    {
        if (null === $this->resolvedPaths) {
            $this->resolveDirectories();
            // Collect all path properties and put them into $paths associatively using propertyName => propertyValue
            $paths = [];
            collect(array_keys(get_class_vars(get_class($this))))->filter(function ($propertyName) {
                return ends_with($propertyName, 'Path');
            })->each(function ($propertyName) use (&$paths) {
                $paths[ $propertyName ] = $this->{$propertyName};
            });

            // Use the paths to generate parsed paths, resolving all the {vars}
            $this->resolvedPaths = collect($paths)->transform(function ($path) use ($paths) {
                return Util::template($path, $paths);
            })->transform(function ($path, $propertyName) {
                return ends_with($propertyName, 'DestinationPath') ? base_path($path) : path_join($this->rootDir, $path);
            })->toArray();
        }

        return $this->resolvedPaths;
    }
52460
protected function getClassFiles()
	{
		$app = $this->flyphp;

		$core = require __DIR__.'/Optimize/config.php';

		return array_merge($core, $this->flyphp['config']['compile']);
	}
1133290
public function loadConfig()
    {
        $path = $this->getConfigPath();

        if (!is_dir($path)) {
            return [];
        }

        $configs = Cache::remember("moduleConfig::{$path}", Carbon::now()->addMinutes(10), function () use ($path) {
            $configs = [];
            foreach (new \DirectoryIterator($path) as $file) {
                if ($file->isDot() or strpos($file->getFilename(), '.php') === false) {
                    continue;
                }
                $key = $file->getBasename('.php');
                $configs[$key] = array_merge_recursive(require $file->getPathname(), app('config')->get($key, []));
            }

            return $configs;
        });

        return $configs;
    }
547191
public function getList()
    {
        $libraries = &gplcart_static('library.list');

        if (isset($libraries)) {
            return (array) $libraries;
        }

        $libraries = (array) gplcart_config_get(GC_FILE_CONFIG_LIBRARY);
        $this->hook->attach('library.list', $libraries, $this);
        $libraries = (array) $this->prepareList($libraries);

        return $libraries;
    }
254573
public static function get_available_configs_map()
    {
        $configs = array();

        foreach (self::$configs as $identifier => $config) {
            $configs[$identifier] = $config->getOption('friendly_name');
        }

        return $configs;
    }
341655
def get_paths(cls, packages):
        """"""
        allowable_packages = dict((app_config.name, app_config) for app_config in apps.get_app_configs())
        app_configs = [allowable_packages[p] for p in packages if p in allowable_packages]
        # paths of requested packages
        return [os.path.join(app.path, 'locale') for app in app_configs]
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
809559
public function allPsr4SourcePaths()
    {
        $autoloadPsr4Paths = array();
        foreach ($this->autoloadPsr4() as $namespace => $paths) {
            $autoloadPsr4Paths = array_merge($autoloadPsr4Paths, $paths);
        }

        return $autoloadPsr4Paths;
    }
722614
protected function get_paths() {
		return [
			WP_LANG_DIR . '/' . $this->textdomain . '-' . get_locale() . '.mo',
			dirname( KIRKI_PLUGIN_FILE ) . '/languages/' . $this->textdomain . '-' . get_locale() . '.mo',
		];
	}
1341061
public function loadUndefinedConfigPaths()
    {
        $list       = [];
        $collection = $this->coreConfig->getCollectionByPath(SgCoreInterface::PATH_UNDEFINED . '%');
        /** @var \Magento\Framework\App\Config\Value $item */
        foreach ($collection as $item) {
            $path       = explode('/', $item->getPath());
            $key        = array_pop($path);
            $list[$key] = $item->getPath();
        }

        return $list;
    }
1127136
private function getRouteFolders()
    {
        $libsPath[] = [DOMINIO => "public/{$this->directory}"];
        if (!empty($_SESSION['userlogin'])) {
            $libsPath[][DOMINIO] = "public/{$this->directory}/{$_SESSION['userlogin']['setor']}";
            $libsPath = array_merge($libsPath, array_map(function ($class) {
                return [$class => VENDOR . $class . "/public/{$this->directory}/{$_SESSION['userlogin']['setor']}"];
            }, $this->getRouteFile()));
        }
        $libsPath = array_merge($libsPath, array_map(function ($class) {
            return [$class => VENDOR . $class . "/public/{$this->directory}"];
        }, $this->getRouteFile()));

        return $libsPath;
    }