Removes a class from the symbols object.
@param string $name
@param string $namespace A specific namespace.
@param string $header A specific header.
541899
public function RemoveClass($name, $namespace="", $header="")
    {
        if($header)
        {
            if($namespace)
            {
                unset($this->headers[$header]->namespaces[$namespace]->classes[$name]);
            }
            else
            {
                foreach($this->headers[$header]->namespaces as $namespace_object)
                {
                    unset($namespace_object->classes[$name]);
                }
            }
        }
        elseif($namespace)
        {
            foreach($this->headers as $header_object)
            {
                unset($header_object->namespaces[$namespace]->classes[$name]);
            }
        }
        else
        {
            foreach($this->headers as $header_object)
            {
                foreach($header_object->namespaces as $namespace_object)
                {
                    unset($namespace_object->classes[$name]);
                }
            }
        }
    }
153021
private function removeHeader($name, array &$options)
    {
        foreach (array_keys($options['_headers']) as $key) {
            if (!strcasecmp($key, $name)) {
                unset($options['_headers'][$key]);
                return;
            }
        }
    }
184444
public function unregisterNamespace($namespace)
    {
        if (is_string($namespace)) {
            $namespace = (array) $namespace;
        } elseif (!is_array($namespace)) {
            throw new Zend_Loader_Exception('Invalid namespace provided');
        }

        foreach ($namespace as $ns) {
            if (isset($this->_namespaces[$ns])) {
                unset($this->_namespaces[$ns]);
            }
        }
        return $this;
    }
1013701
public function removeHeader($name)
    {
        if (!$this->hasHeader($name)) {
            throw new \InvalidArgumentException(sprintf('The request header "%s" does not exist.', $name));
        }

        unset($this->headers[$name]);
    }
68817
@Transactional
  public void deleteNamespace(String namespace) {
    List<L10nString> namespaceEntities = getL10nStrings(namespace);
    dataService.delete(L10N_STRING, namespaceEntities.stream());
  }
121470
public static function delete(string $name, string $namespace = '*'): void
    {
        self::initialize();
        if (isset($_SESSION[$namespace][$name])) {
            unset($_SESSION[$namespace][$name]);
            if (count($_SESSION[$namespace]) === 0) {
                unset($_SESSION[$namespace]);
            }
        }
    }
1257706
public function remove($name)
    {
        $context = $this->_context;

        if (!$context->started) {
            $this->_start();
        }

        $context->is_dirty = true;
        unset($context->_SESSION[$name]);
    }
676592
public function delete($name)
	{
		$templates = $this->getTemplates();
		$templates->delete($name, $this->plugin->name);
	}
411960
public function clear($namespace='default')
    {
        $cleared = false;

        if (isset($this->addedData[$namespace])) {
            $this->addedData[$namespace] = [];
            $cleared = true;
        }

        if (isset($this->cachedData[$namespace])) {
            $this->cachedData[$namespace] = [];
            $cleared = true;
        }

        if ($cleared) {
            $this->queryHits = [];
        }
    }
250059
@Override
  public void close(String namespace)
  {
    if (config.isEvictOnClose()) {
      cache.asMap().keySet().removeIf(key -> key.namespace.equals(namespace));
    }
  }
784907
public function clearFrom($namespace, $key = null)
    {
        $oldNamespace = $this->namespace;
        $this->setNamespace($namespace);
        $this->clear($key);
        $this->setNamespace($oldNamespace);
    }
827188
public function remove($name, $namespace = null)
    {
        // Get previous value
        $value = $this->get($name, null, $namespace);

        // Set value
        $this->set($name, null, $namespace);

        // Return old value
        return $value;
    }
335032
public function removePattern($name)
    {
        foreach ($this->patterns as $k => $p) {
            if ($p[0] === $name) {
                unset($this->patterns[$k]);
            }
        }
    }
407499
protected function isClient(string $namespace, string $name): bool
    {
        if (preg_match('/^Spryker[a-zA-Z]*\\\\Client\\\\[a-zA-Z]+$/', $namespace) && preg_match('/^(.*?)(Client|ClientInterface)$/', $name)) {
            return true;
        }

        return false;
    }
516121
public function remove($name)
    {
        if ($this->rootModule && $name === $this->rootModule->getName()) {
            $this->rootModule = null;
        }

        unset($this->modules[$name]);
    }
540720
def delete_namespace(self, name):
        
        self.core_api.delete_namespace(name, client.V1DeleteOptions())

        logger.info("Deleting namespace: %s", name)
889667
public function removeClass($name)
    {
        foreach ($this as $node) {
            if ($node instanceof \DOMElement) {
                /** @var \DOMElement $node */
                $classes = preg_split('/\s+/s', $node->getAttribute('class'));
                $count = count($classes);
                for ($i = 0; $i < $count; $i++) {
                    if ($classes[$i] == $name) {
                        unset($classes[$i]);
                    }
                }
                $node->setAttribute('class', trim(join(' ', $classes)));
            }
        }
        return $this;
    }