Uninstall provided extension.

@param feature the feature to uninstall
@param namespace the namespace
@see #uninstallExtension(LocalExtension, String)
770670
private void removeInstalledFeature(String feature, String namespace)
    {
        // Extensions namespaces by feature

        if (namespace == null) {
            this.extensionNamespaceByFeature.remove(feature);
        } else {
            Map<String, InstalledFeature> namespaceInstalledExtension = this.extensionNamespaceByFeature.get(feature);

            namespaceInstalledExtension.remove(namespace);
        }
    }
257411
public static void removeLocalBundle(String name, Version version, boolean removePhysical, boolean doubleTap) throws BundleException {
	name = name.trim();
	CFMLEngine engine = CFMLEngineFactory.getInstance();
	CFMLEngineFactory factory = engine.getCFMLEngineFactory();

	BundleFile bf = _getBundleFile(factory, name, version, null);
	if (bf != null) {
	    BundleDefinition bd = bf.toBundleDefinition();
	    if (bd != null) {
		Bundle b = bd.getLocalBundle();
		if (b != null) {
		    stopIfNecessary(b);
		    b.uninstall();
		}
	    }
	}

	if (!removePhysical) return;

	// remove file
	if (bf != null) {
	    if (!bf.getFile().delete() && doubleTap) bf.getFile().deleteOnExit();
	}
    }
1142429
public void unpersist(String namespace, String name) throws DDFException {
    this.getDummyDDF().getPersistenceHandler().unpersist(namespace, name);
  }
1025609
public void unregisterPropertyExclusion( Class target, String propertyName ) {
      if( target != null && propertyName != null ) {
         Set set = (Set) exclusionMap.get( target );
         if( set == null ) {
            set = new HashSet();
            exclusionMap.put( target, set );
         }
         set.remove( propertyName );
      }
   }
379233
function(feature) {
        delete this.features[feature.fid || feature.id];
        this.events.triggerEvent("featureunselected", {feature: feature});
    }
68817
@Transactional
  public void deleteNamespace(String namespace) {
    List<L10nString> namespaceEntities = getL10nStrings(namespace);
    dataService.delete(L10N_STRING, namespaceEntities.stream());
  }
252660
private Set<InstalledExtension> getReplacedInstalledExtensions(Extension extension, String namespace)
        throws IncompatibleVersionConstraintException, ResolveException, InstallException
    {
        // If a namespace extension already exist on root, fail the install
        if (namespace != null) {
            checkRootExtension(extension.getId().getId());
        }

        Set<InstalledExtension> previousExtensions = new LinkedHashSet<>();

        Set<InstalledExtension> installedExtensions = getInstalledExtensions(extension.getId().getId(), namespace);

        VersionConstraint versionConstraint =
            checkReplacedInstalledExtensions(installedExtensions, extension.getId(), namespace, null);
        previousExtensions.addAll(installedExtensions);

        for (ExtensionId feature : extension.getExtensionFeatures()) {
            // If a namespace extension already exist on root, fail the install
            if (namespace != null) {
                checkRootExtension(feature.getId());
            }

            installedExtensions = getInstalledExtensions(feature.getId(), namespace);
            versionConstraint =
                checkReplacedInstalledExtensions(installedExtensions, feature, namespace, versionConstraint);
            previousExtensions.addAll(installedExtensions);
        }

        // If the extensions is already installed (usually mean we are trying to repair an invalid extension) it's not
        // going to replace itself
        if (extension instanceof InstalledExtension) {
            previousExtensions.remove(extension);
        }

        return previousExtensions;
    }
250059
@Override
  public void close(String namespace)
  {
    if (config.isEvictOnClose()) {
      cache.asMap().keySet().removeIf(key -> key.namespace.equals(namespace));
    }
  }
