for DbKit.removeConfig(configName)
177390
static void removeDbProWithConfig(String configName) {
    	if (MAIN != null && MAIN.config.getName().equals(configName)) {
    		MAIN = null;
    	}
    	map.remove(configName);
    }
278108
function remove(conf) {
  var file = conf.get(ConfigKey.PIDFILE);
  // can be the empty string
  if(file) {
    log.notice('removing pid file %s', file);
    try {
      fs.unlinkSync(file);
    }catch(e) {
      log.warning('failed to remove pid file (%s): %s', file, e.message);
    }
  }
}
495376
def _deregister_config_file(self, key):
        
        state = self.__load_state()
        if 'remove_configs' not in state:
            state['remove_configs'] = {}
        state['remove_configs'][key] = (state['config_files'].pop(key))
        self.__dump_state(state)
610778
public CacheConfigurationBuilder<K, V> remove(ServiceConfiguration<?> configuration) {
    CacheConfigurationBuilder<K, V> otherBuilder = new CacheConfigurationBuilder<>(this);
    otherBuilder.serviceConfigurations.remove(configuration);
    return otherBuilder;
  }
961599
def discard_config(self):
        """"""
        if self.config_session is not None:
            commands = []
            commands.append('configure session {}'.format(self.config_session))
            commands.append('abort')
            self.device.run_commands(commands)
            self.config_session = None
1039431
def _delete_advanced_config(config_spec, advanced_config, vm_extra_config):
    '''
    
    '''
    log.trace('Removing advanced configuration '
              'parameters %s', advanced_config)
    if isinstance(advanced_config, str):
        raise salt.exceptions.ArgumentValueError(
            'The specified \'advanced_configs\' configuration '
            'option cannot be parsed, please check the parameters')
    removed_configs = []
    for key in advanced_config:
        for option in vm_extra_config:
            if option.key == key:
                option = vim.option.OptionValue(key=key, value='')
                config_spec.extraConfig.append(option)
                removed_configs.append(key)
    return removed_configs
1002588
def remove_handler_if_not_configured(self, dict_config, requested_handlers, handler_name, check_key) -> None:
        
        try:
            if not dict_config["handlers"][handler_name][check_key]:
                dict_config["handlers"].pop(handler_name)
                if handler_name in requested_handlers:
                    requested_handlers.remove(handler_name)
        except KeyError:
            # Ignore key errors
            pass
210945
ProviderList removeInvalid() {
        int n = loadAll();
        if (n == configs.length) {
            return this;
        }
        ProviderConfig[] newConfigs = new ProviderConfig[n];
        for (int i = 0, j = 0; i < configs.length; i++) {
            ProviderConfig config = configs[i];
            if (config.isLoaded()) {
                newConfigs[j++] = config;
            }
        }
        return new ProviderList(newConfigs, true);
    }
1102888
def remove_config_lock(name):
    '''
    

    '''
    ret = _default_ret(name)

    ret.update({
        'changes': __salt__['panos.remove_config_lock'](),
        'result': True
    })

    return ret
104378
def _trim_config(self, b_config, mod, key):
        '''
        
        '''
        if isinstance(b_config[mod], list):
            self._remove_list_item(b_config[mod], key)
        elif isinstance(b_config[mod], dict):
            b_config[mod].pop(key)
        return b_config
80684
def unset(config, section, opt=None):
        
        if section not in config.keys():
            raise ConfigError("section '{}' doesn't exist".format(section))

        if opt is None:
            del config[section]
            return

        if opt not in config[section].keys():
            raise ConfigError(
                "option '{}.{}' doesn't exist".format(section, opt)
            )
        del config[section][opt]

        if not config[section]:
            del config[section]
1228231
public function remove()
    {
        $f = json_decode(file_get_contents(FEnv::get("framework.root").
            "elements/config_files/core/apps.json"));
        foreach ($f as $one => $val) {
            if ($val->name == $this->name) {
                unset($f->$one);
                break;
            }
        }

        $f = json_encode($f, JSON_PRETTY_PRINT);
        file_put_contents(FEnv::get("framework.root")."elements/config_files/core/apps.json", $f);

        Server::delete(FEnv::get("framework.root")."apps/".$this->name, "directory");
        Server::delete(
            FEnv::get("framework.root")."public/components/apps/".strtolower($this->name),
            'directory'
        );
    }
491296
public static ns_configtemplate delete(nitro_service client, ns_configtemplate resource) throws Exception
	{
		resource.validate("delete");
		return ((ns_configtemplate[]) resource.delete_resource(client))[0];
	}
36767
public static Single<Boolean> delete(CacheConfigBean cacheConfigBean, String cacheKey) {
        return CacheObjectUtil.remove(cacheConfigBean, cacheKey);
    }
436762
def remove_custom_binding(self, key_name, needs_prefix=False):
        
        k = (needs_prefix, key_name)

        if k in self.custom_bindings:
            self.custom_key_bindings.remove(self.custom_bindings[k].handler)
            del self.custom_bindings[k]
1271098
public void removeConfig(AbstractInterfaceConfig config, String overridePath, ChildData data,
                             AbstractInterfaceConfig registerConfig)
        throws Exception {
        if (data == null) {
            if (LOGGER.isInfoEnabled(config.getAppName())) {
                LOGGER.infoWithApp(config.getAppName(), "Receive data is null");
            }
        } else if (registerConfig == null) {
            if (LOGGER.isInfoEnabled(config.getAppName())) {
                LOGGER.infoWithApp(config.getAppName(), "Register config is null");
            }
        } else {
            if (LOGGER.isInfoEnabled(config.getAppName())) {
                LOGGER.infoWithApp(config.getAppName(), "Receive data: path=[" + data.getPath() + "]" + ", data=[" +
                    StringSerializer.decode(data.getData()) + "]" + ", stat=[" + data.getStat() + "]");
            }
            notifyListeners(config, overridePath, data, true, registerConfig);
        }
    }
1235751
InventoryEntry remove(String key) {
		InventoryEntry ret = configs.remove(key);
		if (ret!=null) {
			ret.getPath().delete();
		}
		return ret;
	}