Uninstall provided extension.

@param installedExtension the extension to uninstall
@param namespace the namespace
@see #uninstallExtension(LocalExtension, String)
352885
private void removeInstalledExtension(DefaultInstalledExtension installedExtension, String namespace)
    {
        removeInstalledFeature(installedExtension.getId().getId(), namespace);

        for (ExtensionId feature : installedExtension.getExtensionFeatures()) {
            removeInstalledFeature(feature.getId(), namespace);
        }

        removeFromBackwardDependencies(installedExtension, namespace);

        if (!installedExtension.isInstalled()) {
            removeCachedExtension(installedExtension);
        }
    }
763369
def remove_namespace(self, namespace):
        """"""
        params = (namespace, )
        execute = self.cursor.execute
        execute('DELETE FROM gauged_data WHERE namespace = %s', params)
        execute('DELETE FROM gauged_statistics WHERE namespace = %s', params)
        execute('DELETE FROM gauged_keys WHERE namespace = %s', params)
        self.remove_cache(namespace)
440151
public void uninstallBundle(final String symbolicName, final String version) {
        Bundle bundle = bundleDeployerService.getExistingBundleBySymbolicName(symbolicName, version, null);
        if (bundle != null) {
            stateChanged = true;
            Logger.info("Uninstalling bundle: " + bundle);
            BundleStartLevel bundleStartLevel = bundle.adapt(BundleStartLevel.class);
            if (bundleStartLevel.getStartLevel() < currentFrameworkStartLevelValue) {
                setFrameworkStartLevel(bundleStartLevel.getStartLevel());
            }
            try {
                bundle.uninstall();
            } catch (BundleException e) {
                Logger.error("Error during uninstalling bundle: " + bundle.toString(), e);
            }
        }
    }
957926
public static void uninstall() {
		final PopupFactory factory = PopupFactory.getSharedInstance();
		if (!(factory instanceof ShadowPopupFactory)) {
			return;
		}

		final PopupFactory stored = ((ShadowPopupFactory) factory).storedFactory;
		PopupFactory.setSharedInstance(stored);
	}
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]);
            }
        }
    }
130612
public function uninstallExtension($extensionName)
	{
		$this->amOnPage('/administrator/index.php?option=com_installer&view=manage');
		$this->waitForText('Extensions: Manage', '30', array('css' => 'H1'));
		$this->searchForItem($extensionName);
		$this->waitForElement(array('id' => 'manageList'), '30');
		$this->click(array('xpath' => "//input[@id='cb0']"));
		$this->click(array('xpath' => "//div[@id='toolbar-delete']/button"));
		$this->acceptPopup();
		$this->waitForText('was successful', '30', array('id' => 'system-message-container'));
		$this->see('was successful', '#system-message-container');
		$this->searchForItem($extensionName);
		$this->waitForText(
			'There are no extensions installed matching your query.',
			TIMEOUT,
			array('class' => 'alert-no-items')
		);
		$this->see('There are no extensions installed matching your query.', '.alert-no-items');
		$this->debug('Extension successfully uninstalled');
	}
733371
public void removeExtension() {

		try {
			if (contentsIdDao.isTableExists()) {
				geoPackage.dropTable(contentsIdDao.getTableName());
			}
			if (extensionsDao.isTableExists()) {
				extensionsDao.deleteByExtension(EXTENSION_NAME);
			}
		} catch (SQLException e) {
			throw new GeoPackageException(
					"Failed to delete Contents Id extension and table. GeoPackage: "
							+ geoPackage.getName(), e);
		}
	}
592559
def unregister_namespace(self, namespace):
        
        if namespace not in self._namespaces:
            raise NoRegisteredError("Namespace '{0}' is not registered on loader.".format(namespace))

        del self._namespaces[namespace]
191842
public void registerExtension(ExtensionNamespaceSupport extNsSpt)
  {
    String namespace = extNsSpt.getNamespace();
    if (namespaceIndex(namespace, m_extensions) == -1)
    {
      m_extensions.add(extNsSpt);
      if (m_unregisteredExtensions.contains(namespace))
        m_unregisteredExtensions.remove(namespace);
    }
    
  }
