Removes the list of explorer type settings from the given module.<p>

@param module the module witch contains the explorer type settings to remove
162221
public void removeExplorerTypeSettings(CmsModule module) {

        List<CmsExplorerTypeSettings> explorerTypes = module.getExplorerTypes();
        if ((explorerTypes != null) && (explorerTypes.size() > 0)) {
            Iterator<CmsExplorerTypeSettings> i = explorerTypes.iterator();
            while (i.hasNext()) {
                CmsExplorerTypeSettings settings = i.next();
                if (m_explorerTypeSettingsFromModules.contains(settings)) {
                    m_explorerTypeSettingsFromModules.remove(settings);
                    if (CmsLog.INIT.isInfoEnabled()) {
                        CmsLog.INIT.info(
                            Messages.get().getBundle().key(
                                Messages.INIT_REMOVE_EXPLORER_TYPE_SETTING_1,
                                settings.getName()));
                    }
                }
            }
            // reset the list of all explorer type settings
            initExplorerTypeSettings();
        }
    }
87860
async def unloadmodule(self, module, ignoreDependencies = False):
        '''
        
        '''
        self._logger.debug('Try to unload module %r', module)
        if hasattr(module, '_instance'):
            self._logger.debug('Module %r is loaded, module state is %r', module, module._instance.state)
            inst = module._instance
            if inst.state == ModuleLoadStateChanged.LOADING or inst.state == ModuleLoadStateChanged.LOADED:
                # Wait for loading
                # Wait for succeeded or failed
                sm = ModuleLoadStateChanged.createMatcher(module._instance.target, ModuleLoadStateChanged.SUCCEEDED)
                fm = ModuleLoadStateChanged.createMatcher(module._instance.target, ModuleLoadStateChanged.FAILED)
                await M_(sm, fm)
            elif inst.state == ModuleLoadStateChanged.UNLOADING or inst.state == ModuleLoadStateChanged.UNLOADED:
                um = ModuleLoadStateChanged.createMatcher(module, ModuleLoadStateChanged.UNLOADED)
                await um
        if hasattr(module, '_instance') and (module._instance.state == ModuleLoadStateChanged.SUCCEEDED or
                                             module._instance.state == ModuleLoadStateChanged.FAILED):
            self._logger.info('Unloading module %r', module)
            inst = module._instance
            # Change state to unloading to prevent more dependencies
            await inst.changestate(ModuleLoadStateChanged.UNLOADING, self)
            if not ignoreDependencies:
                deps = [d for d in inst.dependedBy if hasattr(d, '_instance') and d._instance.state != ModuleLoadStateChanged.UNLOADED]
                ums = [ModuleLoadStateChanged.createMatcher(d, ModuleLoadStateChanged.UNLOADED) for d in deps]
                for d in deps:
                    self.subroutine(self.unloadmodule(d), False)
                await self.wait_for_all(*ums)
            await inst.unload(self)
            del self.activeModules[inst.getServiceName()]
            self._logger.info('Module %r is unloaded', module)
            if not ignoreDependencies:
                for d in module.depends:
                    if hasattr(d, '_instance') and module in d._instance.dependedBy:
                        self._removeDepend(module, d)
735009
function (refpath) {
            var bindings = this._bindings[refpath];
            if (bindings) {
                for (var bind in bindings) {
                    if (bindings.hasOwnProperty(bind)) {
                        var moduleDescription = this._getModuleDataDescription(refpath, bind);
                        this.json.removeListener(moduleDescription.container, moduleDescription.property, bindings[bind][1], true);
                    }
                }
                delete this._bindings[refpath];
            }
        }
224348
public void unloadModule(ModuleIdentifier revisionId) {
        Objects.requireNonNull(revisionId, "revisionId");
        Module module = findLoadedModule(revisionId);
        if (module != null) {
            unloadModule(module);
        }
    }
526810
def clear_modules(self):
        """"""
        for child in self.module_selection.winfo_children():
            child.destroy()

        self.clear_ui()

        tk.Label(self.module_ui, text="Start Modis and select a module").grid(
            column=0, row=0, padx=0, pady=0, sticky="W E N S")

        if self.current_button is not None:
            self.current_button.config(bg="white")

        self.module_buttons = {}
        self.current_button = None
251430
public function setModuleSettings(&$config, $module, $settings)
    {
        $config['modules'][$module->getFolderContainer()][$module->getListName()] = $settings;
    }