995330
public void removeExtension() {

		if (geoPackage.isTable(MetadataReference.TABLE_NAME)) {
			geoPackage.dropTable(MetadataReference.TABLE_NAME);
		}

		if (geoPackage.isTable(Metadata.TABLE_NAME)) {
			geoPackage.dropTable(Metadata.TABLE_NAME);
		}

		try {
			if (extensionsDao.isTableExists()) {
				extensionsDao.deleteByExtension(EXTENSION_NAME);
			}
		} catch (SQLException e) {
			throw new GeoPackageException(
					"Failed to delete Metadata extension. GeoPackage: "
							+ geoPackage.getName(), e);
		}

	}
668123
private void unregisterMBeanInService(String name) {
        ServiceRegistration<DynamicMBean> existingMBean = endpointMBeans.remove(name);
        if (existingMBean != null) {
            existingMBean.unregister();
        }
    }
244519
public static void unregister(ApiFeature apiFeature) {
        JavaScriptObject scriptObject = features.get(apiFeature);
        if (scriptObject != null) {
            if (scriptObject.cast() instanceof Element) {
                Element scriptElement = scriptObject.cast();
                scriptElement.removeFromParent();
            }
        }
        features.remove(apiFeature);
    }
514660
private void unregisterNamespace(String prefix, boolean persist) throws NamespaceException, RepositoryException
   {
      if (namespaces.get(prefix) == null)
      {
         throw new NamespaceException("Prefix " + prefix + " is not registered");
      }

      if (PROTECTED_NAMESPACES.contains(prefix))
      {
         throw new NamespaceException("Prefix " + prefix + " is protected");
      }
      String uri = getURI(prefix);
      if (indexSearcherHolder != null)
      {
         final Set<String> nodes = indexSearcherHolder.getNodesByUri(uri);
         if (nodes.size() > 0)
         {
            StringBuilder builder = new StringBuilder();
            builder.append("Fail to unregister namespace '");
            builder.append(prefix);
            builder.append("' because of following nodes:  ");

            for (String uuid : nodes)
            {
               ItemData item = dataManager.getItemData(uuid);
               if (item != null && item.isNode())
               {
                  builder.append(" - ");
                  builder.append(item.getQPath().getAsString());
                  builder.append("\r\n");
               }
            }
            builder.append(" uses this prefix.");
            throw new NamespaceException(builder.toString());
         }
      }
      prefixes.remove(uri);
      namespaces.remove(prefix);
      if (persister != null && persist)
      {
         persister.removeNamespace(prefix);
      }
   }
719130
public void removeFeature(FeatureInterface<AbstractSequence<C>, C> feature) {
		features.remove(feature);
		ArrayList<FeatureInterface<AbstractSequence<C>, C>> featureList = groupedFeatures.get(feature.getType());
		if (featureList != null) {
			featureList.remove(feature);
			if (featureList.isEmpty()) {
				groupedFeatures.remove(feature.getType());
			}
		}
	}
578732
public void deleteNamespace(String namespaceId) {

        DeleteNamespaceRequest deleteNamespaceRequest = new DeleteNamespaceRequest().withId(namespaceId);
        getDiscoveryClient().deleteNamespace(deleteNamespaceRequest);

    }
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]
374118
public void removeExtension() {

		deleteRelationships();

		geoPackage.deleteTable(StyleTable.TABLE_NAME);

		geoPackage.deleteTable(IconTable.TABLE_NAME);

		try {
			if (extensionsDao.isTableExists()) {
				extensionsDao.deleteByExtension(EXTENSION_NAME);
			}
		} catch (SQLException e) {
			throw new GeoPackageException(
					"Failed to delete Feature Style extension. GeoPackage: "
							+ geoPackage.getName(), e);
		}

	}
136853
@Override
    public void removeEndPoint(String name) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "Deleting endpoint: " + name);
        }

        synchronized (this.endpoints) {
            if (this.endpoints.remove(name) != null) {
                unregisterMBeanInService(name);
            }
        }
    }