Deletes the specified floatingip
760708
def delete_floatingip(self, floatingip_id):
        '''
        
        '''
        ret = self.network_conn.delete_floatingip(floatingip_id)
        return ret if ret else True
904735
public static synchronized void removeTruncationRecord(UUID cfId)
    {
        String req = "DELETE truncated_at[?] from system.%s WHERE key = '%s'";
        executeInternal(String.format(req, LOCAL_CF, LOCAL_KEY), cfId);
        truncationRecords = null;
        forceBlockingFlush(LOCAL_CF);
    }
558102
def remove_value(self, name):
        """"""
        code = u"get_ipython().kernel.remove_value('%s')" % name
        if self._reading:
            self.kernel_client.input(u'!' + code)
        else:
            self.silent_execute(code)
689940
def unassign_floating_ip(kwargs=None, call=None):
    '''
    
    '''
    if call != 'function':
        log.error(
            'The inassign_floating_ip function must be called with -f or --function.'
        )
        return False

    if not kwargs:
        kwargs = {}

    if 'floating_ip' not in kwargs:
        log.error('A floating IP is required.')
        return False

    result = query(method='floating_ips',
                   command=kwargs['floating_ip'] + '/actions',
                   args={'type': 'unassign'},
                   http_method='post')

    return result
247313
def floating_ip_delete(self, floating_ip):
        '''
        
        '''
        ip = self.floating_ip_show(floating_ip)
        nt_ks = self.compute_conn
        return nt_ks.floating_ips.delete(ip)
761678
public static void removeSipSubcontext(Context envCtx) {
		try {
			envCtx.destroySubcontext(SIP_SUBCONTEXT);
		} catch (NamingException e) {
			logger.error(sm.getString("naming.unbindFailed", e));
		}
	}
36962
public void deleteMsgsWithNoReferences() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "deleteMsgsWithNoReferences");

        if (null != _pubSubRealization) //doing a sanity check with checking for not null
            _pubSubRealization.deleteMsgsWithNoReferences();

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "deleteMsgsWithNoReferences");
    }
1297124
def delete(self):
        """"""
        if lib.EnvDeleteInstance(self._env, self._ist) != 1:
            raise CLIPSError(self._env)
490737
def clear(self):
        ""
        self._pb.IntMap.clear()
        self._pb.StringMap.clear()
        self._pb.FloatMap.clear()
        self._pb.BoolMap.clear()
1041579
def delete_virtualip(self, loadbalancer, vip):
        """"""
        lb = vip.parent
        if not lb:
            raise exc.UnattachedVirtualIP("No parent Load Balancer for this "
                    "VirtualIP could be determined.")
        resp, body = self.api.method_delete("/loadbalancers/%s/virtualips/%s" %
                (lb.id, vip.id))
        return resp, body
81843
def remove(self, *args):
        

        key = self.get_storage_key(*args)
        pk = self.instance.pk.get()
        logger.debug("removing %s from index %s" % (pk, key))
        self.connection.srem(key, pk)
        self._deindexed_values.add(tuple(args))
251999
public void clear() {
        iMinPrintedDigits = 1;
        iPrintZeroSetting = PRINT_ZERO_RARELY_LAST;
        iMaxParsedDigits = 10;
        iRejectSignedValues = false;
        iPrefix = null;
        if (iElementPairs == null) {
            iElementPairs = new ArrayList<Object>();
        } else {
            iElementPairs.clear();
        }
        iNotPrinter = false;
        iNotParser = false;
        iFieldFormatters = new FieldFormatter[10];
    }
1096503
def update_floatingip(self, floatingip_id, port=None):
        '''
        
        '''
        if port is None:
            body = {'floatingip': {}}
        else:
            port_id = self._find_port_id(port)
            body = {'floatingip': {'port_id': port_id}}
        return self.network_conn.update_floatingip(
            floatingip=floatingip_id, body=body)
317465
def delete(self):
        
        cmd = self.command_builder('ntp source', disable=True)
        return self.configure(cmd)
684087
def RemoveForwardedIp(self, address, interface):
    
    ip = netaddr.IPNetwork(address)
    self._RunIfconfig(args=[interface, '-alias', str(ip.ip)])
1195213
def remove(cls, pid):
        
        with cls._lock:
            cls._ensure_pool_exists(pid)
            cls._pools[pid].close()
            del cls._pools[pid]
38127
function destroy(foPairs, index, collection, operand) {
  if (foPairs[index][collection].size === 1) {
    if (containsOne(foPairs[index])) {
      delete foPairs[index];
    } else {
      delete foPairs[index][collection];
    }
  }else {
    foPairs[index][collection].delete(operand);
  }
}