@VirtualProperty
@SerializedName("tags")

@return array
979809
public function getTags()
    {
        $tags = [];
        foreach ($this->getFileVersion()->getTags() as $tag) {
            /* @var TagInterface $tag */
            array_push($tags, $tag->getName());
        }

        return $tags;
    }
334798
public function getTagValues($tagName)
    {
        if (!$this->isTaggedWith($tagName)) {
            throw new \RuntimeException('Tag "' . $tagName . '" does not exist.', 1169128255);
        }
        return $this->tags[$tagName];
    }
65372
public function objectTag($oldFields = [])
    {
        /** @var \yii\db\ActiveRecord $this */
        $primaryKey = null;
        if (count($this->primaryKey()) === 1)
        {
            $key = $this->primaryKey()[0];
            $primaryKey = isset($oldFields[$key]) ? $oldFields[$key] : $this->$key;
        } else {
            $primaryKey = [];
            foreach ($this->primaryKey() as $key)
            {
                $primaryKey[$key] = isset($oldFields[$key]) ? $oldFields[$key] : $this->$key;
            }
        }
        return NamingHelper::getObjectTag($this->className(), $primaryKey);
    }
94363
public function getValuesByTag(string $tag): array
    {
        $result = array();

        foreach ($this->_definition as $key => $value) {
            $tags = $this->getFieldProperty($key, 'tags');

            if (is_array($tags) && in_array($tag, $tags)) {
                $result[$key] = $this->$key;
            }
        }

        return $result;
    }
1320680
public function getTags()
    {
        if (!$this->_extendedBackend) {
            Zend_Cache::throwException(self::BACKEND_NOT_IMPLEMENTS_EXTENDED_IF);
        }
        if (!($this->_backendCapabilities['tags'])) {
            Zend_Cache::throwException(self::BACKEND_NOT_SUPPORTS_TAG);
        }
        return $this->_backend->getTags();
    }
672667
public function properties() {
    $props = array();

    if ($this->itemScope()) {
      $toTraverse = array($this);

      foreach ($this->itemRef() as $itemref) {
        $children = $this->ownerDocument->xpath()->query('//*[@id="'.$itemref.'"]');
        foreach($children as $child) {
          $this->traverse($child, $toTraverse, $props, $this);
        }
      }
      while (count($toTraverse)) {
        $this->traverse($toTraverse[0], $toTraverse, $props, $this);
      }
    }

    return $props;
  }
877366
public function findTags()
    {
        $tags = [];
        foreach ($this->getDefinitions() as $id => $definition) {
            $tags = array_merge(array_keys($definition->getTags()), $tags);
        }

        return array_unique($tags);
    }
54014
protected static function define_properties() {
        return [
            'id' => [
                'type' => PARAM_INT,
                'description' => 'Collection id.',
            ],
            'name' => [
                'type' => PARAM_NOTAGS,
                'description' => 'Collection name.',
                'null' => NULL_ALLOWED,
            ],
            'isdefault' => [
                'type' => PARAM_BOOL,
                'description' => 'Whether is the default collection.',
                'default' => false,
            ],
            'component' => [
                'type' => PARAM_COMPONENT,
                'description' => 'Component the collection is related to.',
                'null' => NULL_ALLOWED,
            ],
            'sortorder' => [
                'type' => PARAM_INT,
                'description' => 'Collection ordering in the list.',
            ],
            'searchable' => [
                'type' => PARAM_BOOL,
                'description' => 'Whether the tag collection is searchable.',
                'default' => true,
            ],
            'customurl' => [
                'type' => PARAM_NOTAGS,
                'description' => 'Custom URL for the tag page instead of /tag/index.php.',
                'null' => NULL_ALLOWED,
            ],
        ];
    }
1314312
public function getNames()
    {
        $tags = $this->execute();
        $tags = \explode("\n", $tags);
        $tags = \array_map('trim', $tags);
        $tags = \array_filter($tags);

        return $tags;
    }
1076522
public function toArray()
    {
        $properties = $this->properties;

        foreach ($properties as $name => $value) {
            if ($value instanceof Entity) {
                $properties[$name] = $value->toArray();
            }
        }

        return $properties;
    }
408151
public function getCurrentTags()
    {
        if (!isset($this->_currentTags)) {
            if (!$this->viaClass) {
                return [];
            }
            $viaClass = $this->viaClass;
            $params = [$this->viaLocalField => $this->owner->primaryKey];
            $rawTags = $viaClass::find()->disableAccessCheck()->where($params)->select($this->viaForeignField)->column();

            $this->_currentTags = [];
            foreach ($rawTags as $tag) {
                $this->_currentTags[$tag] = $tag;
            }
        }

        return $this->_currentTags;
    }
162028
public function getTags()
    {
        $currentCommitTags = [];

        /** @var Tag $tag */
        foreach ($this->repository->getTags() as $tag) {
            if ($tag->getSha() === $this->getSha()) {
                $currentCommitTags[] = $tag;
            }
        }

        return $currentCommitTags;
    }
413066
public function paramTags()
    {
        if (isset($this->_tags['@param'])) {
            if (is_array($this->_tags['@param'])) {
                return $this->_tags['@param'];
            } else {
                return array($this->_tags['@param']);
            }
        } else {
            return NULL;
        }
    }
446443
public function getTag()
	{
		if (!isset($this->tagName))
		{
			throw new RuntimeException('No tag associated with this plugin');
		}

		return $this->configurator->tags[$this->tagName];
	}
808904
private function set_tags(){
    if ( $this->mode ){
      if ( $this->mode === 'vue' ){
        $tags = \bbn\x::merge_arrays($this->all_tags['js'], $this->all_tags['vue']);
      }
      else {
        $tags = $this->all_tags[$this->mode];
      }
      $this->tags = \bbn\x::merge_arrays($this->all_tags['common'], $tags);
      return $this->tags;
    }
  }
655727
public function allTags()
    {
        $tags = [];
        $images = $this->model->orderBy('created_at', 'desc')->where('is_published', 1)->get();

        foreach ($images as $image) {
            foreach (explode(',', $image->tags) as $tag) {
                if ($tag > '') {
                    array_push($tags, $tag);
                }
            }
        }

        return array_unique($tags);
    }
583503
public function getEmbeddableProperties(): array
    {
        if (null !== $this->embeddableProperties) {
            return $this->embeddableProperties;
        }
        $traits = $this->reflectionClass->getTraits();
        $return = [];
        foreach ($traits as $traitName => $traitReflection) {
            if (\ts\stringContains($traitName, '\\Entity\\Embeddable\\Traits')) {
                $property                     = $traitReflection->getProperties()[0]->getName();
                $embeddableObjectInterfaceFqn = $this->getTypesFromVarComment(
                    $property,
                    $this->getReflectionHelper()->getTraitProvidingProperty($traitReflection, $property)
                )[0];
                $embeddableObject             = $this->getNamespaceHelper()
                                                     ->getEmbeddableObjectFqnFromEmbeddableObjectInterfaceFqn(
                                                         $embeddableObjectInterfaceFqn
                                                     );
                $return[$property]            = $embeddableObject;
            }
        }

        return $return;
    }