Returns all path mappings set for the given module name.

@param string $moduleName The module name.

@return PathMapping[] The path mappings.

@throws OutOfBoundsException If no path mapping was set for the
given module name.
194439
public function listByModuleName($moduleName)
    {
        if ($this->primaryKeysSorted) {
            $this->lazySortPrimaryKeys();
        }

        return $this->map->listBySecondaryKey($moduleName);
    }
550752
public function getRequiredModules($moduleName) {
        $moduleName = strtolower($moduleName);
        if (isset($this->_requiredModules[$moduleName])) {
            return $this->_requiredModules[$moduleName];
        }
        else {
            return null;
        }
    }
1307029
public function optimizeIndex($moduleName)
    {
        $translator = $this->getServiceLocator()->get('translator');
        $status = $translator->translate('tr_melis_engine_search_optimize');
        $lucenePath = self::FOLDER_PATH.$moduleName.'/'.self::FOLDER_NAME . '/indexes';

        if(file_exists($lucenePath) && is_readable($lucenePath)) {
            $index = Lucene::open($lucenePath);
            $index->optimize();
        }

        return $status;

    }
521974
public function getNodeByTagName($tagName)
    {
        $result = [];

        foreach ($this as $node) {
            if ($node->tagName === $tagName) {
                $result[] = $node;
            }
        }

        return $result;
    }
908900
public function getMappedFirstEntitiesByEntityType($entityName)
    {
        $entities = [];
        foreach ($this->data as $data) {
            $entity = $this->createAndReturnNewFirstEntity($data, $entityName);
            if ($entity) {
                $entities[] = $entity;
            }
        }
        return $entities;
    }
129051
public function getOptionsByModuleName($moduleName)
    {
        $moduleOptions = $this->resolveModuleOptionsByModuleName($moduleName);
        $this->validatePlugin($moduleOptions);

        return $moduleOptions;
    }
1066077
public function getByPathPrefix($pathPrefix){

        $this->fillScopes();

        if(!isset($this->scopeByPathPrefix[$pathPrefix])){
            throw new OutOfBoundsException("No scope with pathprefix '$pathPrefix' found");
        }

        return $this->scopeByPathPrefix[$pathPrefix];

    }
152302
private function getPathsOfAvailableModules()
    {
        $config = Registry::getConfig();
        $modulesRootPath = $config->getModulesDir();
        $modulePaths = $config->getConfigParam('aModulePaths');

        if (!is_dir($modulesRootPath))
            return [];

        if (!is_array($modulePaths))
            return [];

        $fullModulePaths = array_map(function ($modulePath) use ($modulesRootPath) {
            return $modulesRootPath . $modulePath;
        }, array_values($modulePaths));

        return array_filter($fullModulePaths, function ($fullModulePath) {
            return is_dir($fullModulePath);
        });
    }
573713
public static function module_extends_navigation($modname) {
        global $CFG;
        static $extendingmodules = array();
        if (!array_key_exists($modname, $extendingmodules)) {
            $extendingmodules[$modname] = false;
            $file = $CFG->dirroot.'/mod/'.$modname.'/lib.php';
            if (file_exists($file)) {
                $function = $modname.'_extend_navigation';
                require_once($file);
                $extendingmodules[$modname] = (function_exists($function));
            }
        }
        return $extendingmodules[$modname];
    }
1315070
public function getRelationForeignKeys($relationName)
    {
        if (!isset($this->relationForeignKeys[ $relationName ])) {
            throw new \OutOfBoundsException("Unknown relation: {$relationName}");
        }

        return $this->relationForeignKeys[ $relationName ];
    }
805595
protected function getApiMapping($className)
    {
        $apiMapping = Config::inst()->get($className, 'api_field_mapping');
        if ($apiMapping && is_array($apiMapping)) {
            return $apiMapping;
        }
        return [];
    }
1206983
public function findByNamesWithDependencies(array $modNames): array
    {
        $result = [];
        if (count($modNames) > 0) {
            $queryBuilder = $this->entityManager->createQueryBuilder();
            $queryBuilder->select(['m', 'd', 'dm'])
                         ->from(Mod::class, 'm')
                         ->leftJoin('m.dependencies', 'd')
                         ->leftJoin('d.requiredMod', 'dm')
                         ->andWhere('m.name IN (:modNames)')
                         ->setParameter('modNames', array_values($modNames));

            $result = $queryBuilder->getQuery()->getResult();
        }
        return $result;
    }
796577
private function getConfiguredDependencies($moduleName)
    {
        $config = $this->getModuleConfig($moduleName);

        if (!isset($config['depends'])) {
            return [];
        }

        return is_array($config['depends']) ? $config['depends'] : [$config['depends']];
    }
1192796
public function getPaths($sub = null)
    {
        $paths = [];

        foreach ($this->moduleLoader->getRegisteredModules() as $module) {
            if (is_dir($dir = $module->getPath($sub))) {
                // This path has a file, add it to the list
                $paths[$module->getName()] = $dir;
            }
        }

        return $paths;
    }
1278265
public function getMapperFor($className)
    {
        if (!$this->hasMapperFor($className)) {
            throw new MappingException(sprintf(
                'Class [%s] does not have a mapping configuration. '.
                'Make sure you create a Mapping class that extends either %s, %s or %s. '.
                'If you are using inheritance mapping, remember to create mappings '.
                'for every child of the inheritance tree.',
                $className,
                EntityMapping::class,
                EmbeddableMapping::class,
                MappedSuperClassMapping::class
            ));
        }

        return $this->mappers[$className];
    }
124148
public function getOptionsByClassName($className)
    {
        try {
            $moduleName = $this->getModuleNameByClassName($className);
            $moduleOptions = $this->getOptionsByModuleName($moduleName);
        } catch (\Exception $e) {
            throw new Exception\ErrorGetModuleOptionsByClassNameException($e->getMessage(), $e->getCode(), $e);
        }
        return $moduleOptions;
    }
439000
protected function mapsModule($moduleName, $url, $method){
        $maps= FALSE;
        foreach ($this->getModule($moduleName) as $key) {
            $maps= $this->mapsKey($key, $url, $method);
            if($maps){break;}
        }
        return $maps;
    }