151961
function (name, options) {
        var opts = options || {};
        ProcessService.execute(['bower uninstall', name, opts.options].join(' '), 'uninstall-' + name);
      }
1282460
public function unregisterExtension(common_ext_Extension $extension)
    {
        $extensions = $this->getExtensionById('generis')->getConfig(self::EXTENSIONS_CONFIG_KEY);
        unset($extensions[$extension->getId()]);
        $this->getExtensionById('generis')->setConfig(self::EXTENSIONS_CONFIG_KEY, $extensions);
    }
281454
@Override
    public InstalledExtension getInstalledExtension(String feature, String namespace)
    {
        InstalledFeature installedFeature = getInstalledFeatureFromCache(feature, namespace);

        if (installedFeature != null) {
            if (installedFeature.root.extension != null) {
                return installedFeature.root.extension;
            }

            return installedFeature.root.invalidExtensions.isEmpty() ? null
                : installedFeature.root.invalidExtensions.iterator().next();
        }

        return null;
    }
673761
public function uninstall($name, $delete = false, $unmigrate = true, $unseed = true, $unpublish = true)
    {
        // Check if installed
        if (!$this->installed($name)) {
            throw new Exceptions\HookNotInstalledException("Hook [{$name}] is not installed.");
        }

        $hook = $this->hook($name);

        $hook->loadJson();

        event(new Events\UninstallingHook($hook));

        if ($this->enabled($name)) {
            event(new Events\DisablingHook($hook));

            // Some logic could later be placed here

            event(new Events\DisabledHook($hook));
        }

        if ($unseed) {
            $this->unseedHook($hook);
        }

        if ($unmigrate) {
            $this->unmigrateHook($hook);
        }

        if ($unpublish) {
            $this->unpublishHook($hook);
        }

        $this->runComposer([
            'command'  => 'remove',
            'packages' => [$name],
        ]);

        $hooks = $this->hooks()->where('name', '!=', $name);
        $this->hooks = $hooks;

        $this->remakeJson();

        event(new Events\UninstalledHook($name));

        if ($delete && $hook->isLocal()) {
            $this->filesystem->deleteDirectory(base_path("hooks/{$name}"));
        }
    }
1142170
public final void nameSpace (String namespace) {
    if (namespace == null || namespace.equals("")) {
      _namespace = "";
    } else {
      _namespace = namespace + ":";
    }
  }
1171414
def remove_namespace(self, ns_uri):
        """"""
        if not self.contains_namespace(ns_uri):
            return

        ni = self.__ns_uri_map.pop(ns_uri)
        for prefix in ni.prefixes:
            del self.__prefix_map[prefix]
893848
protected boolean tryInstallExtension(ExtensionId extensionId, String namespace)
    {
        DefaultExtensionPlanTree currentTree = this.extensionTree.clone();

        try {
            installExtension(extensionId, namespace, currentTree);

            setExtensionTree(currentTree);

            return true;
        } catch (InstallException e) {
            if (getRequest().isVerbose()) {
                this.logger.info(FAILED_INSTALL_MESSAGE, extensionId, namespace, e);
            } else {
                this.logger.debug(FAILED_INSTALL_MESSAGE, extensionId, namespace, e);
            }
        }

        return false;
    }
1237206
private Set<String> uninstallInstalleeBundles(Set<String> installeeBundleLocationsToUninstall) {
        Set<String> unsuccessfulUninstallLocations = new HashSet<String>();
        for (String installeeBundleLocation : installeeBundleLocationsToUninstall) {
            Bundle installeeBundleToUninstall = ctx.getBundle(installeeBundleLocation);
            if (installeeBundleToUninstall != null) {
                try {
                    installeeBundleToUninstall.uninstall();
                } catch (BundleException e) {
                    //this will auto FFDC
                    //uninstall failed, track it
                    unsuccessfulUninstallLocations.add(installeeBundleLocation);
                    //we couldn't uninstall the bundle, but we want to stop it starting
                    //set the bundle start level to MAX_INT
                    BundleStartLevel bsl = installeeBundleToUninstall.adapt(BundleStartLevel.class);
                    bsl.setStartLevel(Integer.MAX_VALUE);
                }
            }
        }
        return unsuccessfulUninstallLocations;
    }