Get all keys of the widget for clearing cache.
@return string
544530
public function cacheKeys()
    {
        $keys = [];
        $roles = array_merge(cache('roles'), ['guest']);

        foreach ($roles as $role) {
            $keys[] = $this->generateCacheKey($role);
        }

        return implode('|', $keys);
    }
6998
public function getAllKeys()
    {

        // initialize the array with keys of all attributes
        $keys = array();

        // prepare the pattern to filter the attributes
        $pattern = sprintf('%s-*', $this->getSerial());

        // prepare the array with the attribute keys
        foreach (array_keys((array) $this) as $key) {
            if (fnmatch($pattern, $key)) {
                $keys[] = $this->unmaskKey($key);
            }
        }

        // return the attribute keys
        return $keys;
    }
533268
public function getKeys()
    {

        $catalog = $this->fetch($this->catalog_key);
        $catalog = is_array($catalog) ? $catalog : Array();

        $arr = Array();
        foreach ($catalog as $k => $v) {
            $arr[preg_replace("~^" . $this->namespace . "~", '', $k)] = $v;
        }
        ksort($arr);
        return $arr;
    }
1321214
public function getKeys()
    {
        if ($this->hasCompositeKey()) {
            $key = [];

            foreach ($this->compositeKey as $name) {
                $key[$name] = $this->getAttribute($name);
            }

            return $key;
        }

        $name = $this->getKeyName();

        return [$name => $this->getAttribute($name)];
    }
990427
protected function getContentFromCache()
    {
        $cache_key = $this->widget->cacheKey();
        $cache_time = $this->widget->cacheTime();

        // Check the existence of the cache.
        if (! cache()->has($cache_key)) {
            // If cache is empty and validation is fails.
            $this->checkWidgetParams();
            // If cache is empty and template file does not exists.
            $this->checkWidgetTemplate();
        }

        return cache()->remember($cache_key, $cache_time, function () {
            return $this->getContent();
        });
    }
382756
public static function getCombinerCacheKey()
    {
        $theme = CmsTheme::getActiveTheme();
        if (!$theme->hasCustomData()) {
            return '';
        }

        $customData = $theme->getCustomData();

        return (string) $customData->updated_at ?: '';
    }
1297238
public function keySet()
    {
        $result = [];
        $keys = $this->keys();
        foreach ($keys as $key) {
            $result[] = $key;
        }

        return $result;
    }
723583
public function getKeys()
    {
        $catalog = $this->fetch($this->catalog_key);
        $catalog = \is_array($catalog) ? $catalog : Array();
        \ksort($catalog);
        return $catalog;
    }
257431
public function all()
    {
        $results = [];
        foreach ($this->index->getKeys() as $key) {
            $result = $this->get($key);
            $results[key($result)] = current($result);
        }

        return $results;
    }
232078
public function keys()
    {
        $locales = array_map(function (LocaleCollection $locales) {
            $keys = $locales->keys()->toArray();
            return array_combine($keys, $keys);
        }, $this->locales);

        $all = [];

        foreach ($locales as $keys) {
            $all = array_merge($all, $keys);
        }

        return $all;
    }
1124637
public function getCacheKey()
    {
        if (is_null($this->cacheKey)) {
            return $this->cachePrefix . $this->getUserName();
        }

        return $this->cacheKey;
    }
452985
protected function getParamsKey()
    {
        return array(
            self::PARAM_DRIVER_OPTIONS,
            self::PARAM_HOST,
            self::PARAM_DATABASE,
            self::PARAM_USER,
            self::PARAM_PASSWORD,
        );
    }
660921
public function getTwigCacheKey()
    {
        $key = $this->getFilePath();

        if ($event = $this->fireEvent('cmsObject.getTwigCacheKey', compact('key'), true)) {
            $key = $event;
        }

        return $key;
    }
