Generates a multi key prefix for this definition

@return array
173653
public function generate_multi_key_parts() {
        if ($this->keyprefixmulti === null) {
            $this->keyprefixmulti = array(
                'mode' => $this->mode,
                'component' => $this->component,
                'area' => $this->area,
                'siteidentifier' => $this->get_cache_identifier()
            );
            if (isset($this->identifiers) && !empty($this->identifiers)) {
                $identifiers = array();
                foreach ($this->identifiers as $key => $value) {
                    $identifiers[] = htmlentities($key, ENT_QUOTES, 'UTF-8').'='.htmlentities($value, ENT_QUOTES, 'UTF-8');
                }
                $this->keyprefixmulti['identifiers'] = join('&', $identifiers);
            }
        }
        return $this->keyprefixmulti;
    }
690925
public function getUnicodeKeys() {
		$the_array = $this->icons_array;

		if ( is_array( $the_array ) ) {
			$temp = array();

			foreach ( $the_array as $class => $unicode ) {
				$temp[ $class ] = $unicode;
			}

			$the_array = $temp;
		}

		return $the_array;
	}
1182140
public function key()
    {
        if (is_null($this->ext)) {
            $this->ext = $this->generateExt();
        }
        return $this->ext;
    }
1297238
public function keySet()
    {
        $result = [];
        $keys = $this->keys();
        foreach ($keys as $key) {
            $result[] = $key;
        }

        return $result;
    }
559452
public function keys()
    {

        $keys = new StringList();
        $url = $this->urlOrFail();

        if (!$this->filesystem->isDirectory($url)) {
            return $keys;
        }

        $fileExtension = $this->fileExtension();

        foreach ($this->filesystem->listDirectory($url) as $fileName) {

            if ($this->filesystem->extension($fileName) != $fileExtension) {
                continue;
            }

            if ($this->filesystem->isDirectory($fileName)) {
                continue;
            }

            $keys->append($this->keyOfFile($fileName));

        }

        return $keys;
    }
401045
public function keys()
    {
        return $this->create(array_keys($this->toArray()))->map(
            function ($key) {
                return new String($key);
            }
        );
    }
948955
public function getPrefix()
  {
    $uuid = uniqid(static::CACHE_CHECK_PREFIX, true);
    $prefix = wp_cache_get($this->prefix, static::CACHE_GROUP_KEY, false, $uuid);

    if ($prefix !== $uuid) {
      return $prefix;
    }

    $this->setPrefix($this->prefix);
    return $this->getPrefix();
  }
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;
    }
708819
public function generate()
	{
		$args = func_get_args();
		$useKeyLength = array_shift($args);

		if (!is_bool($useKeyLength)) {
			array_unshift($args, $useKeyLength);
			$useKeyLength = false;
		}

		$callables = call_user_func_array(array($this, 'flattenArguments'), $args);

		$key = $this->keygen($useKeyLength ? $this->length : $this->getAdjustedKeyLength());

		while ($callable = current($callables)) {
			if (is_callable($callable)) {
				$key = call_user_func($callable, $key);
			}
			next($callables);
		}

		return sprintf("%s%s%s", $this->prefix, $key, $this->suffix);
	}
288855
public function getKeys()
    {
        $keys = array_keys($this->cache) + array_keys($this->factories);
        return array_unique($keys);
    }
273056
protected static function generateRandomKey()
  {
    $chars = array('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F');
    $baseKey = '';
    for ($i = 0; $i < self::$baseKeyLength; $i++) {
      $baseKey .= $chars[rand(0, count($chars) - 1)];
    }
    $baseKey .= uniqid();

    return $baseKey;
  }
127963
private function generateKey()
    {
        $this->info('Generating application key');
        $this->callSilent('key:generate', ['--force' => true]);
        $this->advanceBar();

        $this->clearCaches();

        return $this;
    }
603549
private function resolveKey($keys)
    {
        if (is_array($keys)) {
            $result = [];
            foreach ($keys as $key) {
                $result[] = $this->prefix . $key;
            }

            return $result;
        }

        return $this->prefix . $keys;
    }
736998
protected function generateCacheKey()
    {
        $bindings = array_map(function ($param) {

            // Round datetime
            if ($param instanceof \DateTime) {
                $this->isTimeAwareQuery = true;
                return $this->getRoundedDateTime($param);
            }

            return $param;

        }, $this->getBindings());


        return sha1($this->connection->getName() . $this->toSql() . serialize($bindings));
    }
430636
public function getKeys() {
        $keys = [];
        foreach($this->arrays as $array) {
            $keys = array_merge($keys, $array instanceof \ArrayAccess ? $array->getKeys():array_keys($array));
        }
        return array_unique($keys);
    }
441940
public function getKeyPrefix()
    {
        if (!$this->keyPrefix) {
            return '';
        }

        $clean = Inflector::slug($this->keyPrefix);
        return substr($clean, 0, 8);
    }
968632
public function getTaxonomyKeys()
    {
        $taxonomies = $this->getTaxonomies();
        if (!Arr::iterable($taxonomies)) {
            return array();
        }

        $out = array();
        foreach ($taxonomies as $k => $taxonomy) {
            $taxonomy = $this->getTaxonomy($k);
            $out[] = $this->getTaxonomyKey($k, $taxonomy);
        }
        return $out;
    }