Removes the account params from persisted storage.
770832
private void removeAccountParams() {
        Editor editor = PreferenceManager.getDefaultSharedPreferences(mContext).edit();
        editor.remove(mContext.getString(R.string.wings_dropbox__account_name_key));
        editor.remove(mContext.getString(R.string.wings_dropbox__share_url_key));
        editor.remove(mContext.getString(R.string.wings_dropbox__access_token_key));

        // Set preference to unlinked.
        editor.putBoolean(mContext.getString(R.string.wings_dropbox__link_key), false);
        editor.apply();
    }
1277284
function cleanup() {

  var ds = application.dataStore;

  //delete the application's directory.  This will auto-delete any contained accounts and groups:
  ds.getResource(application.defaultAccountStoreMapping.href, function(err, mapping) {
    if (err) throw err;

    console.log('Retrieved application accountStoreMapping for deletion:');
    console.log(mapping);

    ds.deleteResource(mapping.accountStore, function(err) {
      if(err) throw err;

      console.log('Deleted application directory.');

      application.delete(function(err) {
        if (err) throw err;
        console.log('Deleted application.');
      });
    });
  });
}
447544
protected function clearParams()
    {
        $this->limit      = null;
        $this->limitStart = false;
        $this->limitEnd   = false;
        $this->where      = null;
        $this->orderBy    = null;
        $this->groupBy    = null;
        $this->in         = null;
        $this->params     = [];
        $this->joins      = [];
        $this->query      = '';
    }
45671
def clean(self, *args, **kwargs):
        """"""
        for key in list(self.store.keys()):
            self.unset(key)
741323
public void clearPersistedFiles(List<Long> persistedFiles) {
    synchronized (mLock) {
      for (long persistedId : persistedFiles) {
        mPersistedUfsFingerprints.remove(persistedId);
      }
    }
  }
42681
public static void removeCurrentAuthentication() {
        RequestContext context = RequestContext.getCurrent();
        if (context != null) {
            removeAuthentication(context.getRequest());
        }
    }
479276
public void removeAccount(Account accountToDelete) {
        // Thou shalt not delete root
        if (accountToDelete.getId().equals(rootAccount.getId()))
            return;

        Account parent = findParent(accountToDelete);
        if (parent != null) {
            removeAccount(parent, accountToDelete);
            setDirty(true);
        }
    }
418109
public void clear() {
        this.attributes.clear();
        this.queryParameters = null;
        this.inReader = null;
        this.streamActive = false;
        this.inStream = null;
        this.encoding = null;
        this.sessionData = null;
        this.strippedURI = null;
        this.srvContext = null;
        this.srvPath = null;
        this.pathInfo = null;
        this.pathInfoComputed = false;
        this.filters = null;
    }
88440
def delete(method, hmc, uri, uri_parms, logon_required):
        """"""
        try:
            resource = hmc.lookup_by_uri(uri)
        except KeyError:
            raise InvalidResourceError(method, uri)
        resource.manager.remove(resource.oid)
666108
def remove(self, parameters):
        

        # Verify that we already know our assigned subscription_id
        assert self.subscription_id != -1

        if not parameters:
            return

        options = web_pb2.ParameterSubscriptionRequest()
        options.subscriptionId = self.subscription_id
        options.id.extend(_build_named_object_ids(parameters))

        self._manager.send('unsubscribe', options)
642320
def clear(self):
        
        del self._statements_and_parameters[:]
        self.keyspace = None
        self.routing_key = None
        if self.custom_payload:
            self.custom_payload.clear()
941310
synchronized void removeCredential(String accountId) throws IOException {
        DataStore<StoredCredential> sc = StoredCredential.getDefaultDataStore(dataStoreFactory);
        sc.delete(accountId);
        calendarService = null;
        geoService = null;
    }
1026843
def param_remove(self, param: 'str') -> None:
        
        for attr in self._param_attr_dicts:
            if param in self.__dict__[attr]:
                self.__dict__[attr].pop(param)

        for attr in self._param_attr_lists:
            if param in self.__dict__[attr]:
                self.__dict__[attr].remove(param)
909894
protected function clearAcctDataFromStorage()
	{
		$this->session->remove( $this->getName() );

		if ( !is_null( $this->getRecaller() ) )
		{
			$recaller = $this->getRecallerName();
			$this->getCookieJar()->queue( $this->getCookieJar()->forget( $recaller ) );
		}
	}
1350564
protected function resetSubscriptionParams() {
        foreach($this->options as $op=>$junk){
            if(preg_match("#Subscription.#",$op)){
                unset($this->options[$op]);
            }
        }
    }
299848
public void clear() {
        documentsByEntity.clear();
        deletedEntities.clear();
        documentsById.clear();
        _knownMissingIds.clear();
        if (_countersByDocId != null) {
            _countersByDocId.clear();
        }
    }
445780
def _UnregisterDatastoreArtifacts(self):
    """"""
    to_remove = []
    for name, artifact in iteritems(self._artifacts):
      if artifact.loaded_from.startswith("datastore"):
        to_remove.append(name)
    for key in to_remove:
      self._artifacts.pop(key)