return cloud for search keywords.

@return TCMSTagCloud
425556
protected function &GetSearchKeywordCloud()
    {
        $iSize = 13;
        $aCustomWords = array();
        $oCustomList = &TdbShopSearchCloudWordList::GetList();
        while ($oWord = &$oCustomList->Next()) {
            $aCustomWords[$oWord->fieldName] = $oWord->fieldWeight;
        }
        $iSize = $iSize - count($aCustomWords);
        if ($iSize < 0) {
            $iSize = 0;
        }
        $activeLanguage = $this->getLanguageService()->getActiveLanguageId();
        $query = 'SELECT COUNT(`shop_search_log`.`id`) AS '.TCMSTagCloud::QUERY_ITEM_COUNT_NAME.',
                       `shop_search_log`.`name` AS '.TCMSTagCloud::QUERY_ITEM_KEY_NAME.",
                       `shop_search_log`.*
                  FROM `shop_search_log`
                 WHERE `cms_language_id` = '".MySqlLegacySupport::getInstance()->real_escape_string($activeLanguage)."' OR `cms_language_id` =  ''
              GROUP BY `shop_search_log`.`name`
                HAVING ".TCMSTagCloud::QUERY_ITEM_COUNT_NAME.' > 0
              ORDER BY '.TCMSTagCloud::QUERY_ITEM_COUNT_NAME." DESC
                 LIMIT 0,{$iSize}
               ";
        // add custom words...

        return TCMSTagCloud::GetCloud($query, 'TdbShopSearchLog', $aCustomWords);
    }
451272
public function getDefaultCloudStorage(): ?Cloud
    {
        // By default, the Storage Facade does not return the
        // any actual storage fisk, but rather an
        // instance of \Illuminate\Filesystem\FilesystemManager.
        // Therefore, we make sure only to obtain its
        // "disk", to make sure that its the correct
        // instance that we obtain.
        $manager = Storage::getFacadeRoot();
        if (isset($manager)) {
            return $manager->disk();
        }
        return $manager;
    }
552637
def getcloud(site, feed_id=None):
	

	cloudict = fjcache.cache_get(site.id, 'tagclouds')
	if not cloudict:
		cloudict = cloudata(site)
		fjcache.cache_set(site, 'tagclouds', cloudict)

	# A subscriber's tag cloud has been requested.
	if feed_id:
		feed_id = int(feed_id)
		if feed_id in cloudict:
			return cloudict[feed_id]
		return []
	# The site tagcloud has been requested.
	return cloudict[0]
94862
public function getIndexDefinition()
    {
        return [
            'tag_keywords' => new Search\FieldType\MultipleStringField(),
            'parent_tag_ids' => new Search\FieldType\MultipleIntegerField(),
            'tag_ids' => new Search\FieldType\MultipleIntegerField(),
            'tag_text' => new Search\FieldType\TextField(),
            'fulltext' => new Search\FieldType\FullTextField(),
        ];
    }
349120
public function getVideoTags()
    {
        $this->ensureMediaGroupIsNotNull();
        if ($this->getMediaGroup()->getKeywords() != null) {

            $keywords = $this->getMediaGroup()->getKeywords();
            $keywordsString = $keywords->getText();
            if (strlen(trim($keywordsString)) > 0) {
                return preg_split('/(, *)|,/', $keywordsString);
            }
        }
        return array();
    }
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();
    }
505437
public function createSearch()
	{
		$conn = $this->_dbm->acquire( $this->_dbname );
		$search = new MW_Common_Criteria_SQL( $conn );
		$this->_dbm->release( $conn, $this->_dbname );

		return $search;
	}
1165496
public static function factory($config = array())
    {
        $required = array(
            'base_url',
            'username',
            'password',
        );

        $defaults = array(
            'base_url' => self::BASE_URL,
            'base_path' => self::BASE_PATH,
        );

        // Instantiate the Acquia Search plugin.
        $config = Collection::fromConfig($config, $defaults, $required);
        $client = new static($config->get('base_url'), $config);
        $client->setDefaultHeaders(array(
            'Content-Type' => 'application/json; charset=utf-8',
        ));

        // Attach the Acquia Search plugin to the client.
        $plugin = new CloudApiAuthPlugin($config->get('username'), $config->get('password'));
        $client->addSubscriber($plugin);

        return $client;
    }
697405
public function getTagsFromSearchResult()
    {
        $tags = $tagsForResult = array();
        $tagChar = $this->pObj->extConf['prePostTagChar'];
        $tagDivider = $tagChar . ',' . $tagChar;

        if ($this->sphinxSearchEnabled()) {
            $tagsForResult = $this->getTagsFromSphinx();
        } else {
            $tagsForResult = $this->getTagsFromMySQL();
        }
        foreach ($tagsForResult as $tagSet) {
            $tagSet = explode($tagDivider, trim($tagSet, $tagChar));
            foreach ($tagSet as $tag) {
                $tags[$tag] += 1;
            }
        }
        return $tags;
    }
157637
def __get_tags(vm_):
    '''
    
    '''
    t = config.get_cloud_config_value(
        'tags', vm_, __opts__,
        default='[]', search_global=False)
    # Consider warning the user that the tags in the cloud profile
    # could not be interpreted, bad formatting?
    try:
        tags = literal_eval(t)
    except Exception:  # pylint: disable=W0703
        tags = None
    if not tags or not isinstance(tags, list):
        tags = None
    return tags
