Gets all sub keys for the inipart cache files

@return string[]
197171
public static function getAllIniPartCacheSubKeys() : array
    {
        $subKeys = [];
        $chars = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];

        foreach ($chars as $charOne) {
            foreach ($chars as $charTwo) {
                foreach ($chars as $charThree) {
                    $subKeys[] = $charOne . $charTwo . $charThree;
                }
            }
        }

        return $subKeys;
    }
784259
protected function fetchPrimaryKeys(): array
    {
        $query = "SHOW INDEXES FROM {$this->driver->identifier($this->getName())}";

        $primaryKeys = [];
        foreach ($this->driver->query($query) as $index) {
            if ($index['Key_name'] == 'PRIMARY') {
                $primaryKeys[] = $index['Column_name'];
            }
        }

        return $primaryKeys;
    }
1148103
protected function getPossibleKeys()
	{
		$keys = [];
		foreach (range('a', 'z') as $char)
		{
			$keys[] = $this->keyPrefix . $char;
		}

		return $keys;
	}
292733
public function getAll()
    {
        $values = json_decode(file_get_contents($this->cacheFile), true);

        if( ! is_array($values)) return [];
        
        foreach ($values as $key => $value) {
            $values[$key] = unserialize($value);
        }
        return $values;
    }
808145
public function getNames()
    {
        if($this->isKeycacheInvalid())
        {
            $this->regenerateKeyCache();
        }
        if(is_array($this->__keycacheindex))
        {
            return $this->__keycacheindex;
        }
        return array();
    }
903947
public function all()
	{
		$allinfo = $this->apcu ? apcu_cache_info() : apc_cache_info('user');

		$keys = $allinfo['cache_list'];

		$hash = $this->options['hash'];

		$data = array();

		foreach ($keys as $key)
		{
			$name    = $key['info'];
			$namearr = explode('-', $name);

			if ($namearr !== false && $namearr[0] == $secret && $namearr[1] == 'cache')
			{
				$group = $namearr[2];

				if (!isset($data[$group]))
				{
					$item = new Auditor($group);
				}
				else
				{
					$item = $data[$group];
				}

				$item->tally($key['mem_size'] / 1024);

				$data[$group] = $item;
			}
		}

		return $data;
	}
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;
    }
787041
public function getFilesHashKey()
    {
        $file_locker = [];
        // $config = $this->config['config_root'].'/config.php';
        // $file_config = [];
        // $file = @$this->fileSys->getContent($this->config['config_root'].'/config.php');
        // $file_config[] = $file['setting'];
        $files_source = $this->fileSys->getFiles($this->source_dir);
        $files_themes = $this->fileSys->getFiles($this->themes_dir);
        $files = array_merge($files_source, $files_themes);
        foreach ($files as $file) {
            $file_locker[] = md5_file($file['file_path']);
        }
        return $file_locker;
    }
930658
public function getKeys()
    {
        if ($this->_keys === null) {
            $this->_keys = $this->getResolvedPathInfo($this->request)->resolvedValues;
        }
        
        return $this->_keys;
    }
717372
private function _getKeyIdMap(): array
    {
        // lazily build mapping
        if (!isset($this->_keyIdMap)) {
            $this->_keyIdMap = array();
            foreach ($this->_certs as $cert) {
                $id = self::_getCertKeyId($cert);
                if (!isset($this->_keyIdMap[$id])) {
                    $this->_keyIdMap[$id] = array();
                }
                array_push($this->_keyIdMap[$id], $cert);
            }
        }
        return $this->_keyIdMap;
    }
665159
public static function GetCacheLimiterList () {
		return [
			static::CACHE_LIMITER_PUBLIC				=> static::CACHE_LIMITER_PUBLIC,
			static::CACHE_LIMITER_PRIVATE_NO_EXPIRE		=> static::CACHE_LIMITER_PRIVATE_NO_EXPIRE,
			static::CACHE_LIMITER_PRIVATE				=> static::CACHE_LIMITER_PRIVATE,
			static::CACHE_LIMITER_NOCACHE				=> static::CACHE_LIMITER_NOCACHE,
			static::CACHE_LIMITER_NOT_SEND_HEADER		=> static::CACHE_LIMITER_NOT_SEND_HEADER,
		];
	}
617618
protected function getIDListFromCache() : array
    {
        $arCacheTags = $this->getCacheTagList();
        $sCacheKey = $this->getCacheKey();

        $arElementIDList  = (array) CCache::get($arCacheTags, $sCacheKey);

        return $arElementIDList;
    }
931208
public function get_table_keys() {
		if ( isset( self::$memo[ get_called_class() ][ __METHOD__ ] ) ) {
			return self::$memo[ get_called_class() ][ __METHOD__ ];
		}

		$keys = array();

		foreach ( $this->get_attribute_keys() as $key ) {
			if ( ! $this->has_map_method( $key ) &&
				 ! $this->has_compute_method( $key )
			) {
				$keys[] = $key;
			}
		}

		return self::$memo[ get_called_class() ][ __METHOD__ ] = $keys;
	}
135431
public function getAll()
    {
        $this->initializeOnDemand();
        $result = array();

        foreach ($this->cache as $key => $options) {
            $result[$key] = $options[ConstProviderInterface::CACHE_PARAM_VALUE];
        }

        return $result;
    }
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;
    }
480984
private function filesFromKey()
    {
        try {
            return $this->manager->files()[$this->file];
        } catch (\ErrorException $e) {
            $this->error(sprintf('Language file %s.php not found!', $this->file));

            return [];
        }
    }
914881
public function all()
	{
		$hash = $this->options['hash'];

		$allinfo = wincache_ucache_info();

		$data = array();

		foreach ($allinfo['cache_entries'] as $key)
		{
			$name    = $key['key_name'];
			$namearr = explode('-', $name);

			if ($namearr !== false && $namearr[0] == $hash && $namearr[1] == 'cache')
			{
				$group = $namearr[2];
				if (!isset($data[$group]))
				{
					$item = new Auditor($group);
				}
				else
				{
					$item = $data[$group];
				}
				if (isset($key['value_size']))
				{
					$item->tally($key['value_size'] / 1024);
				}
				else
				{
					// Dummy, WINCACHE version is too low.
					$item->tally(1);
				}

				$data[$group] = $item;
			}
		}

		return $data;
	}