Remove all of the hooks from a filter.

@param string   $tag      The filter to remove hooks from.
@param int|bool $priority Optional. The priority number to remove. Default false.

@return true True when finished.
174751
public function remove_all_filters($tag, $priority = false)
    {
        if (isset($this->filter[ $tag ])) {
            if (false === $priority) {
                $this->filter[ $tag ] = array();
            } elseif (isset($this->filter[ $tag ][ $priority ])) {
                $this->filter[ $tag ][ $priority ] = array();
            }
        }

        unset($this->merged_filters[ $tag ]);

        return true;
    }
253712
public function hasTag(Tag $tag)
    {
        foreach ($this->_tags as $knownTag) {
            if ($knownTag->getId() == $tag->getId()) {
                return true;
            }
        }

        return false;
    }
702716
public function printOnTag( string $tag, int $priority = 10) {
		$html = $this->render();
		$function_to_add = function () use ( $html ) {
			echo $html;
		};
		
		return Filters::add( $tag, $function_to_add, $priority, 0);
	}
894852
protected function removeOneTag($tag) {
        if ($tag = Tag::findBy('tag', $tag))
            $this->tags()->detach($tag);
    }
127090
public void removeTaggedComponent(final String tag) {
		TemplateModel model = getOrCreateComponentModel();
		if (model.taggedComponents != null) {
			WComponent component = model.taggedComponents.remove(tag);
			if (model.taggedComponents.isEmpty()) {
				model.taggedComponents = null;
			}
			if (component != null) {
				remove(component);
			}
		}
	}
937981
public function DelSubCommunity(string $tag = NULL)
    {
        if (GnUtil::IsNullOrEmpty($tag)) {
            throw new \InvalidArgumentException("tag required");
        }

        $this->ExecuteCall("DelSubCommunity", (object)[
            "tag" => $tag
        ], GnResponseType::Json, FALSE, PHP_INT_MAX);
    }
753325
protected function addFilter($tag, $function_to_add, $priority = 10, $accepted_args = 1)
    {
        global $wp_filter;

        $idx                              = $this->filterBuildUniqueId($function_to_add);
        $wp_filter[$tag][$priority][$idx] = array('function' => $function_to_add, 'accepted_args' => $accepted_args);
        return true;
    }
1050279
public static function writeLog($priority, $tag, $msg) // [int priority, String tag, String msg]
    {
        $logger = AxolotlLoggerProvider::getProvider();
        if (($logger != null)) {
            $logger->log($priority, $tag, $msg);
        }
    }
186115
public function hasTag ($tag)
	{
		
		foreach ($this->lines as $line)
		{
			if (strpos ($line, '@' . $tag) === 0)
			{
				return TRUE;
			}
		}
		
		return FALSE;
		
	}
941142
public function filter($name, $callable, $priority = 10, $override = false)
    {
        if ($override) {
            $this->clearFilters($name);
        }

        if (!isset($this->filters[$name])) {
            $this->filters[$name] = array(array());
        }
        if (is_callable($callable)) {
            $this->filters[$name][(int) $priority][] = $callable;
        }
    }
859240
def tag_delete(self, tag):
        
        if tag:
            if self.__git_tag_delete(tag):
                return True
            return False

        if self.__git_tag_delete(self.get_latest_tag()):
            return True
        return False
438220
public function remove_item_by_priority( $priority = 0 ) {
		// Search all items for the same priority.
		$all_items = $this->get_items();
		if ( array_key_exists( $priority, $all_items ) ) {
			// Remove all items with that priority.
			unset( $all_items[ $priority ] );
		}

		// Update the items.
		$this->set_items( $all_items );
	}
724325
protected function _filterTag($tag)
    {
        // Parse the tag into:
        // 1. a starting delimiter (mandatory)
        // 2. a tag name (if available)
        // 3. a string of attributes (if available)
        // 4. an ending delimiter (if available)
        $isMatch = preg_match('~(</?)(\w*)((/(?!>)|[^/>])*)(/?>)~', $tag, $matches);

        // If the tag does not match, then strip the tag entirely
        if (!$isMatch) {
            return '';
        }

        // Save the matches to more meaningfully named variables
        $tagStart = $matches[1];
        $tagName = strtolower($matches[2]);
        $tagAttributes = $matches[3];
        $tagEnd = $matches[5];

        // If the tag is not an allowed tag, then remove the tag entirely
        if (!isset($this->_tagsAllowed[$tagName])) {
            return '';
        }

        // Trim the attribute string of whitespace at the ends
        $tagAttributes = trim($tagAttributes);

        // If there are non-whitespace characters in the attribute string
        if (strlen($tagAttributes)) {
            // Parse iteratively for well-formed attributes
            preg_match_all('/(\w+)\s*=\s*(?:(")(.*?)"|(\')(.*?)\')/s', $tagAttributes, $matches);

            // Initialize valid attribute accumulator
            $tagAttributes = '';

            // Iterate over each matched attribute
            foreach ($matches[1] as $index => $attributeName) {
                $attributeName = strtolower($attributeName);
                $attributeDelimiter = $matches[2][$index];
                $attributeValue = $matches[3][$index];

                // If the attribute is not allowed, then remove it entirely
                if (!array_key_exists($attributeName, $this->_tagsAllowed[$tagName]) && !array_key_exists($attributeName, $this->_attributesAllowed)) {
                    continue;
                }
                // Add the attribute to the accumulator
                $tagAttributes .= " $attributeName=" . $attributeDelimiter . $attributeValue . $attributeDelimiter;
            }
        }

        // Reconstruct tags ending with "/>" as backwards-compatible XHTML tag
        if (strpos($tagEnd, '/') !== false) {
            $tagEnd = " $tagEnd";
        }

        // Return the filtered tag
        return $tagStart . $tagName . $tagAttributes . $tagEnd;
    }
1191801
public function deleteByTags($tag)
    {
        if (!isset($this->tags[$tag])) {
            return false;
        }

        foreach ($this->tags[$tag] as $key) {
            $this->delete($key);
        }

        return true;
    }
1159358
public function drop(...$tags): bool
    {
        $keys = $this->search(...$tags);
        return $this->deleteMultiple($keys);
    }
348782
public function remove($entry, $priority = false)
    {
        $unsetAnything = false;
        foreach ($this->entries as $i => $entryData) {
            if ($entry === $entryData['data'] && ($priority === false || $entryData['priority'] == $priority)) {
                unset($this->entries[$i]);
                $unsetAnything = true;
            }
        }
        if ($unsetAnything) {
            $this->sorted = false;
        }
        return $this;
    }
693395
public static function filterTag(Tag $tag, Parser $parser, array $tagsConfig, array $openTags)
	{
		$tagName   = $tag->getName();
		$tagConfig = $tagsConfig[$tagName];

		// Record the tag being processed into the logger it can be added to the context of
		// messages logged during the execution
		$logger = $parser->getLogger();
		$logger->setTag($tag);

		// Prepare the variables that are accessible to filters
		$vars = [
			'logger'         => $logger,
			'openTags'       => $openTags,
			'parser'         => $parser,
			'registeredVars' => $parser->registeredVars,
			'tag'            => $tag,
			'tagConfig'      => $tagConfig,
			'text'           => $parser->getText()
		];
		foreach ($tagConfig['filterChain'] as $filter)
		{
			if ($tag->isInvalid())
			{
				break;
			}
			self::executeFilter($filter, $vars);
		}

		// Remove the tag from the logger
		$logger->unsetTag();
	}