Deregisters a local check

        Parameters:
            check (ObjectID): Check ID
        Returns:
            bool: ``True`` on success

        The agent will take care of deregistering the check from the Catalog.
513070
async def deregister(self, check):
        
        check_id = extract_attr(check, keys=["CheckID", "ID"])
        response = await self._api.get("/v1/agent/check/deregister", check_id)
        return response.status == 200
755564
synchronized void deRegisterTx(long txId) {
		activeTXs.remove(txId);
		if (isSingleSession) {
			//no need to record history
			return;
		}
		
		//cache only if there are active TXs
		if (activeTXs.isEmpty()) {
			updateHistory.clear();
			updateSummary.clear();
			return;
		}
		
		endedTx.add(new Pair<>(latestTxId, txId));
		
		//drop all tx with END < min(active_start), i.e. drop all that ended before any of the 
		//remaining active transactions started.
		
		long minOpenTx = activeTXs.getFirst();
		while (!endedTx.isEmpty() && endedTx.getFirst().getA() < minOpenTx) {
			long beginID = endedTx.getFirst().getB();
			ArrayList<TxObjInfo> allUpdates = updateHistory.get(beginID);
			if (allUpdates != null) {
				for (TxObjInfo info: allUpdates) {
					long oid = info.getOid();
					long tx = updateSummary.get(oid).getTxId();
					if (tx == beginID) {
						updateSummary.remove(oid);
					}
				}
				updateHistory.remove(beginID);
			}
			endedTx.removeFirst();
		}
	}
310711
public void deregisterTransaction(TransactionImpl tran, boolean recovered) {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "deregisterTransaction", new Object[] { this, tran, recovered });

        //AJQ - use concurrent set on large SMP
        if (isConcurrent)
            _transactions.remove(tran);

        //AJQ - new gate for synchronized block
        if (!isConcurrent || recovered) {
            synchronized (this) {
                //AJQ - only if using standard hashset
                if (!isConcurrent)
                    _transactions.remove(tran);

                if (recovered) {
                    _recoveryManager.deregisterTransaction(tran);
                }
            }
        }

        if (tc.isEntryEnabled())
            Tr.exit(tc, "deregisterTransaction");
    }
629604
protected boolean check(String id, List<String> includes, List<String> excludes) {
		return check(id, includes) && !check(id, excludes);
	}
901706
def deregister(self, reg_data, retry=True, interval=1, timeout=3):
        
        Retry(target=self.publish.direct.delete,
              args=("/controller/registration", reg_data,),
              kwargs={"timeout": timeout},
              options={"retry": retry, "interval": interval})
        _logger.debug("Deregister successfully %s tunnel: %s" %
                      (reg_data["name"],
                       self._conn.tunnels[reg_data["role"]][0],))
387
def delete(self, id):
        ''''''
        if not self._item_path:
            raise AttributeError('delete is not available for %s' % self._item_name)
        target = self._item_path % id
        self._redmine.delete(target)
        return None
416343
def invalidate(self, context, sid):
		""""""
		
		result = self._Document.get_collection().delete_one({'_id': sid})
		
		return result.deleted_count == 1
219101
def deregister(self, event, fn):
        
        if event in self._handler_dict and fn in self._handler_dict[event]:
            self._handler_dict[event].remove(fn)
481386
boolean doResetCheck() {
    if(documents.isEmpty() || (documents.size() > 1 && noMultiReset)) {
      return false;
    }
    return documents.get(docNum).doresetCheck();
  }
895182
def delete(self, rid, raise_on_error=True):
        
        return self.ds.delete(rid, raise_on_error)
270587
function rollback() {
    var parsed = ensureConfig();
    var name = parsed.name;
    // check if is an index number.
    // if yes try to lookup the id
    // by its index.
    try {
        var idx = void 0;
        if (/^[0-9]+$/.test(name)) {
            idx = parseInt(parsed.name) - 1;
            if (idx >= 0) {
                var keys = Object.keys(mu.rollbacks);
                var key = keys[idx];
                if (key)
                    name = key;
            }
        }
    }
    catch (ex) { }
    mu.rollback(parsed.name, parsed.output);
}
808024
def check(id, repair)
      begin
        return get_object(id) != nil
      rescue PEROBS::FatalError => e
        PEROBS.log.error "Cannot read object with ID #{id}: #{e.message}"
        if repair
          begin
            PEROBS.log.error "Discarding broken object with ID #{id}"
            @flat_file.delete_obj_by_id(id)
          rescue PEROBS::FatalError
          end
        end
      end

      return false
    end
1209677
def deregister_hook(self, event, hook):
        

        try:
            self.hooks[event].remove(hook)
            return True
        except ValueError:
            return False
128468
function checksDo(listChecks, cb) {
    if (listChecks.length === 0) {
      return cb();
    }

    var check = listChecks.shift();
    check.func(check.key, function () {
      // schedule the next check
      setImmediate(checksDo, listChecks, cb);
    });
  }
239044
def delete(self, **kwargs):
        
        if self.is_valid:
            if '_id' in self._document:
                to_delete = self.find_one({'_id': self._id})

                if to_delete:
                    before = self.before_delete()
                    if before:
                        return before

                    try:
                        self.delete_one({'_id': self._id})

                        self.after_delete()

                        return self._document
                    except PyMongoException as exc:
                        return PyMongoError(
                            error_message=exc.details.get(
                                'errmsg', exc.details.get(
                                    'err', 'PyMongoError.'
                                )
                            ),
                            operation='delete', collection=type(self).__name__,
                            document=self._document,
                        )
                else:
                    return DocumentNotFoundError(type(self).__name__, self._id)
            else:
                return UnidentifiedDocumentError(
                    type(self).__name__, self._document
                )
843129
def _do_check(self, obj, check_module, check_str):
        ''''''
        opts = self._config['options']
        if check_str in opts:
            fargs = opts[check_str]
            if isinstance(fargs, list):
                out = check_wrapper(getattr(check_module, check_str))(obj, *fargs)
            else:
                out = check_wrapper(getattr(check_module, check_str))(obj, fargs)
        else:
            out = check_wrapper(getattr(check_module, check_str))(obj)

        try:
            if out.info:
                L.debug('%s: %d failing ids detected: %s',
                        out.title, len(out.info), out.info)
        except TypeError:  # pragma: no cover
            pass

        return out
90857
def _is_valid_scan(self):
        
        if self._scan is not None:
            return self._scan
        if self._ordering:
            return False
        if self._facets:
            return False
            #TODO check for child or nested query
        return True