Remove a provider
@param provider The provider
978822
public void removeProvider(UserTransactionProvider provider)
   {
      UserTransactionProviderImpl impl = providers.get(provider);

      if (impl != null)
      {
         delegator.removeProvider(impl);
         providers.remove(provider);
      }
   }
1160378
def clear_provider(self):
        
        if (self.get_provider_metadata().is_read_only() or
                self.get_provider_metadata().is_required()):
            raise errors.NoAccess()
        self._my_map['providerId'] = self._provider_default
372319
public static void remove(ServiceController<?> controller) {
        try {
            transition(controller, State.REMOVED);
        } catch (StartException e) {
            // This can't happen
            throw new IllegalStateException(e);
        }
    }
535374
public final void remove(ObservableDoubleValue dependency) {
        requireNonNull(dependency, "Parameter 'dependency' is null");

        if (dependencies.contains(dependency)) {

            dependencies.remove(dependency);
            unbind(dependency);
            invalidate();

        } else {
            LOGGER.warn("Dependency not included: " + dependency + ", Skipping.");
        }
    }
1157238
public static void removeAllProviders() {
        Provider[] provider_list = Security.getProviders();

        for (int i = 0; i < provider_list.length; i++) {
            if (provider_list[i] != null) {
                String name = provider_list[i].getName();
                if (name != null) {
                    Security.removeProvider(name);
                }
            }
        }
    }
1267893
protected void unsetContextProvider(ServiceReference<JCAContextProvider> ref) {
        contextProviders.removeReference((String) ref.getProperty(JCAContextProvider.TYPE), ref);
    }
826900
@Override
    public final void remove(final V entity) {
        final SqlParameterSource parameterSource; // Parameters source

        parameterSource = new BeanPropertySqlParameterSource(entity);

        getTemplate().update(getDeleteQueryTemplate(), parameterSource);
    }
230396
public void unsetUserConfigurations(UserConfigurationsProvider provider) {
		if (userConfigurations.isPresent() && userConfigurations.get().equals(provider)) {
			this.userConfigurations = Optional.empty();
		}
	}
280145
public static void removeConnectionData(String providerId, String providerUserId, Profile profile) {
        Map<String, List<Map<String, Object>>> allConnections = profile.getAttribute(CONNECTIONS_ATTRIBUTE_NAME);

        if (MapUtils.isNotEmpty(allConnections)) {
            List<Map<String, Object>> connectionsForProvider = allConnections.get(providerId);

            if (CollectionUtils.isNotEmpty(connectionsForProvider)) {
                for (Iterator<Map<String, Object>> iter = connectionsForProvider.iterator(); iter.hasNext();) {
                    Map<String, Object> connectionDataMap = iter.next();

                    if (providerUserId.equals(connectionDataMap.get("providerUserId"))) {
                        iter.remove();
                    }
                }
            }
        }
    }
278754
public void setProviders(Map<String, IPermissionTargetProvider> providers) {
        this.providers.clear();
        for (Map.Entry<String, IPermissionTargetProvider> provider : providers.entrySet()) {
            this.providers.put(provider.getKey(), provider.getValue());
        }
    }
555070
public void setProvider(String provider)
    {
        if (provider != null && provider.endsWith(".class"))
        {
            this.provider = provider.substring(0, provider.length() - 6);
        }
        this.provider = provider;
    }
961510
public static void removeJ2CIdentityService(J2CIdentityService j2cIdentityService) {
        if (j2cIdentityService != null) {
            j2cIdentityServices.remove(j2cIdentityService);
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "A J2CIdentityService implementation was removed.", j2cIdentityService.getClass().getName());
            }
        }
    }
183303
public void unregisterProviders(Collection<?> providers) {
		ProvidedResourceScanner providedResourceScanner = new ProvidedResourceScanner(getFhirContext());
		if (providers != null) {
			for (Object provider : providers) {
				removeResourceMethods(provider);
				if (provider instanceof IResourceProvider) {
					myResourceProviders.remove(provider);
					IResourceProvider rsrcProvider = (IResourceProvider) provider;
					Class<? extends IBaseResource> resourceType = rsrcProvider.getResourceType();
					providedResourceScanner.removeProvidedResources(rsrcProvider);
				} else {
					myPlainProviders.remove(provider);
				}
				invokeDestroy(provider);
			}
		}
	}
782241
function(provider) {
      if (!this.isCurrent()) {
        return;
      }
      var authType;
      if (_.isString(provider)) {
        authType = provider;
        provider = Parse.User._authProviders[authType];
      } else {
        authType = provider.getAuthType();
      }
      var authData = this.get('authData');
      if (!authData || !provider) {
        return;
      }
      var success = provider.restoreAuthentication(authData[authType]);
      if (!success) {
        this._unlinkFrom(provider);
      }
    }
71979
public void removeResultCollector(ResultCollector<?, DPO> resultCollector) {
        if (resultCollector != null) {
            removeTrigger(resultCollector);
            removeDataProvider(resultCollector);
        }
    }
631672
public function setProvider( $provider )
	{
		if ( $provider == $this->getProvider() ) { return; }

		$this->_values['provider'] = (string) $provider;
		$this->setModified();
	}
490368
def delete(self, name, provider='AwsEKS'):
        
        # if self.check_cluster_exists(name) is False:
        #     raise JhubctlError("Cluster name not found in availabe clusters.")

        # Create cluster object
        Cluster = getattr(providers, provider)
        cluster = Cluster(name)
        cluster.delete()

        # Remove from kubeconf
        self.kubeconf.open()
        self.kubeconf.remove_context(name)
        self.kubeconf.remove_user(name)
        self.kubeconf.remove_cluster(cluster.cluster_name)
        self.kubeconf.close()