of the unbound provider (
2204
public synchronized T get(Scope scope) {
    if (instance != null) {
      return instance;
    }

    if (providerInstance != null) {
      if (isProvidingSingletonInScope) {
        instance = providerInstance.get();
        //gc
        providerInstance = null;
        return instance;
      }

      return providerInstance.get();
    }

    if (factoryClass != null && factory == null) {
      factory = FactoryLocator.getFactory(factoryClass);
      //gc
      factoryClass = null;
    }

    if (factory != null) {
      if (!factory.hasScopeAnnotation() && !isCreatingSingletonInScope) {
        return factory.createInstance(scope);
      }
      instance = factory.createInstance(scope);
      //gc
      factory = null;
      return instance;
    }

    if (providerFactoryClass != null && providerFactory == null) {
      providerFactory = FactoryLocator.getFactory(providerFactoryClass);
      //gc
      providerFactoryClass = null;
    }

    if (providerFactory != null) {
      if (providerFactory.hasProvidesSingletonInScopeAnnotation() || isProvidingSingletonInScope) {
        instance = providerFactory.createInstance(scope).get();
        //gc
        providerFactory = null;
        return instance;
      }
      if (providerFactory.hasScopeAnnotation() || isCreatingSingletonInScope) {
        providerInstance = providerFactory.createInstance(scope);
        //gc
        providerFactory = null;
        return providerInstance.get();
      }

      return providerFactory.createInstance(scope).get();
    }

    throw new IllegalStateException("A provider can only be used with an instance, a provider, a factory or a provider factory. Should not happen.");
  }
208615
function(callback) {

  if (isProviderUp) {

    // All is good!
    return Promise.resolve()
    .nodeify(callback);

  } else {

    // Query for provider's up status.
    return providerInstance().call('isUp')
    // Update cache and turn on provider if needed
    .then(function(isUp) {
      isProviderUp = isUp;
      if (!isProviderUp) {
        // Try to turn it on!
        return up()
        // Turn promise resolution
        .then(function() {
          return Promise.resolve();
        });
      }
    })
    // Return.
    .nodeify(callback);

  }

}
102884
public void valueUnbound(HttpSessionBindingEvent event) {
		String sessionId = event.getSession().getId();
		Debug.logVerbose("[JdonFramework] unvalueBound active, sessionId :" + sessionId, module);
		Debug.logVerbose("[JdonFramework] unvalueUnbound active, componentsboxs size" + componentsboxsInSession.size(), module);
		// removeObjects();
		componentsboxsInSession.clear();
		if (targetMetaRequestsHolder != null)
			targetMetaRequestsHolder.clear();
		targetMetaRequestsHolder = null;
		componentVisitor = null;
	}
398782
function withNonceTracker(provider) {
  const nonceTracker = new NonceTrackerSubprovider()
  provider.engine._providers.unshift(nonceTracker)
  nonceTracker.setEngine(provider.engine)
  return provider
}
404967
public function unbind()
    {
        if ($this->isBinded()) {
            $this->getSocket()->unbind($this->dsn);
            $this->dsn = null;
        }

        return $this;
    }
29796
def provider(position)
      content_providers.find_by(position: position) ||
        ContentProviders::Null.new(self, position)
    end
1328056
function(provider) {
      if (!this.isCurrent()) {
        return;
      }
      if (_.isString(provider)) {
        provider = Parse.User._authProviders[provider];
      }
      if (provider && provider.deauthenticate) {
        provider.deauthenticate();
      }
    }
1081006
@Override
	public void unregisterOsgiProviders (Collection<Object> providers) throws FhirConfigurationException {
		if (null == providers) {
			throw new NullPointerException("FHIR Provider list cannot be null");
		}
		try {
			for (Object provider : providers) {
				log.trace("unregistered provider. class ["+provider.getClass().getName()+"]");
				this.serverProviders.remove(provider);
			}
			super.unregisterProvider(providers);
		} catch (Exception e) {
			log.error("Error unregistering FHIR Providers", e);
			throw new FhirConfigurationException("Error unregistering FHIR Providers", e);
		}
	}
1156931
def unblocked(origin, square_set)
      select { |destination| square_set.between(origin, destination).all?(&:unoccupied?) }
    end
436114
def get_provider(self, provider_name='default'):
        """"""
        try:
            if self._providers is None:
                self._providers = self._initialize_providers()
            return self._providers[provider_name]
        except KeyError:
            raise AssertionError(f'No Provider registered with name {provider_name}')
690984
def get(self, identifier):
        """"""
        for provider in self._providers:
            if provider.identifier == identifier:
                return provider
        return None
385851
public function bind()
    {
        if ($this->providersLoaded) {
            return $this;
        }

        $this->providers = new ProvidersCollection($this->providersRepository->all());

        foreach ($this->providerGateways as & $providerGateway) {
            $providers = $this->providers->filterByGatewayName($providerGateway->getName());

            foreach ($providers as & $provider) {
                $provider->setProviderGateway($providerGateway);
            }
        }

        $this->providersLoaded = true;

        return $this;
    }
1240428
def get_provider(self, provider):
        """"""
        if self.provider is not None:
            return self.provider
        return providers.by_id(provider)
885757
function() {
      if (!this._unbound) {
        log.unbind && console.log('[%s] asyncUnbindAll', this.localName);
        this._unbindAllJob = this.job(this._unbindAllJob, this.unbindAll, 0);
      }
    }
1056995
def get_default_config(self):
        
        config = super(UnboundCollector, self).get_default_config()
        config.update({
            'path':         'unbound',
            'bin':          self.find_binary('/usr/sbin/unbound-control'),
            'histogram':    True,
        })
        return config
105542
@Override
  public <T, U> BindingBuilder<T> provider(Key<U> parent, Method m)
  {
    throw new UnsupportedOperationException(getClass().getName());
  }
727618
@NotNull
    @ObjectiveCName("unblockUser:")
    public Promise<Void> unblockUser(int uid) {
        return modules.getUsersModule().unblockUser(uid);
    }