Remove the given monitor from the listed devices and events.
194701
def _remove_monitor(monitors, handle, devices, events):
    """"""

    empty_devices = []

    for conn_string in devices:
        data = monitors.get(conn_string)
        if data is None:
            continue

        for event in events:
            event_dict = data.get(event)
            if event_dict is None:
                continue

            if handle in event_dict:
                del event_dict[handle]

            if len(event_dict) == 0:
                del data[event]

        if len(data) == 0:
            empty_devices.append(conn_string)

    return empty_devices
1282139
private synchronized void remove(TableRowProgressMonitor monitor) {
    final int row = monitors.indexOf(monitor);
    if (row >= 0) {
      monitors.remove(row);
      SwingUtilities.invokeLater(new Runnable() {
        public void run() {
          fireTableRowsDeleted(row, row); // row your boat...
        }
      });
    }
  }
759490
def resetMonitors(self):
        
        Debug.error("*** BE AWARE: experimental - might not work ***")
        Debug.error("Re-evaluation of the monitor setup has been requested")
        Debug.error("... Current Region/Screen objects might not be valid any longer")
        Debug.error("... Use existing Region/Screen objects only if you know what you are doing!")
        self.__init__(self._screenId)
        self.showMonitors()
1207597
def detach_hardware(self, ticket_id=None, hardware_id=None):
        
        return self.ticket.removeAttachedHardware(hardware_id, id=ticket_id)
48296
def remove(self):
        
        self._multivol.deallocate(self.id)
        ARRAY_CACHE.pop(self.id, None)
        PIXEL_CACHE.pop(self.id, None)
370862
public void removeDisplay(String displayID) throws ShanksException {
        Scenario2DPortrayal scenarioPortrayal = (Scenario2DPortrayal) this
                .getSimulation().getScenarioPortrayal();
        HashMap<String, Display2D> displays = scenarioPortrayal.getDisplays();
        if (displays.containsKey(displayID)) {
            displays.remove(displayID);
        }
    }
454633
@Override
  public void unregister(Monitor<?> monitor) {
    try {
      List<MonitorMBean> beans = MonitorMBean.createMBeans(name, monitor, mapper);
      for (MonitorMBean bean : beans) {
        try {
          mBeanServer.unregisterMBean(bean.getObjectName());
          locks.remove(bean.getObjectName());
        } catch (InstanceNotFoundException ignored) {
          // ignore errors attempting to unregister a non-registered monitor
          // a common error is to unregister twice
        }
      }
      monitors.remove(monitor.getConfig());
      updatePending.set(true);
    } catch (Exception e) {
      LOG.warn("Unable to un-register Monitor:" + monitor.getConfig(), e);
    }
  }
1065485
public static void unRegister(Monitor monitor) {
        ScheduledFuture future = register.remove(monitor);
        if (future != null) {
            future.cancel(true);// 打断
        }
    }
857412
def remove_receiver(self, receiver):
        
        if receiver in self.event_receivers:
            self.event_receivers.remove(receiver)
12326
def remove_monitor(self, handle):
        

        action = (handle, "delete", None, None)
        if self._currently_notifying:
            self._deferred_adjustments.append(action)
        else:
            self._adjust_monitor_internal(*action)
744396
private void sawMonitorExit(int pc) {
        if (!monitorSyncPCs.isEmpty()) {
            ScopeBlock sb = findSynchronizedScopeBlock(rootScopeBlock, monitorSyncPCs.get(0).intValue());
            if (sb != null) {
                sb.setFinish(pc);
            }
            monitorSyncPCs.remove(monitorSyncPCs.size() - 1);
        }
    }
934775
def _delete_device(device):
    '''
    
    '''
    log.trace('Deleting device with type %s', type(device))
    device_spec = vim.vm.device.VirtualDeviceSpec()
    device_spec.operation = vim.vm.device.VirtualDeviceSpec.Operation.remove
    device_spec.device = device
    return device_spec
1355968
def _delete_device_from_device_group(self, device):
        '''
        '''

        device_name = get_device_info(device).name
        dg = pollster(self._get_device_group)(device)
        device_to_remove = dg.devices_s.devices.load(
            name=device_name, partition=self.partition
        )
        device_to_remove.delete()
884088
def clear(self):
        """"""
        self.command(c.LCD_CLEARDISPLAY)
        self._cursor_pos = (0, 0)
        self._content = [[0x20] * self.lcd.cols for _ in range(self.lcd.rows)]
        c.msleep(2)
341491
def _process_removed_port(self, device):
        """"""
        LOG.debug("Trying to remove the port %r", device)
        self._update_port_status_cache(device, device_bound=False)
        self._port_unbound(device, vnic_deleted=True)

        LOG.debug("The port was successfully removed.")
        self._removed_ports.discard(device)
323606
function unlinkFromCuratedDeviceEvents() {
        self.curatedDevice.removeListener(
            'DEVICE_DISCONNECTED',
            curatedDeviceDisconnected
        );
        self.curatedDevice.removeListener(
            'DEVICE_RECONNECTED',
            curatedDeviceReconnected
        );
        self.curatedDevice.removeListener(
            'DEVICE_ERROR',
            curatedDeviceError
        );
        self.curatedDevice.removeListener(
            'DEVICE_RECONNECTING',
            curatedDeviceReconnecting
        );
        self.curatedDevice.removeListener(
            'DEVICE_ATTRIBUTES_CHANGED',
            cureatedDeviceAttributesChanged
        );
    }
1096715
@Override
  public void unregister(Monitor<?> monitor) {
    Preconditions.checkNotNull(monitor, "monitor");
    try {
      monitors.remove(monitor);
    } catch (Exception e) {
      throw new IllegalArgumentException("invalid object", e);
    }
  }