a listing of all cached entries which have been
inserted through this wrapper

@return boolean
167153
public function listCache()
    {

        $newlist = array();

        foreach ($this->cacheListing as $key => $val) {
            $newlist [$key] = new \stdClass();

            foreach ($val as $skey => $sval) {
                $newlist [$key]->$skey = $sval;
            }
        }

        $this->list = $newlist;

        return true;
    }
816589
public function getStats() {
		return array(
			'inserts' => $this->cacheInserts,
			'deletes' => $this->cacheDeletes,
			'max'     => $this->maxCacheCount,
			'count'   => $this->count,
			'hits'    => $this->cacheHits,
			'misses'  => $this->cacheMisses
		);
	}
576057
static function isCacheEnabled()
    {
        if ( isset( $GLOBALS['eZSiteBasics'] ) )
        {
            $siteBasics = $GLOBALS['eZSiteBasics'];
            if ( isset( $siteBasics['no-cache-adviced'] ) and
                 $siteBasics['no-cache-adviced'] )
            {
                return false;
            }
        }

        $ini = eZINI::instance();
        $cacheEnabled = $ini->variable( 'TemplateSettings', 'NodeTreeCaching' ) == 'enabled';
        return $cacheEnabled;
    }
978065
public function getCachedContent()
    {
        if ($this->_content !== null) {
            return $this->_content;
        }

        $this->_content = false;

        if (!($this->cache instanceof CacheInterface)) {
            return $this->_content;
        }

        $key = $this->calculateKey();
        $data = $this->cache->get($key);
        if (!is_array($data) || count($data) !== 2) {
            return $this->_content;
        }

        [$this->_content, $placeholders] = $data;
        if (!is_array($placeholders) || count($placeholders) === 0) {
            return $this->_content;
        }

        $this->_content = $this->updateDynamicContent($this->_content, $placeholders, true);

        return $this->_content;
    }
550239
public boolean hasEntries()
    {
        return (getCache4Id() != null && !getCache4Id().isEmpty())
            || (getCache4Name() != null && !getCache4Name().isEmpty())
            || (getCache4UUID() != null && !getCache4UUID().isEmpty());
    }
774057
public function all()
    {
        if ($this->useCache()) {
            return $this->cache->remember($this->getCacheKey(), $this->getCacheLifetime(), function () {
                return $this->scan();
            });
        }

        return $this->scan();
    }
176754
protected static function cacheMigrations()
	{
		//check if already cached
		if (static::$MIGRATION_CACHE !== null) return true;

		//check if there is a connection
		if (!static::hasDbConnection() || Yii::$app->db->schema->getTableSchema('{{%migration}}') === null) {
			return false;
		}

		//load the data
		static::$MIGRATION_CACHE = [];
		$migrationData = (new Query())
			->select(['version','apply_time'])
			->from('{{%migration}}')
			->orderBy(['apply_time'=>SORT_ASC])
			->all();

		//fill the cache
		foreach ($migrationData as $migration) {
			static::$MIGRATION_CACHE[$migration['version']] = $migration['apply_time'];
		}

		return true;
	}
1091557
private function cachedI() {
		if (!isset($this->{__METHOD__})) {
			$this->{__METHOD__} = $this->cached();
		}
		return $this->{__METHOD__};
	}
1084360
public function checkRegistryRequestsAnswers()
    {
        if ($this->cache) {
            $cacheId = $this->_getCacheId();
            $this->_data = $this->cache->load($cacheId);
        } else {
            $cacheId = false;
        }

        if (! $this->_data) {
            $this->_data = $this->loadData($this->_id);

            if ($cacheId) {
                $this->cache->save($this->_data, $cacheId, $this->_cacheTags);
            }
        }
        // \MUtil_Echo::track($this->_data);

        $this->exists = is_array($this->_data);

        return ($this->exists || (! $this->requireArray)) && parent::checkRegistryRequestsAnswers();
    }
550544
public function clearCache()
    {
        $this->_data = null;
        if ($this->frontCache instanceof Cache) {
            $this->frontCache->delete($this->cacheKey);
        }
        if ($this->cache instanceof Cache) {
            return $this->cache->delete($this->cacheKey);
        }
        return true;
    }
984852
private function isCacheUpToDate()
    {
        if (!file_exists($this->cachedFile)) {
            return false;
        }

        $cacheTime = filemtime($this->cachedFile);
        $mTime     = $this->modificationTime();

        return $cacheTime == $mTime;
    }
592890
private function isPerfectCache()
	{
		if ($this->cacheMap[$this->hash] + 0x93a80 > time()) {
			$this->cacheData = json_decode(
				file_get_contents(
					$this->cacheFile
				), 
				true
			);
			return is_array($this->cacheData);
		}
		return false;
	}
390917
public function clear()
    {
        $purged = $this->writeStorage->clear();

        if ($this->bigStorage) {
            $this->bigStorage->clear();
        }

        $this->entryCache = [];

        return $purged;
    }
156294
public function get_css_cached_content() {

        $key = $this->get_css_cache_key();
        $cache = cache::make('core', 'postprocessedcss');

        return $cache->get($key);
    }
604408
public function getCacheIsReady(): bool
    {
        foreach ($this->caches as $cache) {
            if (!$cache->getCacheIsReady()) {
                return false;
            }
        }

        return true;
    }
1110007
public function lastInsert()
	{
		$query = $this->connection->createSelect();
		$query->setQuery('*:*');
		$query->setFields(array('timestamp'));
		$query->addSort('timestamp', 'DESC');
		$query->setRows(1);
		$query->setStart(0);

		$results = $this->connection->execute($query);
		foreach ($results as $document)
		{
			foreach ($document as $field => $value)
			{
				$result = $value;
				return $result;
			}
		}
	}
1275595
public function saveCacheListing()
    {

        if (md5(json_encode($this->cacheListing)) === $this->md5Sum) return false;

        return parent::set('cacheListing', $this->cacheListing);
    }