Delete a member configuration on the NVE interface.
168788
def delete_nve_member(self, nexus_host, nve_int_num, vni):
        """"""

        starttime = time.time()

        path_snip = snipp.PATH_VNI_UPDATE % (nve_int_num, vni)
        self.client.rest_delete(path_snip, nexus_host)

        self.capture_and_print_timeshot(
            starttime, "delete_nve",
            switch=nexus_host)
1174882
function clearConfig() {
    var conf = J$.Config;
    conf.INSTR_READ = null;
    conf.INSTR_WRITE = null;
    conf.INSTR_GETFIELD = null;
    conf.INSTR_PUTFIELD = null;
    conf.INSTR_BINARY = null;
    conf.INSTR_PROPERTY_BINARY_ASSIGNMENT = null;
    conf.INSTR_UNARY = null;
    conf.INSTR_LITERAL = null;
    conf.INSTR_CONDITIONAL = null;
}
867447
def delete(self):
        """"""
        self.conn.delete(self.jid)
        self.reserved = False
354649
private void delete(ReflectedHandle<K, V> n) {
        if (n.inner == null && free != n) {
            throw new IllegalArgumentException("Invalid handle!");
        }

        if (free == n) {
            free = null;
        } else {
            // delete from inner queue
            AddressableHeap.Handle<K, HandleMap<K, V>> nInner = n.inner;
            ReflectedHandle<K, V> nOuter = nInner.getValue().outer;
            nInner.delete();
            nOuter.inner = null;
            nOuter.minNotMax = false;

            // delete pair from inner queue
            AddressableHeap.Handle<K, HandleMap<K, V>> otherInner = nInner.getValue().otherInner;
            ReflectedHandle<K, V> otherOuter = otherInner.getValue().outer;
            otherInner.delete();
            otherOuter.inner = null;
            otherOuter.minNotMax = false;

            // reinsert either as free or as pair with free
            if (free == null) {
                free = otherOuter;
            } else {
                insertPair(otherOuter, free);
                free = null;
            }
        }
        size--;
    }
294997
def deallocate(self):
        """"""
        if self._domain is not None:
            self._domain_delete()
        if self._network is not None and 'network' in self.configuration:
            self._network_delete()
        if self._hypervisor is not None:
            self._hypervisor_delete()
380692
def deleteMember(self, address, id, headers=None, query_params=None, content_type="application/json"):
        
        uri = self.client.base_url + "/network/"+id+"/member/"+address
        return self.client.delete(uri, None, headers, query_params, content_type)
316005
private void removeHelpProperties(JComponent component) {
		component.putClientProperty(HELP_ID_PROPERTY, null);
		component.putClientProperty(HELP_SET_PROPERTY, null);
	}
795493
def remove_all_nexusport_bindings():
    """"""

    LOG.debug("remove_all_nexusport_bindings() called")
    session = bc.get_writer_session()
    session.query(nexus_models_v2.NexusPortBinding).delete()
    session.flush()
1006074
def _delete_nve_db(self, vni, device_id, mcast_group, host_id):
        
        rows = nxos_db.get_nve_vni_deviceid_bindings(vni, device_id)
        for row in rows:
            nxos_db.remove_nexusnve_binding(vni, row.switch_ip, device_id)
166270
public void remove(Env env) {
		T obj = objs.remove(Thread.currentThread());
		if(obj!=null)
			obj.destroy(env);
	}
241267
def DeleteInstance(self, si, logger, session, vcenter_data_model, vm_uuid, vm_name):
        
        # find vm
        vm = self.pv_service.find_by_uuid(si, vm_uuid)
        if vm is not None:
            # destroy vm
            result = self.pv_service.destroy_vm(vm=vm, logger=logger)
        else:
            resource___format = "Could not find the VM {0},will remove the resource.".format(vm_name)
            logger.info(resource___format)
            result = resource___format

        return result
1091880
def remove(self, member):
        
        if not self.client.srem(self.name, member):
            raise KeyError(member)
1123008
def delete(config, group, force):
        """"""
        if not force:
            if not click.confirm(
                    'Confirm that you want to delete group {}'.format(group)):
                sys.exit("Deletion of {} aborted".format(group))

        client = Client()
        client.prepare_connection()
        group_api = API(client)
        group_api.delete(group)
1079595
def discard_config(self):
        """"""
        self.device.cu.rollback(rb_id=0)
        if not self.config_lock:
            self._unlock()
582852
def discard_config(self):
        """"""
        discard_candidate = 'copy running-config {}'.format(self._gen_full_path(self.candidate_cfg))
        discard_merge = 'copy null: {}'.format(self._gen_full_path(self.merge_cfg))
        self._disable_confirm()
        self.device.send_command_expect(discard_candidate)
        self.device.send_command_expect(discard_merge)
        self._enable_confirm()
235952
def _delete_vdev_info(self, vdev):
        """"""
        vdev = vdev.lower()
        network_config_file_name = self._get_network_file()
        device = self._get_device_name(vdev)
        cmd = '\n'.join(("num=$(sed -n '/auto %s/=' %s)" % (device,
                                                    network_config_file_name),
                        "dns=$(awk 'NR==(\"\'$num\'\"+6)&&"
                        "/dns-nameservers/' %s)" %
                                                    network_config_file_name,
                        "if [[ -n $dns ]]; then",
                        "  sed -i '/auto %s/,+6d' %s" % (device,
                                                    network_config_file_name),
                        "else",
                        "  sed -i '/auto %s/,+5d' %s" % (device,
                                                    network_config_file_name),
                        "fi"))
        return cmd
356000
def _delete_membership(self, pipeline=None):
        
        Set(self._key['all'], pipeline=pipeline).remove(self.id)