Returns the list of additional modules that should be included ahead
of this module build in the layer

@return The list of before modules.
962942
public List<String> getExtraModules() {
		return extraModules == null ? Collections.<String>emptyList() : Collections.unmodifiableList(extraModules);
	}
490831
private List<String> getComponentModules(CmsSetupComponent component) {

        List<String> modules = new ArrayList<String>();
        Iterator<String> itModules = m_availableModules.keySet().iterator();
        while (itModules.hasNext()) {
            String moduleName = itModules.next();
            if (component.match(moduleName)) {
                modules.add(moduleName);
            }
        }
        return modules;
    }
848523
private List extractModuleNames() {

        List modules = new ArrayList();

        StringTokenizer tok = new StringTokenizer(getParamModule(), ",");
        while (tok.hasMoreTokens()) {
            String module = tok.nextToken();
            modules.add(module);
        }

        return modules;
    }
123055
public List<Relationship> getPreviousRelationships() {
        final List<Relationship> prevRelationships = new LinkedList<Relationship>();
        for (final Relationship r : relationships) {
            if (r.getType() == RelationshipType.PREVIOUS) {
                prevRelationships.add(r);
            }
        }
        return prevRelationships;
    }
2198
public static Module combineAndOverride(List<? extends Module> modules) {
        Iterator<? extends Module> iter = modules.iterator();
        Module current = Modules.EMPTY_MODULE;
        if (iter.hasNext()) {
            current = iter.next();
            if (iter.hasNext()) {
                current = Modules.override(current).with(iter.next());
            }
        }
        
        return current;
    }
661012
public List<Construction> getNextConstructions() {
	List<Construction> constructions = new ArrayList<Construction>();
	for (T item : kernelItems) {
	    Construction element = item.getNext();
	    if (element != null) {
		constructions.add(element);
	    }
	}
	for (T item : nonKernelItems) {
	    Construction element = item.getNext();
	    if (element != null) {
		constructions.add(element);
	    }
	}
	return constructions;
    }
1218889
public synchronized static Modules getInstance() {
        if (modules == null) {
            modules = new Modules(null);
            modules.gatherInformations();
        }
        return modules;
    }
782992
public List<LifecycleCallbackType<WebFragmentDescriptor>> getAllPreDestroy()
   {
      List<LifecycleCallbackType<WebFragmentDescriptor>> list = new ArrayList<LifecycleCallbackType<WebFragmentDescriptor>>();
      List<Node> nodeList = model.get("pre-destroy");
      for(Node node: nodeList)
      {
         LifecycleCallbackType<WebFragmentDescriptor>  type = new LifecycleCallbackTypeImpl<WebFragmentDescriptor>(this, "pre-destroy", model, node);
         list.add(type);
      }
      return list;
   }
1165906
public function getSortedModules()
    {
        $i18nOrder = Sources::config()->uninherited('module_priority');
        $sortedModules = [];
        if ($i18nOrder) {
            Deprecation::notice('5.0', sprintf(
                '%s.module_priority is deprecated. Use %s.module_priority instead.',
                __CLASS__,
                ModuleManifest::class
            ));
        }

        foreach (ModuleLoader::inst()->getManifest()->getModules() as $module) {
            $sortedModules[$module->getName()] = $module->getPath();
        };

        return $sortedModules;
    }
387799
def inspect_modules
      modules = []

      if constant.respond_to?(:ancestors)
        parent = inspect_superclass

        # Take all the modules included *directly* into the constant.
        modules = constant.ancestors.take_while do |ancestor|
          parent && ancestor != parent
        end

        # Get rid of non Module instances and modules that don't have a name.
        modules = modules.select do |mod|
          mod.instance_of?(Module) && mod.name
        end
      end

      return modules
    end
