Provide a generic getStats() method
for files-based drivers
@return DriverStatistic
@throws \Phpfastcache\Exceptions\PhpfastcacheIOException
970228
public function getStats(): DriverStatistic
    {
        $stat = new DriverStatistic();
        $path = $this->getFilePath(false);

        if (!\is_dir($path)) {
            throw new PhpfastcacheIOException("Can't read PATH:" . $path);
        }

        $stat->setData(\implode(', ', \array_keys($this->itemInstances)))
            ->setRawData([
                'tmp' => $this->tmp,
            ])
            ->setSize(Directory::dirSize($path))
            ->setInfo('Number of files used to build the cache: ' . Directory::getFileCount($path));

        return $stat;
    }
626588
public function getStat()
    {
        if ($this->exists()) {
            $flags = $this->getFlags();
            $stats = @stat($this->getRealPath());
            if ($stats) {
                foreach ($stats as $i=>$val) {
                    if (!is_string($i)) {
                        unset($stats[$i]);
                    } else {
                        if ((self::STAT_DATETIME_FIELD & $this->flags) && in_array($i, array('atime', 'mtime', 'ctime'))) {
                            $stats[$i.'DateTime'] = WebFilesystem::getDateTimeFromTimestamp($val);
                        } elseif ((self::STAT_SIZE_FIELD & $this->flags) && $i==='size') {
                            $stats[$i.'Transformed'] = WebFilesystem::getTransformedFilesize($val);
                        }
                    }
                }
            }
            return $stats;
        }
        return null;
    }
956947
public function getAvailableDrivers()
	{
		$drivers = array();
		
		if(count($this->drivers) > 0)
		{
			foreach($this->drivers as $driver)
			{
				if(class_exists("LikePDO\\Drivers\\".$driver."Driver"))
				{
					$drivers[] = $driver;
				}
			}
		}
		
		return $drivers;
	}
930371
protected function getStatistics() {
        if (!$this->_statistics) {
            $this->_statistics = new TaskQueueStatisticsList(
                $this->version,
                $this->solution['workspaceSid'],
                $this->solution['sid']
            );
        }

        return $this->_statistics;
    }
71849
public function getCache(string $driverName=''): \Nofuzz\SimpleCache\CacheInterface
  {
    if (empty($driverName)) {
      # Return the 1st Cache in the list
      return (array_values($this->drivers)[0] ?? null);
    } else {
      # Return the Cache for the $driverName
      return $this->drivers[strtolower($driverName)] ?? null;
    }
  }
863682
static private function getDriver() {
        if (self::$_driver != null) return self::$_driver;
        
        $driver = Utils::spare(Config::get('cache.driver'), 'file');

        switch (strtolower($driver)) {
            case 'memcached':
                self::$_driver = new \Lollipop\Cache\MemcachedAdapter();
                break;
                
            case 'file':
            default:
                self::$_driver = new \Lollipop\Cache\FileAdapter();
                break;
        }
        
        return self::$_driver;
    }
929063
public function getStats()
    {
        if (is_null($this->_stats)) {
            $this->_stats = $this->module->getStats(Yii::$app->request->object);
        }

        return $this->_stats;
    }
1257772
public function getStats()
    {
        $this->stats = array(
            'tooSlow'        => 0,
            'slowAcceptable' => 0,
            'aBitSlow'       => 0,
            'goodSlow'       => 0,
            'perfect'        => 0,
            'goodFast'       => 0,
            'aBitFast'       => 0,
            'fastAcceptable' => 0,
            'tooFast'        => 0
        );

        $cuesCount = $this->getCuesCount();
        for ($i = 0; $i < $cuesCount; $i++) {
            $rs = $this->getCue($i)->getReadingSpeed();

            if ($rs < 5) {
                $this->stats['tooSlow']++;
            } elseif ($rs < 10) {
                $this->stats['slowAcceptable']++;
            } elseif ($rs < 13) {
                $this->stats['aBitSlow']++;
            } elseif ($rs < 15) {
                $this->stats['goodSlow']++;
            } elseif ($rs < 23) {
                $this->stats['perfect']++;
            } elseif ($rs < 27) {
                $this->stats['goodFast']++;
            } elseif ($rs < 31) {
                $this->stats['aBitFast']++;
            } elseif ($rs < 35) {
                $this->stats['fastAcceptable']++;
            } else {
                $this->stats['tooFast']++;
            }
        }

        return $this->stats;
    }