191012
public function getTags()
    {
        if (!is_array($this->aTags) && $this->id) {
            $this->aTags = [];
            foreach (Sked::getEventTags($this->id) as $aEventTag)
                $this->aTags[$aEventTag['tag_id']] = new SkeVentTag($aEventTag);
        }
        return $this->aTags;
    }
1168548
public function getPrivateTagsList()
    {
        $config = SiteConfig::current_site_config();
        //Filter out global excluded tags and non configured Organisations
        $pri_tags = PrivateTag::get()->filter(['HailID:not' => json_decode($config->HailExcludePrivateTagsIDs), 'HailOrgID' => json_decode($config->HailOrgsIDs)]);

        return $pri_tags->sort(['HailOrgName ASC', 'Name ASC'])->map('HailID', 'FullName')->toArray();
    }
61284
public function toCloudPush()
    {
        return Yii::createObject([
            'class' => CloudPushMessage::class,
            'title' => $this->getTitle(),
            'content' => $this->getContent(),
            'extParameters' => $this->getData()
        ]);
    }
656529
public static function existingTags(): Collection
    {
        return Tagged::query()
            ->distinct()
            ->join('tagging_tags', 'tag_slug', '=', 'tagging_tags.slug')
            ->where('taggable_type', '=', (new static)->getMorphClass())
            ->orderBy('tag_slug', 'ASC')
            ->get(array('tag_slug as slug', 'tag_name as name', 'tagging_tags.count as count'));
    }
127045
public function getSearchResultBySphinx()
    {
        /** @var KeSearchPremium keSearchPremium */
        $this->keSearchPremium = GeneralUtility::makeInstance(KeSearchPremium::class);

        // set ordering
        $this->keSearchPremium->setSorting($this->getOrdering());

        // set limit
        $limit = $this->getLimit();
        $this->keSearchPremium->setLimit($limit[0], $limit[1], intval($this->pObj->extConfPremium['sphinxLimit']));

        // generate query
        $queryForSphinx = '';
        if ($this->pObj->wordsAgainst) {
            $queryForSphinx .= ' @(title,content) ' . $this->escapeString($this->pObj->wordsAgainst);
        }
        if (count($this->pObj->tagsAgainst)) {
            foreach ($this->pObj->tagsAgainst as $value) {
                // in normal case only checkbox mode has spaces
                $queryForSphinx .= ' @tags ' . str_replace('" "', '" | "', trim($value));
            }
        }

        // add language
        $queryForSphinx .= ' @language _language_-1 | _language_' . $GLOBALS['TSFE']->sys_language_uid;

        // add fe_groups to query
        $queryForSphinx .= ' @fe_group _group_NULL | _group_0';

        $context = GeneralUtility::makeInstance(Context::class);
        $feGroups = $context->getPropertyFromAspect('frontend.user', 'groupIds');
        if (count($feGroups)) {
            foreach ($feGroups as $key => $group) {
                $intval_positive_group = MathUtility::convertToPositiveInteger($group);
                if ($intval_positive_group) {
                    $feGroups[$key] = '_group_' . $group;
                } else {
                    unset($feGroups[$key]);
                }
            }
            if (is_array($feGroups) && count($feGroups)) {
                $queryForSphinx .= ' | ' . implode(' | ', $feGroups);
            }
        }

        // restrict to storage page (in MySQL: $where .= ' AND pid in (' .  . ') ';)
        $startingPoints = GeneralUtility::trimExplode(',', $this->pObj->startingPoints);
        $queryForSphinx .= ' @pid ';
        $first = true;
        foreach ($startingPoints as $startingPoint) {
            if (!$first) {
                $queryForSphinx .= ' | ';
            } else {
                $first = false;
            }

            $queryForSphinx .= ' _pid_' . $startingPoint;
        }

        // hook for appending additional where clause to sphinx query
        if (is_array($GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['ke_search']['appendWhereToSphinx'])) {
            foreach ($GLOBALS['TYPO3_CONF_VARS']['EXTCONF']['ke_search']['appendWhereToSphinx'] as $_classRef) {
                $_procObj = &GeneralUtility::makeInstance($_classRef);
                $queryForSphinx = $_procObj->appendWhereToSphinx($queryForSphinx, $this->keSearchPremium, $this);
            }
        }
        $rows = $this->keSearchPremium->getSearchResults($queryForSphinx);

        // get number of records
        $this->numberOfResults = $this->keSearchPremium->getTotalFound();
        return $rows;
    }
307488
public function metaKeywordString()
    {
        $tagKeywords = array_map(
        function( $tag )
            {
                /** @var eZTagsObject $tag */
                return $tag->attribute( 'keyword' );
            },
            $this->tags()
        );

        return !empty( $tagKeywords ) ? implode( ', ', $tagKeywords ) : '';
    }
305397
public function getSearchList()
    {
        if ($this->searchList === null) {
            $this->searchList = $this->app->make(SearchList::class, [$this->getStickyRequest()]);
        }

        return $this->searchList;
    }