@param string $key

@return ContainerInterface
320119
public function remove($key)
    {
        if ($this->has($key)) {
            $cont = clone $this;
            $cont->removeParameter($key);

            return $cont;
        }

        return $this;
    }
1039428
public static function createNormalizer($key = 'default')
    {
        return isset(self::$instancePool[$key]) ?
            self::$instancePool[$key] :
            self::$instancePool[$key] = new static(
            PropertyAccess::createPropertyAccessor()
        );
    }
1192877
public function &offsetGet($key)
    {
        if (!isset($this->storage[$key])) {
            $this->storage[$key] = null;
        }

        return $this->storage[$key];
    }
171206
public function clean(string $key = null): ConfigInterface
    {
        if (null !== $key) {
            unset($this->_config[$key]);
        } else {
            $this->_config = [];
        }

        return $this;
    }
332316
public function offsetGet($key)
    {
        if (!\is_array($key)) {
            return $this->offsetExists($key) ? $this->container[$key] : null;
        }

        $namespace = key($key);
        $key = current($key);

        if (!$this->offsetExists($namespace) || !\is_array($this->container[$namespace])) {
            return null;
        }

        if (isset($this->container[$namespace][$key]) || \array_key_exists($key, $this->container[$namespace])) {
            return $this->container[$namespace][$key];
        }

        return null;
    }
745565
public function remove($key)
    {
        $unit = $this->searchForId($key);
        if ($unit) {
            $unit->parentNode->removeChild($unit);
        }

        return $this;
    }
109410
protected static function ctxGetContainer(ContextInterface $context): ContainerInterface
    {
        assert(static::ctxHasContainer($context));

        return $context->get(ContextProperties::CTX_CONTAINER);
    }
765981
public function get($key)
    {
        if(!is_string($key)) {
            throw new OffsetNotValid(sprintf("Offset must be a string, %s passed", gettype($key)));
        }

        //automatically resolve factory callables if they exist
        if(!$this->has($key) && $this->isFactory($key) && is_callable(($factory = $this->getFactory($key)))) {
            return $this->reflector->resolveCallableString($key, $factory, true);
        }

        //automatically resolve shared callables if they exist
        if(!$this->has($key) && $this->isShared($key) && is_callable(($shared = $this->getShared($key)))) {
            return $this->reflector->resolveCallableString($key, $shared);
        }

        //get alias
        $alias = $this->isAlias($key) ? $this->getAlias($key) : $key;

        //automatically resolve classes if they exist even if they don't exist in our reflector cache
        if(!$this->has($alias) && class_exists($alias, true)) {
            return $this->reflector->resolveClassString($alias, $this->isFactory($alias));
        }

        //return basic container value
        return $this->offsetGet($alias);
    }
406637
protected function addConditionalAvailabilityClient(Container $container): Container
    {
        $container[static::CONDITIONAL_AVAILABILITY_CLIENT] = function (Container $container) {
            return $container->getLocator()->conditionalAvailability()->client();
        };

        return $container;
    }
1278577
public function remove($key) {
    $file = $this->getFile($this->getKey($key));
    $file->delete();
    return $this;
  }
26490
protected function closeTag($key)
    {
        $exp = explode('_', $key);

        if ($this->openTagHolder == $exp[1]) {
            $this->elements[static::$formHolder[static::$formName]][$key] = "</$exp[0]>".PHP_EOL;
        }

        return $this;
    }
644355
private function getService(string $service)
    {
        if ($this->container instanceof ContainerInterface && $this->container->has($service)) {
            return $this->container->get($service);
        }

        return new $service();
    }
864148
public function getSection(string $key) : ConfigurationBagInterface
    {
        return new ConfigurationBag(isset($this->configuration[$key]) ? $this->configuration[$key] : []);
    }
1193371
public function resolve( $key ) {
		$this->verifyBootstrap();

		if ( ! isset( $this->getContainer()[ $key ] ) ) {
			return null;
		}

		return $this->getContainer()[ $key ];
	}
952539
public function has($key)
	{
		$key = $this->resolveAlias($key);

		$exists = (bool) $this->getRaw($key);

		if ($exists === false && $this->parent instanceof ContainerInterface)
		{
			$exists = $this->parent->has($key);
		}

		return $exists;
	}
159403
public function remove($key)
    {
        $keys = explode('.', $key);

        $data = $this->getAll();

        $resource = &$data;
        foreach ($keys as $index => $key) {
            if (!isset($resource[$key])) {
                // We bail, the requested key could not be found
                return $this;
            }
            if ($index < (count($keys) - 1)) {
                $resource = &$resource[$key];
            }
        }
        unset($resource[$key]);

        $this->setAll($data);

        return $this;
    }
345242
public function getOptions(ContainerInterface $container, $key, $name = null)
    {
        if ($name === null) {
            $name = $this->getName();
        }

        $options = $container->get('config');
        $options = $options['doctrine'];
        if ($mappingType = $this->getMappingType()) {
            $options = $options[$mappingType];
        }
        $options = isset($options[$key][$name]) ? $options[$key][$name] : null;

        if (null === $options) {
            throw new RuntimeException(
                sprintf(
                    'Options with name "%s" could not be found in "doctrine.%s".',
                    $name,
                    $key
                )
            );
        }

        $optionsClass = $this->getOptionsClass();

        return new $optionsClass($options);
    }