1083983
public static function setCurrentModule(string $module): void
    {
        if (static::$currentModule !== null) {
            $currentModule = static::$currentModule;
            throw new ApplicationException("Current module was already set to {$currentModule}; once current module is set, you can't change it");
        }

        static::$currentModule = $module;

        // register current module & run init.php if present
        static::registerModule($module);
    }
504018
public void removeType(StaticScope scope, String name) {
    scopedNameTable.remove(getRootNodeForScope(getLookupScope(scope, name)), name);
  }
603076
public void deleteAllPresentationModelsOfType(String presentationModelType) {
        getClientConnector().send(new DeletedAllPresentationModelsOfTypeNotification(presentationModelType));
        List<ClientPresentationModel> models = new LinkedList<ClientPresentationModel>(findAllPresentationModelsByType(presentationModelType));
        for (ClientPresentationModel model: models) {
            delete(model, false);
        }
    }
1100630
private Map<String, String> collectModuleSpecificProps(DefaultInputModule module) {
    Map<String, String> moduleSpecificProps = new HashMap<>();
    AbstractProjectOrModule parent = hierarchy.parent(module);
    if (parent == null) {
      moduleSpecificProps.putAll(module.properties());
    } else {
      Map<String, String> parentProps = parent.properties();
      for (Map.Entry<String, String> entry : module.properties().entrySet()) {
        if (!parentProps.containsKey(entry.getKey()) || !parentProps.get(entry.getKey()).equals(entry.getValue())) {
          moduleSpecificProps.put(entry.getKey(), entry.getValue());
        }
      }
    }
    return moduleSpecificProps;
  }
364965
private function setByTypeModule(string $module, array $fields) : void
    {
        foreach ($fields as $field) {
            $this->setByTypeModuleField($module, $field);
        }
    }
1168501
def del_module(self, module):
        """"""
        rev = util.get_latest_revision(module)
        del self.modules[(module.arg, rev)]
312080
public void initialize(CmsModule module) {

        boolean empty = true;
        Set<String> resTypeNames = Sets.newHashSet();
        for (I_CmsResourceType type : module.getResourceTypes()) {
            m_resourceTypes.addComponent(formatResourceType(type));
            resTypeNames.add(type.getTypeName());
            empty = false;
        }
        if (empty) {
            m_resourceTypes.addComponent(
                new Label(CmsVaadinUtils.getMessageText(Messages.GUI_MODULES_NO_RESOURCE_TYPES_0)));
        }
        empty = true;
        for (CmsExplorerTypeSettings expType : module.getExplorerTypes()) {
            if (resTypeNames.contains(expType.getName())) {
                continue;
            }
            m_explorerTypes.addComponent(formatExplorerType(expType));
            empty = false;
        }

        if (empty) {
            m_explorerTypesPanel.setVisible(false);
        }
    }
825388
def deselect_module(self):
        ''' 
        '''
        self._enabled_fe_channels = []  # ignore any RX sync errors
        self._readout_fifos = []
        self._filter = []
        self._converter = []
        self.dut['TX']['OUTPUT_ENABLE'] = 0
        self._current_module_handle = None
        if isinstance(current_thread(), _MainThread):
            current_thread().name = "MainThread"
1258081
public void replaceModuleFromDefault(String moduleName, String importFile) throws Exception {

        if (OpenCms.getModuleManager().getModule(moduleName) != null) {
            OpenCms.getModuleManager().deleteModule(
                m_cms,
                moduleName,
                true,
                new CmsShellReport(m_cms.getRequestContext().getLocale()));
        }

        importModuleFromDefault(importFile);
    }
1011406
public function removeModule($module)
    {
        foreach ($this->modules as $key => $moduleElement) {
            if ($moduleElement === $module) {
                unset($this->modules[$key]);
                break;
            }
        }

        return $this;
    }
1234923
public void removeModules(List<String> modules) throws Exception {
        long startTime = System.currentTimeMillis();
        Exception exception = null;
        if (!cfg.exists()) {
            init();
        }
        userDir = new File(System.getProperty("user.dir")).getAbsolutePath();
        System.setProperty("user.dir", options.getExecutionDirectory().getAbsolutePath());
        try {
            ConfigurationManager manager = new ConfigurationManager(cfg, false);

            ProjectConfigurationProvider cfgProvider = manager.getProjectConfigurationProvider();
            cfgProvider.removeModules(modules);
        } catch (Exception e) {
            exception = e;
        } finally {
            System.setProperty("user.dir", userDir);
            updateMsg(startTime, exception);
        }
    }