Unmarks this Config instance as readOnly (allows modifications)
439548
public function unmarkReadOnly(): void
    {
        $this->readOnly = false;

        /** @var Config $value */
        foreach ($this->data as $value) {
            if ($value instanceof self) {
                $value->unmarkReadOnly();
            }
        }
    }
1052454
function unregister() {
  let list = [];

  // removes module and all its children from the node's require cache
  let unload = (id) => {
    let module = require.cache[id];

    if (!module) return;

    module.children.forEach((child) => unload(child.id));
    delete require.cache[id];
    list.push(id);
  };

  let sourceMapSupport = require.resolve('source-map-support');

  Object.keys(require.cache).forEach((key) => {
    if (path.extname(key) === VUE_EXT || key === sourceMapSupport) {
      unload(key);
    }
  });

  if (has(require.extensions, VUE_EXT)) {
    delete require.extensions[VUE_EXT];
  }

  if (has(Error, 'prepareStackTrace')) {
    delete Error.prepareStackTrace;
  }

  sourceMapsCache.clear();

  return list;
}
111209
def pop_configuration(self):
        
        if len(self.__configurations) == 1:
            raise IndexError('Can not pop the last configuration from the '
                             'stack of configurations.')
        self.__configurations.pop()
        self.__mapped_attr_cache.clear()
439181
def unset(self, key):
        
        key = key.strip().upper()
        if key not in dir(default_settings) and key not in self._defaults:
            self.logger.debug("Unset %s", key)
            delattr(self, key)
            self.store.pop(key, None)
151913
def cleanup(config=None, path=None):
    """"""
    if config is None:
        config = parse()
    if path is None:
        path = os.getcwd()
    root = config.get('root', 'path')
    root = os.path.join(path, root)
    if sys.path[0] == root:
        sys.path.remove(root)
360453
def unset(self, host, *args):
        
        self.__check_host_args(host, args)
        remove_idx = [idx for idx, x in enumerate(self.lines_)
                      if x.host == host and x.key.lower() in args]
        for idx in reversed(sorted(remove_idx)):
            del self.lines_[idx]
147152
function _remove(key) {
    var i = _keys.indexOf(key)
    if (i > -1) {
      ls.removeItem(key);
      _keys.splice(_keys.indexOf(key), 1);
      delete _config[key];
    }
  }
86751
def clear_and_configure(config=None, bind_in_runtime=True):
    """"""
    with _INJECTOR_LOCK:
        clear()
        return configure(config, bind_in_runtime=bind_in_runtime)
243631
function deinit() {
        _isInitialized = false;

        KeyBindingManager.removeBinding(collapseKey);
        KeyBindingManager.removeBinding(expandKey);
        KeyBindingManager.removeBinding(collapseAllKey);
        KeyBindingManager.removeBinding(expandAllKey);
        KeyBindingManager.removeBinding(collapseAllKeyMac);
        KeyBindingManager.removeBinding(expandAllKeyMac);

        //remove menus
        Menus.getMenu(Menus.AppMenuBar.VIEW_MENU).removeMenuDivider(codeFoldingMenuDivider.id);
        Menus.getMenu(Menus.AppMenuBar.VIEW_MENU).removeMenuItem(COLLAPSE);
        Menus.getMenu(Menus.AppMenuBar.VIEW_MENU).removeMenuItem(EXPAND);
        Menus.getMenu(Menus.AppMenuBar.VIEW_MENU).removeMenuItem(COLLAPSE_ALL);
        Menus.getMenu(Menus.AppMenuBar.VIEW_MENU).removeMenuItem(EXPAND_ALL);

        EditorManager.off(".CodeFolding");
        DocumentManager.off(".CodeFolding");
        ProjectManager.off(".CodeFolding");

        // Remove gutter & revert collapsed sections in all currently open editors
        Editor.forEveryEditor(function (editor) {
            CodeMirror.commands.unfoldAll(editor._codeMirror);
        });
        removeGutters();
    }
349952
List<File> removeUnreadable() {
		// List unreadable
		List<InventoryEntry> unreadable = configs.values()
				.stream()
				.filter(v->!v.getConfiguration().isPresent())
				.collect(Collectors.toList());
		// Remove from inventory
		unreadable.forEach(v->configs.remove(v.getIdentifier()));
		// Return the list of removed files
		return unreadable.stream()
				.map(v->v.getPath())
				.collect(Collectors.toList());
	}
662646
def cleanup(self):
        """"""
        self.exit_config_mode()
        self.write_channel("logout" + self.RETURN)
        count = 0
        while count <= 5:
            time.sleep(0.5)
            output = self.read_channel()
            if "Do you want to log out" in output:
                self._session_log_fin = True
                self.write_channel("y" + self.RETURN)
            # Don't automatically save the config (user's responsibility)
            elif "Do you want to save the current" in output:
                self._session_log_fin = True
                self.write_channel("n" + self.RETURN)

            try:
                self.write_channel(self.RETURN)
            except socket.error:
                break
            count += 1
1359575
def clear(self):
        """"""
        self._config = configparser.RawConfigParser()
        # Override config from command line even if we modify the config file and live reload it.
        self._override_config = {}

        self.read_config()
1128115
def do_remove(config, config_dir):
    
    if not os.path.exists(config_dir):
        print "Configuration '{}' does not exist.".format(config)
        exit(1)
    if confirm("Confirm removal of the configuration '{}'".format(config)):
        shutil.rmtree(config_dir)
        print "Configuration '{}' has been removed.".format(config)
    else:
        print "Removal cancelled."
8145
def _unset_magic_constants(self):
        
        if '__FILE__' in self._replace:
            del self._replace['__FILE__']

        if '__ROUTINE__' in self._replace:
            del self._replace['__ROUTINE__']

        if '__DIR__' in self._replace:
            del self._replace['__DIR__']

        if '__LINE__' in self._replace:
            del self._replace['__LINE__']
168759
def unregister(cls, plugin):
        
        plugs = getattr(cls, '_%s__plugins' % cls.__name__, {})
        try:
            plugs.pop(plugin.name())
        except AttributeError:
            pass
        except ValueError:
            pass
963714
def derive_readonly(self):
        
        readonly = list(self.readonly)
        for key, value in self.field_config.items():
            if 'readonly' in value and value['readonly']:
                readonly.append(key)

        return readonly
898362
def remove_reader(socket)
      if event_mask_for_socket(socket) == ZMQ::POLLIN
        remove(socket)
        return
      end
      raise ArgumentError, "not registered for readability only: %p" % socket
    end