<p>
Remove the indicated <code>{@link org.quartz.Trigger}</code> from the
scheduler.
</p>

@param Key $triggerKey

@return bool
333861
public function unscheduleJob(Key $triggerKey)
    {
        if ($this->store->removeTrigger($triggerKey)) {
            $this->notify(Event::JOB_UNSCHEDULED, new KeyEvent($triggerKey));

            return true;
        }

        return false;
    }
394776
public function denyActivation(string $key): bool
    {

        // Get tokendate from db
        $tokenhandler = new ActivationToken($this->db);
        $tokenhandler->setSelectorTokenString($key);
        $tokenhandler->loadTokenData();

        // Get tokendate from db
        $id_user = $tokenhandler->getUserId();

        // Nothings to do when already removed
        if (empty($id_user)) {
            return false;
        }

        // Remove the user and the token
        $this->deleteUser(new User($id_user));
        $tokenhandler->deleteActivationToken();

        return true;
    }
1226399
public function releaseLock( $key )
    {
        if ( strlen( $key ) > self::MAX_KEY_LENGTH )
        {
            throw new ezcCacheInvalidKeyException( $key, 'Length > ' . self::MAX_KEY_LENGTH . '.' );
        }

        $this->memcache->delete( $key );
    }
777287
public boolean deleteJob (final JobKey jobKey) throws SchedulerException
  {
    validateState ();

    boolean result = false;

    final ICommonsList <? extends ITrigger> triggers = getTriggersOfJob (jobKey);
    for (final ITrigger trigger : triggers)
    {
      if (!unscheduleJob (trigger.getKey ()))
      {
        final StringBuilder sb = new StringBuilder ().append ("Unable to unschedule trigger [")
                                                     .append (trigger.getKey ())
                                                     .append ("] while deleting job [")
                                                     .append (jobKey)
                                                     .append ("]");
        throw new SchedulerException (sb.toString ());
      }
      result = true;
    }

    result = m_aResources.getJobStore ().removeJob (jobKey) || result;
    if (result)
    {
      notifySchedulerThread (0L);
      notifySchedulerListenersJobDeleted (jobKey);
    }
    return result;
  }
1000012
public function remove($key)
	{
		$this->connect();

		$this->driver->delete($key);

		$rc = $this->driver->getResultCode();

		if ($rc !== \Memcached::RES_SUCCESS)
		{
			return false;
		}

		return true;
	}
65527
@Override
    public boolean removeJob(JobKey jobKey, Jedis jedis) throws JobPersistenceException {
        final String jobHashKey = redisSchema.jobHashKey(jobKey);
        final String jobBlockedKey = redisSchema.jobBlockedKey(jobKey);
        final String jobDataMapHashKey = redisSchema.jobDataMapHashKey(jobKey);
        final String jobGroupSetKey = redisSchema.jobGroupSetKey(jobKey);
        final String jobTriggerSetKey = redisSchema.jobTriggersSetKey(jobKey);

        Pipeline pipe = jedis.pipelined();
        // remove the job and any associated data
        Response<Long> delJobHashKeyResponse = pipe.del(jobHashKey);
        // remove the blocked job key
        pipe.del(jobBlockedKey);
        // remove the job's data map
        pipe.del(jobDataMapHashKey);
        // remove the job from the set of all jobs
        pipe.srem(redisSchema.jobsSet(), jobHashKey);
        // remove the job from the set of blocked jobs
        pipe.srem(redisSchema.blockedJobsSet(), jobHashKey);
        // remove the job from its group
        pipe.srem(jobGroupSetKey, jobHashKey);
        // retrieve the keys for all triggers associated with this job, then delete that set
        Response<Set<String>> jobTriggerSetResponse = pipe.smembers(jobTriggerSetKey);
        pipe.del(jobTriggerSetKey);
        Response<Long> jobGroupSetSizeResponse = pipe.scard(jobGroupSetKey);
        pipe.sync();
        if(jobGroupSetSizeResponse.get() == 0){
            // The group now contains no jobs. Remove it from the set of all job groups.
            jedis.srem(redisSchema.jobGroupsSet(), jobGroupSetKey);
        }

        // remove all triggers associated with this job
        pipe = jedis.pipelined();
        for (String triggerHashKey : jobTriggerSetResponse.get()) {
            // get this trigger's TriggerKey
            final TriggerKey triggerKey = redisSchema.triggerKey(triggerHashKey);
            final String triggerGroupSetKey = redisSchema.triggerGroupSetKey(triggerKey);
            unsetTriggerState(triggerHashKey, jedis);
            // remove the trigger from the set of all triggers
            pipe.srem(redisSchema.triggersSet(), triggerHashKey);
            // remove the trigger's group from the set of all trigger groups
            pipe.srem(redisSchema.triggerGroupsSet(), triggerGroupSetKey);
            // remove this trigger from its group
            pipe.srem(triggerGroupSetKey, triggerHashKey);
            // delete the trigger
            pipe.del(triggerHashKey);
        }
        pipe.sync();

        return delJobHashKeyResponse.get() == 1;
    }
