Removes an interface.

If the interface is passed as PhpInterface object,
the interface is also remove from the use statements.

@param PhpInterface|string $interface interface or qualified name
@return $this
328086
public function removeInterface($interface) {
		if ($interface instanceof PhpInterface) {
			$name = $interface->getName();
			$qname = $interface->getQualifiedName();

			$this->removeUseStatement($qname);
		} else {
			$name = $interface;
		}

		$this->interfaces->remove($name);

		return $this;
	}
830851
public function remove(...$args): RegistryInterface
    {
        if (!count($args)) {
            //there's nothing to remove
            return $this;
        }

        $separator = '--'. md5(uniqid()) . '--';
        return $this->removeDot(implode($separator, $args), $separator);
    }
605641
public function del($cookie) {

        if ( empty($cookie) ) throw new CookieException("Invalid cookie object or name");

        $name = ($cookie instanceof CookieInterface) ? $cookie->getName() : $cookie;

        if ( $this->isRegistered($name) ) {
            unset($this->cookies[$name]);
        } else {
            throw new CookieException("Cookie is not registered");
        }

        return $this;

    }
791970
public function unregister(ListenerInterface $listener)
    {
        if (!isset($this->storage[$listener])) {
            throw new InvalidArgumentException('Listener is not registered.');
        }

        foreach ($this->storage[$listener] as $event => $EElistener) {
            $listener->removeListener($event, $EElistener);
        }

        $this->storage->detach($listener);

        return $this;
    }
590784
public function setInterface($interface)
	{
		$validValues = [
			Request::INTERFACE_CREDIT_CARD,
			Request::INTERFACE_TEST,
		];

		$this->validateInput(Request::ATTRIBUTE_INTERFACE, $interface, $validValues);

		$this->interface = $interface;

		return $this;
	}
138799
public function remove(BaseEntityInterface $entity): self
    {
        $this->getRepository()->remove($entity, true);

        return $this;
    }
530770
public function remove($identifier)
    {
        $keys = $this->_parseIdentifier($identifier);

        foreach($keys as $key)
        {
            if(array_key_exists($key, $this->_data))
            {
                unset($this->_data[$key]);
                break;
            };
        }

        return $this;
    }
1253052
private function removeByPrefix(InputInterface $input, OutputInterface $output)
    {
        $prefix = $input->getOption('prefix');
        $output->writeln(
            sprintf('<comment>Removing all resources from <info>%s</info></comment>', $prefix)
        );

        $api = $this->getCloudinaryApi();

        $response = $api->delete_resources_by_prefix($prefix);
        $this->outputApiResponse($response, 'deleted', $output);
    }
292423
public function removeElement(ResourceInterface $resource): ResourceCollectionInterface
    {
        $this->remove($resource->type(), $resource->id());

        return $this;
    }
801154
public function removeValue(ValueInterface $value)
    {
        $this->values->removeElement($value);
        $value->setData(null);

        $this->removeValueByAttribute($value);

        return $this;
    }
1025878
public function removeChannel($channel)
    {
        if ($channel instanceof ChannelInterface) {
            $channel = $channel->getId();
        }

        $channel = (string) $channel;

        if (false !== ($key = array_search($channel, $this->channels))) {
            unset($this->channels[$key]);
        }

        return $this;
    }
309706
public function delete($id)
    {
        if ($this->has($id)) {
            //remove instance
            unset($this->instances[$id]);

            //remove interface reference if exists
            foreach ($this->interfaces as $int => $classes) {
                $key = array_search($id, $classes);
                if ($key !== false) {
                    unset($classes[$key]);
                    $this->interfaces[$int] = $classes;
                }
            }

            //remove instance from singleton binding
            if ($this->hasDefinition($id)) {
                $definition = $this->getDefinition($id);
                if ($definition instanceof Singleton) {
                    $definition->deleteStoredInstance();
                }
            }
        }
        return $this;
    }
259627
public function delCert(string $type): ConfigInterface
    {
        $type = mb_strtolower($type);
        $this->throwIfNotInArray($type, self::CERTS);
        unset($this->_certs[$type]);
        return $this;
    }
89320
public function destroy(): SessionInterface
    {
        $this->init();

        # Start the session up, but ignore the error about headers already being sent
        @session_start();

        # Clear the session data from the server
        session_destroy();

        # Clear the cookie so the client knows the session is gone
        setcookie($this->name, "", time() - 86400, $this->cookie->getPath(), $this->cookie->getDomain(), $this->cookie->isSecure(), $this->cookie->isHttpOnly());

        # Reset the session data
        $this->init = false;
        $this->data = [];

        return $this;
    }
392832
public function removeComponent($id)
    {
        /** @var PartInterface $component */
        $component = $this->getComponents()->findByProperty('id', $id, true);
        if ($component) {
            $this->getComponents()->remove($component);
        }
        return $this;
    }
958130
public function remove($factory = null)
    {
        if (!($factory instanceof FactoryInterface)) {
            $factory = $this->find($factory);
        }

        $this->factories = array_values(array_filter($this->factories, function($f) use ($factory) {
            return $f !== $factory;
        }));

        return $this;
    }
612168
public function hasInterface($interface): bool {
		if ($interface instanceof PhpInterface) {
			return $this->interfaces->contains($interface->getName())
				|| $this->interfaces->contains($interface->getQualifiedName());
		}

		return $this->interfaces->contains($interface) || $this->hasInterface(new PhpInterface($interface));
	}