Removes the specified element from the collection, if it is found.

@param mixed $element The element to remove.

@return bool TRUE if this collection contained the specified element, FALSE otherwise.
434353
public function removeElement($element)
    {
        if (!$this->hasElement($element)) {
            return false;
        }

        $totalCollection = $this->count();
        $key             = $this->indexOf($element);

        unset($this->collections[$key]);

        return $this->count() !== $totalCollection;
    }
427039
public function remove($key) {
		$key = $this->extractKey($key);
		if (isset($this->collection[$key])) {
			$element = $this->collection[$key];
			unset($this->collection[$key]);
			
			return $element;
		}
	}
79774
public boolean remove(final T element) {
    for (int i = 0; i < this.size; i++)
      if (this.elements[i].equals(element)) {
        System.arraycopy(this.elements, i + 1, this.elements, i, this.size - (i + 1));
        this.size--;
        return true;
      }
    return false;
  }
724615
function element_deletable($element) {
        global $COURSE;

        if ($element['type'] != 'item') {
            return true;
        }

        $grade_item = $element['object'];

        if ($grade_item->itemtype != 'mod' or $grade_item->is_outcome_item() or $grade_item->gradetype == GRADE_TYPE_NONE) {
            return true;
        }

        $modinfo = get_fast_modinfo($COURSE);
        if (!isset($modinfo->instances[$grade_item->itemmodule][$grade_item->iteminstance])) {
            // module does not exist
            return true;
        }

        return false;
    }
233672
public function is(Hierarchy $element)
    {
        if (get_class($this) !== get_class($element))
            return false;
        return $this->id === $element->id;
    }
418258
public function removeElement(AbstractElement $element)
	{
		$id = $element->getId();

		if (!isset($this->elements[$id])) {
			throw new MissingElementException("Element \"$id\" is not indexed.");
		}

		unset($this->elements[$id]);

		$indexedAttrs = array_intersect_key($element->getAttributes(), $this->index);
		foreach ($indexedAttrs as $key => $oldValue) {
			unset($this->index[$key][$oldValue][$id]);
		}
	}
419115
public function remove($name)
    {
        $removed = false;
        if ($this->has($name)) {
            $this->elements->rewind();
            while($this->elements->valid()) {
                if ($this->elements->current()->getName() == $name) {
                    $this->elements->remove();
                    $removed = true;
                    break;
                }
                $this->elements->next();
            }
        }

        return $removed;
    }
1234562
public static function remove_node($node) {
		if (
			! \is_a($node, 'DOMElement') &&
			! \is_a($node, 'DOMNode')
		) {
			return false;
		}

		$node->parentNode->removeChild($node);

		return true;
	}
235239
public function remove($key)
    {
        if ($this->has($key)) {
            $array = &$this->data;
            foreach (explode(self::SEPERATOR, $key) as $item) {
                if (array_key_exists($item, $array)) {
                    $lastArray = &$array;
                    $array = &$array[$item];
                }
            }
            
            unset($lastArray[$item]);
            if (empty($lastArray)) {
                unset($lastArray);
            }
            $this->save();
            return true;
        }
        
        return false;
    }
1089957
public function remove($item)
    {
        $key = $item instanceof Item ? $item->name : $item;

        if ($this->has($key)) {
            $this->forget($key);
            return true;
        }

        return false;
    }
762003
public function contains($element) : bool
    {
        $acc = [];
        foreach ($this->list as $item) {
            $acc[] = is_array($item) ? A\mapDeep(function ($val) use ($element) {
                return $val == $element;
            }, $item) : $item == $element;
        }

        return self::checkContains($acc);
    }
991711
public function contains($element)
    {
        $hashIndex = $this->hashIndex($element);

        if (array_key_exists($hashIndex, $this->_items)) {
            return true;
        }
        return false;
    }
1031143
public function removeSortable($element)
    {
        if (array_has($this->sortable, $element)) {
            return $this->sortable = array_except($this->sortable, $element);
        }

        if (in_array($element, $this->sortable(), true)) {
            return $this->sortable = array_except(
                $this->sortable,
                array_search($element, $this->sortable, true)
            );
        }

        return $this->sortable;
    }
397968
public function remove($element)
    {
        $index = $this->indexOf($element);

        if ($index !== false) {
            unset($this->_items[$index]);
            $this->_items = array_values($this->_items);
            $this->_iterator = null;
            return true;
        }
        return false;
    }
1119561
public function remove(DOMElement &$element)
    {
        if (empty($element->parentNode)) {
            throw new DOMException('The current DOMItem has no parent.');
        }

        // Remove the element
        $element->parentNode->removeChild($element);
    }
1183490
public function remove($element) {
		$index = array_search($element, $this->collection, true);
		if ($index !== null) {
			unset($this->collection[$index]);
		}

		return $this;
	}
365393
public void remove( Element<T> element ) {
		if( element.next == null ) {
			last = element.previous;
		} else {
			element.next.previous = element.previous;
		}
		if( element.previous == null ) {
			first = element.next;
		} else {
			element.previous.next = element.next;
		}
		size--;
		element.clear();
		available.push(element);
	}