@param string $key Object path.

@throws UnresolvableObjectException When not able to resolve the object path. Any exception thrown by underlying
resolver will be converted to this exception.

@return string
330325
public function resolve($key)
    {
        try {
            return $this->resolver->resolve($key);
        } catch (\Exception $e) {
            throw new UnresolvableObjectException($key, $e);
        }
    }
1168819
public static function getConfiguredUrl($key)
    {
        if (empty(self::$urlOptions[$key])) {
            throw new Exception("Invalid key $key");
        }
        $url = Option::get(self::$urlOptions[$key]);
        return $url;
    }
1365828
protected function getValue($key)
    {
        if (!array_key_exists($key, $this->store)) {
            throw new KeyNotFoundException();
        }

        $getResult = $this->store[$key];
        $unserialized = @unserialize($getResult);

        if (Util::hasInternalExpireTime($unserialized)) {
            $this->handleTtl($key, $unserialized['ts'], $unserialized['s']);

            $getResult = $unserialized['v'];
        }

        return $getResult;
    }
84806
public function load($key)
    {
        if (Crumb::has(static::PAYLOAD)) {
            return unserialize(base64_decode(Crumb::get(static::PAYLOAD)));
        }

        return null;
    }
752032
protected function _normalizeKey($key)
    {
        try {
            return $this->_normalizeString($key);
        } catch (InvalidArgumentException $e) {
            throw $this->_createOutOfRangeException($this->__('Invalid key'), null, $e, $key);
        }
    }
855811
public static function get($key) {
		$memcached = self::connect();
		$var = $memcached->get($key);
		if ($var === false) {
			throw new \Exception('Object not in cache');
		} else {
			return $var;
		}
	}
561465
private function getByPropertyName($key)
    {
        if (($key = $this->getArrayKey($key)) !== static::NOT_FOUND) {
            if (is_array($this->items[$key])) {
                return $this->__wrap($this->items[$key]);
            }

            return $this->items[$key];
        }

        return static::NOT_FOUND;
    }
881251
protected function restoreDataStructure($key)
    {
        if ($this->isSerializedArray($key)) {
            return \unserialize(self::$registry[$key]['value']);
        }

        return (\is_object(self::$registry[$key]['value'])) ?
            clone self::$registry[$key]['value'] :
            self::$registry[$key]['value'];
    }
610987
public function getIndexingProperty($key)
    {
        $this->loadIndexingProperties();

        if (!array_key_exists($key, $this->indexingProperties)) {
            throw new \InvalidArgumentException(
                'No indexing property "' . $key . '".',
                1323174143
            );
        }

        return $this->indexingProperties[$key];
    }
454978
private function resolve($key)
    {
        $reflection = new \ReflectionClass($key);

        if (!$reflection->isInstantiable()) {
            return $key;
        }

        $constructor = $reflection->getConstructor();

        if (!$constructor) {
            return $reflection->newInstance();
        }

        $parameters = $constructor->getParameters();

        $parameters_lists = [];

        foreach ($parameters as $parameter) {
            if ($parameter->getClass()) {
                $parameters_lists[] = $this->make($parameter->getClass()->getName());
            } else {
                $parameters_lists[] = $parameter->getDefaultValue();
            }
        }

        if (!empty($this->parameters)) {
            $parameters_lists = $this->parameters;

            $this->parameters = [];
        }

        return $reflection->newInstanceArgs($parameters_lists);
    }
419574
public function getCached($key)
    {
        if ($image = $this->imageResolver->resolveFromCache($key)) {
            return $this->render($image);
        }

        return $this->notFound();
    }
161902
protected function resolveAlias($key)
	{
		if (isset($this->aliases[$key]))
		{
			return $this->aliases[$key];
		}

		return $key;
	}
100319
public function getType($key) {
        $types = $this->getSupportedTypes();

        if (isset($types[$key])) {
            return new $types[$key]($this);
        }

        throw new UnsupportedTypeException(sprintf('Unsupported data type %s', $key));
    }
242736
public function getWritable($key): WritableTranslationValueInterface
    {
        $chunks = explode('.', $key);
        if (\count($chunks) < 2) {
            throw new NotSupportedException($this, 'Key ' . $key . ' is in bad format (need: [id].[prop-name])');
        }

        // [id].propname
        if (null === ($extractor = $this->getExtractor($chunks[1]))) {
            throw new NotSupportedException($this, 'Key ' . $key . ' is not supported (no extractor found)');
        }

        $sourceId = (int) $chunks[0];
        $targetId = $this->idMap->getTargetIdFor($sourceId);

        return $this->createValueWriter($sourceId, $targetId, $extractor, implode('.', \array_slice($chunks, 2)));
    }
1319605
public function getStoragePath(string $key = null): string
    {
        if (null === $key) {
            $path = $this->dataFolder;
        } else {
            $path = sprintf($this->dataPattern, $this->dataFolder, $key, substr($key, 0, 2));
        }

        return $path;
    }
611243
public function get($key)
    {
        $getResult = $this->getValue($key);
        $unserialized = @unserialize($getResult);

        if (Util::hasInternalExpireTime($unserialized)) {
            $getResult = $unserialized['v'];
        }

        return $getResult;
    }
866326
protected function getPath($key)
    {
        if ($this->humanReadable) {
            $path = $this->sanitizeReadableFileName($key);
        } else {
            $encoded = hash('md5', $key);
            $path = implode(DIRECTORY_SEPARATOR,str_split(substr($encoded, 0, $this->levels))).DIRECTORY_SEPARATOR.$encoded;
        }
        return  $this->directory.$path.'.php';
    }