1075250
public function remove($key)
    {
        if ($key == 'message') {
            $this->message = '';
        }

        if ($key == 'exception') {
            $this->exception = null;
        }

        if (array_key_exists($key, $this->payload)) {
            unset($this->payload[$key]);
        }
    }
1081104
public function del($key)
    {
        if ($this->isMappedKey($key)) {
            return false;
        } else {
            $success = true;
            if ($this->hasMaxSize()) {
                $success = $this->deleteMappedKey($key);
            }
            return $success && $this->getDriver()->del($key);
        }
    }
1011376
public static function remove($key) {

		if(false === is_string($key)) {
			return trigger_error(sprintf('Argument 1 passed to %s() must be of the type string, "%s" given', __METHOD__, gettype($key)), E_USER_ERROR);
		}

		if($key && isset(static :: $data[$key])) {
			unset(static :: $data[$key]);
		}
	}
1185249
@Override
    public boolean removeCalendar(String calendarName, JedisCluster jedis) throws JobPersistenceException {
        final String calendarTriggersSetKey = redisSchema.calendarTriggersSetKey(calendarName);

        if (jedis.scard(calendarTriggersSetKey) > 0) {
            throw new JobPersistenceException(String.format("There are triggers pointing to calendar %s, so it cannot be removed.", calendarName));
        }
        final String calendarHashKey = redisSchema.calendarHashKey(calendarName);
        Long deleteResponse = jedis.del(calendarHashKey);
        jedis.srem(redisSchema.calendarsSet(), calendarHashKey);

        return deleteResponse == 1;
    }
713649
protected function removeKeyFromJsonData($key, &$getJsonData)
    {
        $this->crontab->remove((int) ltrim($key, 'ID'));

        if( isset($getJsonData[$key]) )
        {
            unset($getJsonData[$key]);
        }
    }
1116681
public void resumeJob (@Nonnull final TriggerKey aTriggerKey)
  {
    ValueEnforcer.notNull (aTriggerKey, "TriggerKey");
    try
    {
      m_aScheduler.resumeTrigger (aTriggerKey);
      LOGGER.info ("Succesfully resumed job with TriggerKey " + aTriggerKey.toString ());
    }
    catch (final SchedulerException ex)
    {
      LOGGER.error ("Failed to resume job with TriggerKey " + aTriggerKey.toString (), ex);
    }
  }
1205280
public function removeHeader($key) {

		if(false === is_string($key)) {
			return trigger_error(sprintf('Argument 1 passed to %s() must be of the type string, "%s" given', __METHOD__, gettype($key)), E_USER_ERROR);
		}

		if(true === isset($this -> headers['custom'][$key])) {
			unset($this -> headers['custom'][$key]);
		}
	}
354388
public function remove($key)
    {
        $this->initializeOnDemand();

        if ($this->has($key) && $this->cacheMapper->delete($key)) {
            unset($this->cache[$key]);
            return true;
        } else {
            return false;
        }
    }
719266
public function forget($key)
    {
        if (false === is_resource($this->dba)) {
            return false;
        }

        return dba_delete($key, $this->dba);
    }
454390
protected function doPauseTrigger(Key $triggerKey)
    {
        if (false == $trigger = $this->retrieveTrigger($triggerKey)) {
            return;
        }

        if (false == in_array($trigger->getState(), [Trigger::STATE_WAITING, Trigger::STATE_ACQUIRED], true)) {
            return;
        }

        $trigger->setState(Trigger::STATE_PAUSED);
        $result = $this->res->getTriggerStorage()->update($trigger);

        if (false == $result->isAcknowledged() || false == $result->getModifiedCount()) {
            throw new JobPersistenceException(sprintf('Couldn\'t pause trigger: "%s"', $triggerKey));
        }
    }
71134
public void deleteKey(HKey hk, String key) throws RegistryException {
		int rc = -1;
		try {
			rc = ReflectedMethods.deleteKey(hk.root(), hk.hex(), key);
		} catch (Exception e) {
			throw new RegistryException("Cannot delete key " + key, e);
		}
		if (rc != RC.SUCCESS) {
			throw new RegistryException("Cannot delete key " + key + ". Return code is " + rc);
		}
	}