1272172
@Override
    public String[] getAllCacheStatistics() {
        DCache cache = null;
        if (ServerCache.servletCacheEnabled) {
            cache = ServerCache.cache;
        }
        String stats[] = null;
        if (cache != null) {
            Map statistics = getCacheStatisticsMap(cache.getCacheStatistics());
            Iterator keys = statistics.keySet().iterator();
            Iterator values = statistics.values().iterator();
            stats = new String[statistics.size()];
            int i = 0;
            while (keys.hasNext()) {
                stats[i] = keys.next() + "=" + values.next();
                i++;
            }
        } else {
            stats = new String[0];
            // DYNA1059W=DYNA1059W: WebSphere Dynamic Cache instance named {0} cannot be used because of Dynamic Servlet cache service has not be started.
            Tr.error(tc, "DYNA1059W", new Object[] { DCacheBase.DEFAULT_CACHE_NAME });
        }

        return stats;
    }
167304
private function getDriver(): \BearFramework\App\IDataDriver
    {
        if ($this->driver !== null) {
            return $this->driver;
        }
        throw new \Exception('No data driver specified! Use useFileDriver() or setDriver() to specify one.');
    }
610824
public function getStats()
    {
        $result = $this->callService('GET', self::API_DOWNLOAD_STATS);

        return $result->getModel(models\Download\Stats\DownloadStats::class);
    }
802417
public function getStats()
    {
        $result = [
            self::STATS_QUEUES_LIST   => [],
            self::STATS_JOBS_TOTAL    => 0,
            self::STATS_JOBS_READY    => 0,
            self::STATS_JOBS_RESERVED => 0,
            self::STATS_JOBS_DELAYED  => 0,
            self::STATS_JOBS_BURIED   => 0,
        ];

        $queueList = $this->getQueueNames();
        if (count($queueList) == 0) {
            return $result;
        }

        $result[self::STATS_QUEUES_LIST] = $queueList;

        foreach ($queueList as $queueName) {
            $itemStats = $this->getQueueInfo($queueName);
            $result[self::STATS_JOBS_READY] += $itemStats[self::STATS_JOBS_READY];
            $result[self::STATS_JOBS_RESERVED] += $itemStats[self::STATS_JOBS_RESERVED];
            $result[self::STATS_JOBS_DELAYED] += $itemStats[self::STATS_JOBS_DELAYED];
            $result[self::STATS_JOBS_BURIED] += $itemStats[self::STATS_JOBS_BURIED];
            $result[self::STATS_JOBS_TOTAL] += $itemStats[self::STATS_JOBS_TOTAL];
            $result[self::STATS_QUEUES][$queueName] = $itemStats;
        }

        return $result;
    }
611359
public function getStatistics()
    {
        return [
            'currentCallCount'       => count($this->calls),
            'registeredAt'           => $this->registeredAt,
            'invocationCount'        => $this->invocationCount,
            'invocationAverageTime'  => $this->invocationAverageTime,
            'busyTime'               => $this->busyTime,
            'busyStart'              => $this->busyStart,
            'lastIdledAt'            => $this->lastIdledAt,
            'lastCallStartedAt'      => $this->lastCallStartedAt,
            'completedCallTimeTotal' => $this->completedCallTimeTotal
        ];
    }
340787
public function getStatisticsRouting():array
    {

        $f = $this->getallRouting();
        $fc = 0;
        $fdisabled = 0;
        $fpublic = 0;

        foreach ($f as $one) {
            $fc += $one['count_route'];
            $z = $this-> getMercureContent(str_replace(".merc", "", $one['name']), $one['app']);
            foreach ($z as $two) {
                if ($two['visibility'] == "disabled") {
                    $fdisabled++;
                } elseif ($two['visibility'] == "public") {
                    $fpublic++;
                }
            }
        }

        return (array("number" => $fc, "disabled" => $fdisabled, "public" => $fpublic));
    }
797317
public function getAvailableDrivers()
    {
        $config = $this->client ? $this->client : $this->config;

        return $config->getAvailableDrivers();
    }
387398
protected function getDriversFromStorage()
    {
        if ($this->cache->has(self::$cacheKey)) {
            return $this->cache->get(self::$cacheKey, []);
        }
        $options = Component::findOneByName('api')->options;

        $drivers = array_get($options, 'auth_drivers');

        $this->cache->put(self::$cacheKey, $drivers);

        return $drivers;
    }
391221
private function getDriver(): \BearFramework\App\ICacheDriver
    {
        if ($this->driver !== null) {
            return $this->driver;
        }
        throw new \Exception('No cache driver specified! Use useAppDataDriver() or setDriver() to specify one.');
    }