Removes items whose propeerties match a defined pattern

@param array $aProperties A key/value array of properties and matching patterns

@return $this
175321
public function removeByPropertyPattern($aProperties)
    {
        foreach ($this->aEntries as $sHash => $aEntry) {
            foreach ($aProperties as $aPatterns) {
                foreach ($aPatterns as $sProperty => $sPattern) {
                    if (!array_key_exists($sProperty, $aEntry)) {
                        continue 2;
                    } elseif (!preg_match('/^' . $sPattern . '$/i', $aEntry[$sProperty])) {
                        continue 2;
                    }
                }
                unset($this->aEntries[$sHash]);
            }
        }

        return $this;
    }
1121750
public function reduce(...$keys)
    {
        $keys = $this->normalizeKeys($keys);

        foreach ($this->keys() as $key) {
            if (!in_array($key, $keys, true)) {
                $this->remove($key);
            }
        }

        return $this;
    }
1246598
public function remove(... $items) : Set
    {
        $values = $this->_removeSameAll($items);
        $this->setValues($values);
        return $this;
    }
253978
public function removeOperator(string $operator): self
    {
        $this->validateOperator($operator);
        if (false !== ($key = array_search($operator, $this->operators))) {
            unset($this->operators[$key]);
        }

        return $this;
    }
765954
public function setProperties(array $properties) {
		foreach ($this->properties as $prop) {
			$prop->setParent(null);
		}

		$this->properties->clear();

		foreach ($properties as $prop) {
			$this->setProperty($prop);
		}

		return $this;
	}
1336466
public function _mergeWithPrevious($previous)
    {
        if (!$previous)
        {
            return $this;
        }
        if ($previous instanceof DeleteOperation)
        {
            return $previous;
        }
        if ($previous instanceof SetOperation)
        {
            return new SetOperation($this->_apply($previous->getValue(), $this->objects, null));
        }
        if ($previous instanceof RemoveOperation)
        {
            $oldList = $previous->getValue();

            return new RemoveOperation(array_merge((array) $oldList, (array) $this->objects));
        }
        throw new AVException('Operation is invalid after previous operation.');
    }
1299236
public function removeQueries(array $queries) : self
    {
        foreach ($queries as $key) {
            if (!is_string($key)) {
                throw new \InvalidArgumentException("Invalid querystring '" . $key . "'");
            }

            if (isset($this->uri['query'][$key])) {
                unset($this->uri['query'][$key]);
            }
        }

        return $this;
    }
857445
public function replace(array $items): self {
        foreach ($items as $key => $value) {
            $this->has($key) && $this->set($key, $value);
        }
        return $this;
    }
568386
public function remove($names)
    {
        foreach((array) $names as $name)
        {
            if(!isset($this->__options[$name])) {
                $key = array_search($name, $this->__options, true);
            } else {
                $key = $name;
            }

            if($key !== false) {
                unset($this->__options[$key]);
            }
        }

        return $this;
    }
409410
public function delete(array $keys) {
		if ($this->_config['scope']) {
			$keys = $this->_addScopePrefix($this->_config['scope'], $keys);
		}
		return apc_delete($keys) === [];
	}
347244
public function remove($optionNames)
    {
        if ($this->locked) {
            throw new AccessException('Options cannot be removed from a lazy option or normalizer.');
        }

        foreach ((array) $optionNames as $option) {
            unset($this->defined[$option], $this->defaults[$option], $this->required[$option], $this->resolved[$option]);
            unset($this->lazy[$option], $this->normalizers[$option], $this->allowedTypes[$option], $this->allowedValues[$option]);
        }

        return $this;
    }
841790
public function setStackOperations(array $operations)
    {
        $this->stackOperations = [];
        foreach ($operations as $operation) {
            $this->addStackOperation($operation);
        }

        return $this;
    }
614421
public function remove($items)
    {
        if (!is_array($items)) {
            $items = array($items);
        }

        $allItems = $this->getAll();

        foreach ($items as $item) {
            $existingIndex = array_search($item, $allItems);
            if ($existingIndex === false) {
                return;
            }

            unset($allItems[$existingIndex]);
        }

        $this->setAll(array_values($allItems));
    }
910850
public final function deleteItems(array $keys)
   {
       try {
           foreach ($keys as $value) {
               if (!$this->deleteItem($value)) {
                   return false;
               }
           }
       } catch (InvalidArgumentException $e) {
           throw $e;
       }
       return true;
   }
687660
public function replace($values)
    {
        if (! is_array($values) && ! $values instanceof BaseCollection) {
            $values = func_get_args();
        }

        // Trash the current values
        $this->trashCurrentItems();

        // Build valid instances of the given values based on attribute data type
        $this->items = $this->buildValues($values);

        return $this;
    }
976447
public function replaceWith($properties)
    {
        $removed = array_diff(array_keys($this->_values), array_keys($properties));
        foreach ($removed as $k) {
            unset($this->$k);
        }

        foreach ($properties as $k => $v) {
            $this->$k = $v;
        }
    }
119758
public function removeAllAttributes(array $exclusions = [])
    {
        if (!$this->node instanceof DOMElement) {
            return $this;
        }

        foreach ($this->attributes() as $name => $value) {
            if (in_array($name, $exclusions, true)) {
                continue;
            }

            $this->node->removeAttribute($name);
        }

        return $this;
    }