153697
public function clear()
    {
        $cleared = [];
        if (false === $this->mf->hasCache()) {
            return $cleared;
        }

        $this->mf->enableCache(false);
        foreach ($this->mf->getAllTypeNames() as $type) {
            $metadata = $this->mf->getMetadataForType($type);
            $this->mf->getCache()->evictMetadataFromCache($metadata);
            $cleared[] = $type;
        }
        $this->mf->enableCache(true);
        $this->mf->clearMemory();
        return $cleared;
    }
1114079
public static function flushAll()
    {
        $cachesInfo = [];
        if (empty($caches = self::findCaches())) {
            return $cachesInfo;
        }
        
        foreach ($caches as $name => $class) {
            $cachesInfo[] = [
                'name' => $name,
                'class' => $class,
                'is_flushed' => self::canBeFlushed($class) ? Yii::$app->get($name)->flush() : false,
            ];
        }
        
        return $cachesInfo;
    }
53035
public function getAllEntries()
    {
        if ($this->Using === 'APCu') {
            $Data = apcu_cache_info();
            if (empty($Data['cache_list'])) {
                return [];
            }
            $Output = [];
            foreach ($Data['cache_list'] as $Entry) {
                if (empty($Entry['info'])) {
                    continue;
                }
                $Creation = isset($Entry['creation_time']) ? $Entry['creation_time'] : 0;
                $Entry['Data'] = $this->getEntry($Entry['info']);
                $Output[$Entry['info']] = $Entry['ttl'] > 0 ? [
                    'Data' => $Entry['Data'],
                    'Time' => $Creation + $Entry['ttl']
                ] : $Entry['Data'];
            }
            return $Output;
        }
        if ($this->Using === 'Memcached') {
            $Keys = $this->WorkingData->getAllKeys();
            if ($Keys !== false && $this->WorkingData->getDelayed($Keys)) {
                $Data = $this->WorkingData->fetchAll();
            }
            if (!is_array($Data)) {
                return [];
            }
            $Output = [];
            foreach ($Data as $Entry) {
                if (!is_array($Entry) || !isset($Entry['key'], $Entry['value'], $Entry['cas'])) {
                    continue;
                }
                $Output[$Entry['key']] = ['Data' => $this->unserializeEntry($Entry['value'])];
                if ($Entry['cas'] > 2592000) {
                    $Output[$Entry['key']]['Time'] = $Entry['cas'];
                } else {
                    $Output[$Entry['key']] = $Output[$Entry['key']]['Data'];
                }
            }
            return $Output;
        }
        if ($this->Using === 'Redis') {
            $Keys = $this->WorkingData->keys('*') ?: [];
            $Output = [];
            foreach ($Keys as $Key) {
                $Output[$Key] = $this->unserializeEntry($this->WorkingData->get($Key));
            }
            return $Output;
        }
        if ($this->Using === 'PDO') {
            if ($this->clearExpiredPDO()) {
                $this->Modified = true;
            }
            $PDO = $this->WorkingData->prepare(self::getAllQuery);
            if ($PDO !== false && $PDO->execute()) {
                $Data = $PDO->fetchAll();
                $Output = [];
                foreach ($Data as $Entry) {
                    if (!is_array($Entry) || !isset($Entry['Key'], $Entry['Data'], $Entry['Time'])) {
                        continue;
                    }
                    $Output[$Entry['Key']] = $Entry['Time'] > 0 ? [
                        'Data' => $this->unserializeEntry($Entry['Data']),
                        'Time' => $Entry['Time']
                    ] : $this->unserializeEntry($Entry['Data']);
                }
                return $Output;
            }
            return [];
        }
        if ($Arr = ($this->exposeWorkingDataArray() ?: [])) {
            foreach ($Arr as &$Entry) {
                $Entry = $this->unserializeEntry($Entry);
            }
            return $Arr;
        }
        return [];
    }
205629
public function getFullDataSet () : array
    {
        if ($this->isUsingHandler()) :
            $this->regularize();
            $this->clearCache();

            return $this->_Cache = $this->_DataHandler->selectRangeEntitys(0,$this->_maxKey + 1);
        else :
            return $this->_Container;
        endif;
    }