Disconnects the specified rule from all data providers.

@param rule Rule to be unmapped.
339573
private void unmapRuleFromAllDataProviders(final R rule) {
        if (rule != null) {
            for (final List<R> mappedRules : dataProvidersToRules.values()) {
                mappedRules.remove(rule);
            }
        }
    }
956610
def disconnect(self):
        """"""
        if self._connected:
            self._connected = False
            self._conn.disconnect()
171580
@Override
    public void removePolicy(String sec, String ptype, List<String> rule) {
        throw new Error("not implemented");
    }
662360
@Override
	protected void disconnect() {

		// Stop thread
		super.disconnect();

		// Stop multicast receiver
		if (multicastReceiver != null) {
			try {
				InetAddress address = InetAddress.getByName(udpAddress);
				multicastReceiver.leaveGroup(address);
			} catch (Exception ignored) {
			}
			try {
				multicastReceiver.close();
			} catch (Exception ignored) {
			}
			multicastReceiver = null;
			String msg = "Multicast discovery service stopped on udp://" + udpAddress + ':' + udpPort;
			if (netIf == null) {
				logger.info(msg + '.');
			} else {
				logger.info(msg + " (" + netIf.getDisplayName() + ").");
			}
		}
	}
276891
def disconnect(self):
        """"""

        if not self.connected:
            raise HardwareError("Cannot disconnect when we are not connected")

        # Close the streaming and tracing interfaces when we disconnect
        self._reports = None
        self._traces = None

        self._loop.run_coroutine(self.adapter.disconnect(0))
        self.connected = False
        self.connection_interrupted = False
        self.connection_string = None
737904
def disconnect(self, connection):
        
        self.log.debug("Disconnecting %s" % connection)
        for dest in list(self._topics.keys()):
            if connection in self._topics[dest]:
                self._topics[dest].remove(connection)
            if not self._topics[dest]:
                # This won't trigger RuntimeError, since we're using keys()
                del self._topics[dest]
203036
@Override
    public synchronized void disconnect() {
        if (connectSession != null) {
            logger.debug("Disconnecting client connection.");
            connectSession.disconnect();
            connectSession = null;
        }
    }
1258364
private void disconnect(ZMQ.Socket socket, String eventName){
        String   endpoint = getConnectedEndPoint(eventName);
        if (endpoint!=null) {
            EventList eventList = connectedMap.get(endpoint);
            if (eventList!=null) {
                socket.unsubscribe(eventName.getBytes());
                traceZmqSubscription(eventName, false);
                eventList.remove(eventName);
                if (eventList.size()==0) {
                    socket.disconnect(endpoint);
                    connectedMap.remove(endpoint);
                }
            }
        }
    }
499357
public void destroy() {
        for (int i = 0; i < rules.size(); i++) {
            final Rule rule = (Rule) rules.get(i);
            rule.destroy();
        }
    }
660577
private void disconnectClauses() {
        this.limits.reduceImportant = 0;
        for (int idx = 1; idx <= maxvar(); idx++) {
            for (int sign = -1; sign <= 1; sign += 2) {
                final int lit = sign * idx;
                watches(lit).release();
                occs(lit).release();
            }
        }
        this.dense = false;
    }
1028528
public void disconnect() {
        Presence unavailablePresence = null;
        if (isAuthenticated()) {
            unavailablePresence = new Presence(Presence.Type.unavailable);
        }
        try {
            disconnect(unavailablePresence);
        }
        catch (NotConnectedException e) {
            LOGGER.log(Level.FINEST, "Connection is already disconnected", e);
        }
    }
510427
public void setRules(java.util.Collection<ScalingRule> rules) {
        if (rules == null) {
            this.rules = null;
            return;
        }

        this.rules = new com.amazonaws.internal.SdkInternalList<ScalingRule>(rules);
    }
769287
private void disposeTriggersAndDataProviders() {
        for (final Map.Entry<T, List<DP>> entry : triggersToDataProviders.entrySet()) {
            // Disconnect from trigger
            unhookFromTrigger(entry.getKey());

            // Dispose trigger itself
            final T trigger = entry.getKey();
            if (trigger instanceof Disposable) {
                ((Disposable) trigger).dispose();
            }

            // Dispose data providers
            final List<DP> dataProviders = entry.getValue();
            if (dataProviders != null) {
                for (final DP dataProvider : dataProviders) {
                    if (dataProvider instanceof Disposable) {
                        ((Disposable) dataProvider).dispose();
                    }
                }
            }
        }

        // Clears all triggers
        triggersToDataProviders.clear();
    }
988871
def remove_rule(self, name):
        
        self._rule_attrs.remove(name)
        delattr(self, name)
316369
void connectionCloses(final Session connection) {
        synchronized (connections) {
            final ExecutorService executorService = connectionThreads.get(connection);
            if (executorService != null) {
                executorService.shutdownNow();
            }
            connectionThreads.remove(connection);
            connections.remove(connection);
        }
    }
1104656
public void disconnect() {
        if (connection != null && connection.isConnected()) {
            connection.close();
            transaction = null;
            setTransaction(null);
        }
    }
201212
public void removeConnectionDataFromGroup(ConnectionData cd) {

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "removeConnectionDataFromGroup", new Object[] { cd });
        boolean removed = false;
        synchronized (connectionData)
        {
            removed = connectionData.remove(cd);
        }
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "removeConnectionDataFromGroup", new Object[] { removed });

    }