Remove a namespace from the ontology. All triples bound to the model will
be removed.

@access public
@author Jerome Bogaerts, <jerome.bogaerts@tudor.lu>
@return boolean
343226
public function remove()
    {
        $returnValue = (bool) false;

        
        $db = core_kernel_classes_DbWrapper::singleton();
        if (false === $db->exec("DELETE FROM statements WHERE modelid = ?", array($this->getModelId()))){
        	$returnValue = false;
        }
        else{
        	if (false === $db->exec("DELETE FROM models WHERE modelid = ?", array($this->getModelId()))){
        		$returnValue = false;
        	}
        	else{
        		$returnValue = true;
        	}
        }
        
        

        return (bool) $returnValue;
    }
992949
public function clear()
    {
        $keys = self::$instance->keys($this->options['prefix'].'*');
        if ($keys) {
            self::$instance->del(...$keys);
        }

        return true;
    }
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 = [];
        }
    }
1008649
public function delete()
	{
		if ($this->deleted) {
			return;
		}
		$this->deleted = true;

		$left = $this->getLeftValue();
		$spaceUsed = $this->getIntervalSize() + 1;
		$this->repository->delete($this);

		// Free the unused space
		$this->repository->truncate($left, $spaceUsed);
	}
1112566
private function namespaceMatches() : bool
    {
        $currentNamespace = ($this->currentNamespace && is_array($this->currentNamespace->name->parts))
            ? $this->currentNamespace->name->toString()
            : '';

        return $currentNamespace === $this->reflectedClass->getNamespaceName();
    }
1059666
public function unlinkAll()
    {
        foreach ($this->getValue() as $value) {
            $this->unlinkItem($value);
        }

        // Reset current value
        $this->value = new EntityCollection($this->getEntity());

        return true;
    }
595287
public function remove()
    {
        if($moduleEvents = $this->module->events())
        {
            $systemEvents = $this->load();
            if (isset($moduleEvents['listen']))
                // for listen event we must check if exists merge if not add it
                foreach ($moduleEvents['listen'] as $event => $listens)
                {
                    if (isset($systemEvents['listen'][$event]))
                    {
                        foreach ($listens as $listen)
                        {
                            $key = array_search($listen, $systemEvents['listen'][$event]);
                            if ($key !== false)
                                unset($listen, $systemEvents['listen'][$event][$key]);
                        }
                    }
                }
            // for subscribe
            if (isset($moduleEvents['subscribe']))
            {
                $key = array_search($moduleEvents['subscribe'], $systemEvents['subscribe'][$event]);
                if($key !==false)
                    unset($systemEvents['subscribe'][$key]);
            }
            return $this->set($systemEvents);
        }
        return true;
    }
323662
public function clear(?string $namespace = self::DEFAULT_NAMESPACE): void
    {
        if (null === $namespace) {
            $this->nodeRefs = [];
            return;
        }

        unset($this->nodeRefs[$namespace]);
    }
199490
def delete(self, namespacePrefix):
        """"""
        ns = db.ConfigNamespace.find_one(ConfigNamespace.namespace_prefix == namespacePrefix)
        if not ns:
            return self.make_response('No such namespace: {}'.format(namespacePrefix), HTTP.NOT_FOUND)

        db.session.delete(ns)
        db.session.commit()

        self.dbconfig.reload_data()
        auditlog(
            event='configNamespace.delete',
            actor=session['user'].username,
            data={'namespacePrefix': namespacePrefix}
        )
        return self.make_response('Namespace deleted')
1148255
public function removeName($nameIndex)
    {
        $removed = false;
        $positions = $this->positions;
        foreach ($positions as $position) {
            $source = $position->source;
            $ni = $source->nameIndex;
            if ($ni === $nameIndex) {
                $removed = true;
                $source->nameIndex = null;
                $source->name = null;
            } elseif ($ni > $nameIndex) {
                $source->nameIndex--;
            }
        }
        return $removed;
    }
569375
public function getEntityNamespace()
    {
        $namespace = '';
        if (($bundleNamespace = $this->parseComment('bundleNamespace')) || ($bundleNamespace = $this->getConfig()->get(Formatter::CFG_BUNDLE_NAMESPACE))) {
            $namespace = $bundleNamespace.'\\';
        }
        if ($entityNamespace = $this->getConfig()->get(Formatter::CFG_ENTITY_NAMESPACE)) {
            $namespace .= $entityNamespace;
        } else {
            $namespace .= 'Entity';
        }

        return $namespace;
    }
98268
final public function remove($varname = '', $namespace = 'default')
    {
        //if the registry is empty and the namespace is not default
        //delete the registry;
        //stores a value to a varname in a namespace of this session
        $session = $this;


        //echo $namespace;
        //@TODO, check if the regitry is not locked before adding
        if (!$session->isLocked($namespace)) {

            $registry = $session->getNamespace($namespace);
            $registry->delete($varname);
        }
        //If auth is locked

        return $session;
    }
1010876
public function deleteFrom($namespace, $key)
    {
        if (isset($_SESSION[$namespace])) {
            $oldNamespace = $this->namespace;
            $this->setNamespace($namespace);
            $this->delete($key);
            $this->setNamespace($oldNamespace);
        }
    }
576136
public function delete()
    {
        if (!$this->exists()) {
            return false;
        }
        if ($this->isDir()) {
            return rmdir($this->absoluteFileName);
        }

        return unlink($this->absoluteFileName);
    }
724224
public function delete()
    {
        if (is_resource($this->handle)) {
            fclose($this->handle);
            $this->handle = null;
        }
        if ($this->exists()) {
            return unlink($this->path);
        }

        return false;
    }
1232988
protected function namespaceChanged()
    {
        // Get locale we target (performance)
        $encoding = $this->getEncoding();
        $redirectLocale = $this->getRedirectLocale();

        // Init interface for translation
        if ((!self::$translatorInterfaces) || (false === isset(self::$translatorInterfaces[$encoding]))) {
            self::$translatorInterfaces[$encoding] = $this->translatorInterfaceFactory();
        }

        $locale = ($redirectLocale !== null) ? $redirectLocale : $this->getLocale();

        // Set the new namespace and retrieve key to translationtable
        $this->setTranslationTableUid(
            self::$translatorInterfaces[$encoding]->initLocaleNamespace(
                $locale,
                $this->getNamespaces()
            )
        );

        return true;
    }
1300039
protected function removeLanguageFromOntology()
    {
        
        $this->outVerbose("Removing RDF language description '" . $this->options['language'] . "' from ontology...");
        $taoNS = 'http://www.tao.lu/Ontologies/TAO.rdf#';
        $expectedDescriptionUri = $taoNS . 'Lang' . $this->options['language'];
        $lgResource = new core_kernel_classes_Resource($expectedDescriptionUri);
        
        if (true === $lgResource->exists()) {
            $lgResource->delete();
            $this->outVerbose("RDF language description '" . $this->options['language'] . "' successfully removed.");
        }else{
            $this->outVerbose("RDF language description '" . $this->options['language'] . "' not found but considered removed.");
        }
        
    }