Detach an event listener by id given when it was added.

@param string $name
@param int $id The unique id given by {@see attach()}
@return bool True if the listener has been correctly detached
550883
public function detach( $name, $id )
    {
        if ( !isset( $this->listeners[$name][$id] ) )
        {
            return false;
        }

        unset( $this->listeners[$name][$id] );
        return true;
    }
234724
public function remove(string $nameId): bool
    {
        if (array_key_exists($nameId, $this->elements) === false) {
            return false;
        }

        unset($this->elements[$nameId]);
        return false;
    }
1284062
protected function isSingelton($id)
    {
        return (isset($this->binds[$id]['singleton']) && $this->binds[$id]['singleton'] === true);
    }
993420
public function detach($event, $callback){
        $events = is_array($event) ? $event : array($event);
        $listeners = $this->getOption(self::OPTION_LISTENERS);
        foreach ($events as $event) {
            $eventObject = is_object($event) ? $event : new GenericEvent($event);
            $listeners = $this->removeListener($listeners, $eventObject, $callback);
        }
        $this->setOption(self::OPTION_LISTENERS, $listeners);
    }
1054117
public function read($name, $id = null)
    {
        $definition = $this->capabilities->get($name);

        if ($id !== null) {
            $url = $definition->getUrl() . (string) $id;
        } else {
            $url = $definition->getUrl();
        }

        return $this->client->read($url);
    }
978086
public function deleteRelease(string $id): bool
    {
        $this->getApi()->request($this->getApi()->sprintf('/repos/:owner/:repo/releases/:id',
            $this->getRepositories()->getOwner(), $this->getRepositories()->getRepo(), $id), Request::METHOD_DELETE);

        if ($this->getApi()->getHeaders()['Status'] == '204 No Content') {
            return true;
        }

        return false;
    }
641488
public function removeEventListener(string $name, callable $listener): self
    {
        if (isset($this->internalEventListenersData[$name])) {
            foreach ($this->internalEventListenersData[$name] as $i => $value) {
                if ($value === $listener) {
                    unset($this->internalEventListenersData[$name][$i]);
                    if (empty($this->internalEventListenersData[$name])) {
                        unset($this->internalEventListenersData[$name]);
                    }
                    break;
                }
            }
        }
        return $this;
    }
1117474
public function remove($id)
    {
        if (false === $this->_cache->delete($id)) {
            return $this->_onError('remove');
        }

        return true;
    }
364474
public function detachTags(int $id, DetachRequest $request)
    {
        /** @var \Unite\Tags\HasTagsInterface $object */
        if(!$object = $this->repository->find($id)) {
            abort(404);
        }

        $data = $request->only('tag_names');

        $object->detachTags($data['tag_names']);

        \Cache::tags('response')->flush();

        return $this->successJsonResponse();
    }
1133307
public function removeChild( $name )
	{
		if( !array_key_exists( $name, $this->children ) )
			return FALSE;
		unset( $this->children[$name] );
		return TRUE;
	}
856217
public function deleteRecord($id)
    {
        if (is_object($id)) {
            $entity = $id;
        } else {
            $entity = $this->find($id);
        }

        $this->checkIfOriginRecord($entity);
        $return = $entity;

        if (is_callable([$entity, 'getId']) && $entity->getId() != null) {
            $this->deleteById($entity->getId());
            // detach so odm knows it's gone
            $this->manager->detach($entity);
            $this->manager->clear();
            // Dispatch ModelEvent
            $this->dispatchModelEvent(ModelEvent::MODEL_EVENT_DELETE, $return);
            $return = null;
        }

        return $return;
    }
278461
public function releaseLock($name)
    {
        if (isset($this->locks[$name]) && $this->client->del($name)) {
            unset($this->locks[$name]);

            return true;
        }

        return false;
    }
145128
public function remove($id) {
		// Format id
		$id = $this->_format($id);
		// Verify existence
		if(!$this->has($id)) {
			throw new NotFoundException("'$id' value does not exist");
		}
		// Remove value
		unset($this->values[$id]);
	}
199679
public function deactivate($id)
    {
        $user = $this->findById($id);
        $user->activated = 0;
        $user->activated_at = null;
        $user->save();
        $this->event->fire('users.deactivate',array($user));
        return true;
    }
713045
public static function field($name, $id = null)
    {
        return self::getInstance()
                     ->getBuilder(FieldBehavior::class)
                     ->field($name)
                     ->id($id);
    }
232135
public function destroyTable($name, array $fields, $id)
    {
        $this->modelBuilder->destroy($name);
        $this->formBuilder->destroy($name);

        $migration = $this->migrationBuilder
            ->getMigrationClassPathByKey($name);

        $this->migrateDown($migration);

        $this->migrationBuilder->destroySourceTableMigration($name, $fields);
    }
389584
public function detach(EventManagerInterface $events)
    {
        $sharedManager = $events->getSharedManager();

        foreach ($this->listeners as $index => $listeners) {
            if ($listeners === $this) {
                continue;
            }

            if ($listeners instanceof ListenerAggregateInterface) {
                $listeners->detach($events);
            }

            $events->detach($listeners);
        }

        /** @var array $sharedListeners */
        foreach ($this->sharedListeners as $id => $sharedListeners) {
            foreach ($sharedListeners as $index => $listener) {
                if ($listener === $this) {
                    continue;
                }

                if ($listener instanceof ListenerAggregateInterface) {
                    $listener->detach($events);
                }

                $sharedManager->detach($listener, $id);
            }
        }
    }