Return a string of all supported tags and an example of its output in table row form.

@return string
429225
public function getAllTagsTable(): string
    {
        $examples = [];

        foreach (get_class_methods($this) as $method) {
            $reflection = new ReflectionMethod($this, $method);
            if ($reflection->isPublic() && !in_array($method, self::$public_but_not_allowed, true) && (string) $reflection->getReturnType() !== Builder::class) {
                $examples[$method] = $this->$method();
            }
        }

        ksort($examples);

        $html = '';
        foreach ($examples as $tag => $value) {
            $html .= '<dt>#' . $tag . '#</dt>';
            $html .= '<dd>' . $value . '</dd>';
        }

        return '<dl>' . $html . '</dl>';
    }
1345782
public function getTag()
    {
        $template = $this->File->getFrontendTemplate();
        if (empty($template)) {
            return '';
        }
        return (string)$this->renderWith($template);
    }
807579
public function getTags()
    {
        $tags = array();
        foreach ($this->getTokenParsers()->getParsers() as $parser) {
            if ($parser instanceof Twig_TokenParserInterface) {
                $tags[$parser->getTag()] = $parser;
            }
        }

        return $tags;
    }
780747
public static function getInstantiatedTagObjects()
    {
        $context = self::getInstance();
        foreach ($context->tags as $key => $config) {
            $context->instantiatTag($key);
        }
        
        return $context->tags;
    }
440669
private function getAllTags(){
        if($comment = $this->getDocComment()){
            if(preg_match_all("/\@(\w+)(.*)/", $comment,$m)){
                foreach($m[0] as $i=>$result){
                    $tag = $m[1][$i];
                    $tagValue = trim($m[2][$i]);
                    $this->{"_{$tag}"} = $tagValue;
                }
            }
        }
    }
707138
public function getTags()
    {
        $this->_checkAndBuildStructure();
        $res = $this->_query("SELECT DISTINCT(name) AS name FROM tag");
        $result = array();
        while ($id = @sqlite_fetch_single($res)) {
            $result[] = $id;
        }
        return $result;
    }
537192
protected function get_RowsInnerHtml() {
    $rowsInnerHtml = [];
    foreach ($this->MatrixCells as $rowIndex => $rowCells) {
      $rowInnerHtml = '';
      foreach ($rowCells as $colIndex => $cell) {
        $rowInnerHtml .= $cell->render();
      }
      $rowsInnerHtml[$rowIndex] = $rowInnerHtml;
    }
    return $rowsInnerHtml;
  }
1314312
public function getNames()
    {
        $tags = $this->execute();
        $tags = \explode("\n", $tags);
        $tags = \array_map('trim', $tags);
        $tags = \array_filter($tags);

        return $tags;
    }
879846
public function hasTags()
    {
        $tags = "tags";
        $postType = getPostType($this->getTable());
        return ($postType->hasTags && isset($this->$tags) && !$this->$tags->isEmpty());
    }
530350
public function getHeaderRowHTML()
    {
        $output = [];
        foreach ($this->columns as $name => $column) {

            // If multiple formatters are defined, use the first for the header cell
            if (is_array($column)) {
                $column = $column[0];
            }

            if (!is_int($name)) {
                $field = $this->model->getElement($name);

                $output[] = $column->getHeaderCellHTML($field);
            } else {
                $output[] = $column->getHeaderCellHTML();
            }
        }

        return implode('', $output);
    }
972261
public function getAllTags()
    {
        $qb = $this->createQueryBuilder('c');

        $qb
            ->select('c.tags')
            ->where($qb->expr()->isNotNull('c.tags'))
            ->distinct()
        ;

        $tagStrings = array_map('current', $qb->getQuery()->getScalarResult());
        $distinctTags = array();

        foreach ($tagStrings as $tagString) {
            foreach (explode(',', $tagString) as $tag) {
                if (!in_array($tag, $distinctTags)) {
                    array_push($distinctTags, $tag);
                }
            }
        }

        return $distinctTags;
    }
1345968
protected function __cells():string{
		$abbr    = $this->getAttribute('abbr');
		$colspan = $this->getAttribute('colspan');
		$rowspan = $this->getAttribute('rowspan');

		if($colspan){
			$colspan = ' colspan="'.intval($colspan).'"';
		}

		if($rowspan){
			$rowspan = ' rowspan="'.intval($rowspan).'"';
		}

		if($this->tag === 'th' && $abbr){
			$abbr = ' abbr="'.$abbr.'"';
		}

		return '<'.$this->tag.$colspan.$rowspan.$abbr.$this->__getCellStyle().'>'.$this->eol($this->content, '<br/>').'</'.$this->tag.'>';
	}
556608
final protected function generate_rendered_tags() {

		$data_sources   = $this->data_sources;
		$data_sources[] = $this->recipient;

		$tags     = $this->manager->render_tags( $data_sources );
		$rendered = array();

		foreach ( $tags as $tag => $value ) {
			$rendered[ '{' . $tag . '}' ] = $value;
		}

		$this->regenerate = false;

		return $rendered;
	}
545322
protected function getTagsConfig()
	{
		// Prepare a Dictionary that will preserve tags' names
		$tags = new Dictionary;
		foreach ($this->config['tags'] as $tagName => $tagConfig)
		{
			if (isset($tagConfig['attributes']))
			{
				// Make the attributes array a Dictionary, to preserve the attributes' names
				$tagConfig['attributes'] = new Dictionary($tagConfig['attributes']);
			}

			$tags[$tagName] = $tagConfig;
		}

		return $tags;
	}
372187
public function tagged()
    {
        $out = '';

        // call stream filters.
        foreach ($this->streamFilters as $f) {
            $this->tokens = call_user_func($f[1], $this->tokens);
        }
        foreach ($this->tokens as $t) {
            $type = $t[0];

            // speed is roughly 10% faster if we process the filters inside this
            // loop instead of separately.
            if (isset($this->filters[$type])) {
                foreach ($this->filters[$type] as $filter) {
                    $t = call_user_func($filter[1], $t);
                }
            }
            list($type, $string, $esc) = $t;

            if (!$esc) {
                $string = Utils::escapeString($string);
            }
            if ($type !== null) {
                $out .= Utils::tagBlock($type, $string);
            } else {
                $out .= $string;
            }
        }
        return $out;
    }
1046668
public function getTagsList()
    {
        $tags = explode("\n", str_replace("\r", "\n", trim($this->getTags())));
        $clean_tags = [];
        foreach ($tags as $tag) {
            $tag = trim($tag);
            if ($tag !== '') {
                $clean_tags[] = $tag;
            }
        }

        return $clean_tags;
    }
849777
public static function tags()
    {
        $args = func_get_args();
        $ret = NULL;
        foreach($args as $a)
        {
            $class = "";
            $id = "";
            $type = "";
            $text = "";
            
            if(isset($a['class']))
                $class = $a['class'];
            if(isset($a['id']))
                $id    = $a['id'];
            if(isset($a['type']))
                $type  = $a['type'];
            if(isset($a['text']))
                $text = $a['text'];
            
            unset($a['class'],$a['id'], $a['type'],$a['text']);
            
            $ret .= self::tag($type, $text, $class, $id, $a) . PHP_EOL;
            
        }
        
        return $ret;
    }