@brief Removes one event.

@param string Name of event

@return array Array of events after removal
519973
public function removeEventByName($event_name)
    {
        foreach($this->_events as $key => $event)
        {
            if(strpos($event, $event_name) !== false)
            {
                array_splice($this->_events, $key, 1);
            }
        }
        return $this->_events;
    }
805746
public function remove(string $name) : core\collections\interfaces\NamedObjectSet
    {
        // If no Argument is defined for the given name, there's nothing to remove.
        if (!isset($this->items[$name])) {
            return $this;
        }

        /* @var input\Argument $argument */
        $value = $argument->getValue();

        // There's at most one Multiple Value accepting Argument so we can remove that flag safely.
        if ($value instanceof input\values\Multiple) {
            $this->hasMultiparam = false;
        }

        // Reduce our counter of required arguments.
        if ($value->is(input\Value::REQUIRED)) {
            $this->required--;
        }
        // @fixme - We're not checking whether other Arguments are optional.
        else {
            $this->hasOptional = true;
        }

        return parent::remove($name);
    }
264388
public function getEvent($name)
    {

        if (!isset($this->_events))
            $this->_events = [];

        if (!isset($this->_events[$name])) {

            $className = $this->getEventClassName();
            $this->_events[$name] = new $className($name);
        }

        return $this->_events[$name];
    }
1312045
function removeCommand($name)
    {
        unset($this->commands[$name]);
        foreach ($this->groups as $key => $commands){
            foreach ($commands as $i => $c){
                if ($c[0] == $name){
                    unset($this->groups[$key][$i]);
                }
            }
        }
    }
580416
function (name) {
		var prop = this.properties[name];
		if (prop) {
			this.stopListening(prop, EVENT_CHANGE, this.change);
			delete this.properties[name];
			return prop;
		}
		return null;
	}
1335696
protected function IblockTypeDelete($name)
    {
        $return = [];
        $name = trim($name);
        if (empty($name)) {
            throw new Exception('You must set iblock type ID');
        }
        if (CIBlockType::Delete($name)) {
            $return[] = "Delete {$name} iblock type";
        } else {
            throw new Exception("Can't delete {$name} iblock type");
        }

        return $return;
    }
874927
public function remove($name)
    {
        parent::remove($name);

        return $this->set($name, null, [
            self::OPTION_EXPIRE => 0
        ]);
    }
129165
public function remove($name)
    {
        unset($this->plugins[$name]);
        $this->names = array_keys($this->plugins);

        return $this;
    }
742810
public T remove() {
        EventImpl event = (EventImpl) CurrentEvent.get();
        if (null != event) {
            // Also need to remove name, if specified, from the Event's Set.
            if (name != null) {
                event.removeEventLocalName(name);
            }
            return event.remove(this);
        }
        return null;
    }
311194
public function removeName(Name $name)
    {
        if ($this->names->contains($name)) {
            $this->names->removeElement($name);
            $name->setItem(null);
        }

        return $this;
    }
552313
public function remove($name)
    {
        if (!isset($this->indexed[$name])) {
            return;
        }
        unset($this->indexed[$name]);

        foreach ($this->items as $i => $v) {
            if ($v === $name) {
                unset($this->items[$i]);
            }
        }
    }
390911
function(events) {
	return {
		remove: function() { // Remove multiple events.
			for (var key in events) {
				events[key].remove();
			}
		},
		add: function() { // Add multiple events.
			for (var key in events) {
				events[key].add();
			}
		}
	};
}
609681
public function getResult($name = '') {
        $result = [];

        if ($name != '') {
            if (isset($this->_events[$name])) {
                return $this->_events[$name]->getResult();
            }
            else {
                return false;
            }
        }
        else {
            foreach ($this->_events as $events) {
                $result[$events->getName()] = $events->getResult();
            }

            return $result;
        }
    }
864057
def clear_events(self, event_name):
        
        self.lock.acquire()
        try:
            q = self.get_event_q(event_name)
            q.queue.clear()
        except queue.Empty:
            return
        finally:
            self.lock.release()
1336101
public function removeMethod($name)
    {
        if (isset($this->methods[$name])) {
            unset($this->methods[$name]);
        }

        return $this;
    }
636126
public static function destroy($name)
    {
        if (is_array($name)) {
            foreach ($name as $v) {
                self::destroy($v);
            }
        } elseif (is_string($name) && self::hasTask($name)) {
            unset(self::$tasks[$name]);
        }
    }
1342497
public function removeElement($name)
    {
        $returnValue = false;

		foreach($this->elements as $index => $element){
			if($element->getName() == $name){
				unset($this->elements[$index]);
				$groupName = $this->getElementGroup($name);
				if(!empty($groupName)){
					if(isset($this->groups[$groupName]['elements'][$name])){
						unset($this->groups[$groupName]['elements'][$name]);
					}
				}
				$returnValue = true;
			}
		}

        return $returnValue;
    }