572896
public List<String> getUptodateModules() {

        if (m_uptodateModules == null) {
            m_uptodateModules = new ArrayList<String>();
            m_modulesToUpdate = new ArrayList<String>();
            Map<String, CmsModuleVersion> installedModules = getInstalledModules();
            Map<String, CmsModule> availableModules = getAvailableModules();
            Iterator<Map.Entry<String, CmsModule>> itMods = availableModules.entrySet().iterator();
            while (itMods.hasNext()) {
                Map.Entry<String, CmsModule> entry = itMods.next();
                String name = entry.getKey();
                CmsModuleVersion instVer = installedModules.get(name);
                CmsModuleVersion availVer = entry.getValue().getVersion();
                boolean uptodate = (!UPDATE_ALL_MODULES) && ((instVer != null) && (instVer.compareTo(availVer) >= 0));
                if (uptodate) {
                    m_uptodateModules.add(name);
                } else {
                    m_modulesToUpdate.add(name);
                }
                if (LOG.isDebugEnabled()) {
                    LOG.debug(
                        name + " --- installed: " + instVer + " available: " + availVer + " --- uptodate: " + uptodate);
                }
            }
        }
        return m_uptodateModules;
    }
1026128
function getDefaultModules() {
  return {
    preLoaders: [
      {
        test: /\.(js|jsx)$/,
        include: srcPath,
        loader: 'eslint-loader'
      }
    ],
    loaders: [
      {
        test: /\.css$/,
        loader: 'style-loader!css-loader'
      },
      {
        test: /\.sass/,
        loader: 'style-loader!css-loader!sass-loader?outputStyle=expanded&indentedSyntax'
      },
      {
        test: /\.scss/,
        loader: 'style-loader!css-loader!sass-loader?outputStyle=expanded'
      },
      {
        test: /\.less/,
        loader: 'style-loader!css-loader!less-loader'
      },
      {
        test: /\.styl/,
        loader: 'style-loader!css-loader!stylus-loader'
      },
      {
        test: /\.(png|jpg|gif|woff|woff2)$/,
        loader: 'url-loader?limit=8192'
      },
      {
        test: /\.(mp4|ogg|svg)$/,
        loader: 'file-loader'
      }
    ]
  };
}
86691
@Override
    public List<Module> getModules() {
        modules = Lists.createWhenNull(modules);
        if (ModuleUtils.getModule(modules, DCModule.URI) == null) {
            modules.add(new DCModuleImpl());
        }
        return modules;
    }
413203
def siblings_before(self):
        
        impl_nodelist = self.adapter.get_node_children(self.parent.impl_node)
        before_nodelist = []
        for n in impl_nodelist:
            if n == self.impl_node:
                break
            before_nodelist.append(n)
        return self._convert_nodelist(before_nodelist)
773177
public function getMissingCoreModules()
    {
        $modules = array();

        foreach ($this->coreModules as $module) {
            if (!$this->isLoadedModule($module)) {
                array_push($modules, $module);
            }
        }

        return $modules;
    }
200848
public Collection<ArtifactSpec> getRuntimeExplicitAndTransientDependencies() {
        Collection<ArtifactSpec> allDeps = new HashSet<>();
        Arrays.asList(this, presolvedDependencies).forEach(source -> {
            source.getDirectDeps()
                    .stream()
                    .filter(spec -> !spec.scope.equals("test"))
                    .forEach(spec -> {
                        allDeps.add(spec);
                        allDeps.addAll(source.getTransientDeps(spec));
                    });
        });

        return allDeps;
    }
198884
def _getModules(self):
        
        modules = {}
        modulesPath = os.path.join("application", "module")
        moduleList = os.listdir(modulesPath)

        for moduleName in moduleList:
            modulePath = os.path.join(modulesPath, moduleName, "module.py")
            if not os.path.isfile(modulePath):
                continue

            # importing module
            moduleSpec = importlib.util.spec_from_file_location(
                moduleName,
                modulePath
            )
            module = importlib.util.module_from_spec(moduleSpec)
            moduleSpec.loader.exec_module(module)

            # initializing module
            moduleInstance = module.Module(self)
            modules[moduleName] = moduleInstance

        return modules