Normalizes key by calling each item in chain

@param string $key

@return string
337408
public function normalize($key)
    {
        foreach ($this->chain as $normalizer) {
            $key = $normalizer->normalize($key);
        }

        return $key;
    }
220583
public function hash($key)
    {
        $needle = hexdec(substr(md5($key), 0, 7));
        $server = $min = 0;
        $max = count($this->nodes) - 1;
        while ($max >= $min) {
            $position = (int) (($min + $max) / 2);
            $server = $this->nodes[$position];
            if ($needle < $server) {
                $max = $position - 1;
            } elseif ($needle > $server) {
                $min = $position + 1;
            } else {
                break;
            }
        }
        return $this->ring[$server];
    }
348802
private function parseRaw($key)
    {
        $key = str_replace('[]', '', $key);
        parse_str($key, $levels);
        if (is_null($levels)) {
            return null;
        }
        $inputs = $this->data;
        return $this->recurseGet($levels, $inputs);
    }
584332
public function sanitizeKey( $key ) {
		$key = trim( strtolower( preg_replace( '/-/', '', $key ) ) );
		$key = implode( '-', str_split( $key, 8 ) );
		return sanitize_key( $key );
	}
168311
def normalise_key(self, key):
        """"""
        key = key.replace('-', '_')
        if key.startswith("noy_"):
            key = key[4:]
        return key
596136
protected function getCompositeKey(string $key) : string
    {
        $keys = $this->keys;
        $keys[] = $key;
        $output = implode('.', $keys);
        return trim($output, '.');
    }
1025951
protected function normalizeKey($name)
	{
		$name = strtolower($name);
		$name = str_replace(array('-', '_'), ' ', $name);
		$name = preg_replace('#^http #', '', $name);
		$name = ucwords($name);
		$name = str_replace(' ', '-', $name);

		return $name;
	}
1190109
public function parseKey($key)
    {
        $keys = explode('.', $key);

        if (count($keys) === 1) {
            $keys = [$this->getManager()->getRepository()->newEntity()->getTable(), $keys[0]];
        }

        return DB::raw('`'.implode('.', array_slice($keys, 0, -1)).'`.'.$keys[count($keys) - 1]);
    }
93468
public function getItem($key)
    {
        if (!$this->getOptions()->getEnabled()) {
            return null;
        }

        $this->normalizeKey($key);

        $result = null;
        try {
            $result = $this->internalGetItem($key);
        } catch (\Exception $e) {
        }

        return $result;
    }
661841
public static function normalizeKey($key)
    {
        $key = strtr(strtolower($key), '_', '-');
        if (strpos($key, 'http-') === 0) {
            $key = substr($key, 5);
        }

        return $key;
    }
949861
public function convertToArraySyntax($key)
    {
        if (strpos($key, '.') === false) {
            return $key;
        }
        $key = str_replace('.', '][', $key);
        $key = preg_replace('#\]#', '', $key, 1);

        return $key.']';
    }
1035115
protected function _convertKeyNames($key)
    {
        if (array_key_exists($key, self::$_cacheKeys)) {
            return self::$_cacheKeys[$key];
        }

        $convertedKey = strtolower(
            preg_replace('/(.)([A-Z0-9])/', "$1_$2", $key)
        );
        self::$_cacheKeys[$key] = $convertedKey;
        return $convertedKey;
    }
1007052
protected function parse($key)
    {
        $values = $this->registry;
        $parts = explode(".", $key);
        foreach ($parts as $part) {
            if ($part === "") {
                return $values;
            }
            if (!is_array($values) || !array_key_exists($part, $values)) {
                return ;
            }
            $values = $values[$part];
        }

        return $values;
    }
285660
public function get($key)
	{
		if (!$this->exists($key))
		{
			throw $this->getNotExistException($key);
		}

		$key = $this->normalizeKey($key);

		return $this->items[$key];
	}
1160304
protected function _normalize($key, $type)
    {
        $type = strtolower($type);

        if ($type !== 'external' && $type !== 'internal')
            throw new \InvalidArgumentException;

        if ($type === 'external')
            $return = $this->_normalizeExternal($key);
        else
            $return = $this->_normalizeInternal($key);

        return $return;
    }
457998
protected function indexKey($key)
    {
        $keys = $this->getServiceKeys();

        array_push($keys, $key);

        $keys = array_unique($keys);

        $this->setServiceKeys($keys);

        return $this->getFullKey($key);
    }
527344
protected function processKey($key)
    {
        $key = trim(strtolower($key));
        $key = preg_replace('#[^a-z0-9\.]#', '-', $key) . '~' . $this->keySuffix;

        return $key;
    }