Invalidate the UI for all clients.
194451
def invalidate(self):
        "  "
        logger.info('Invalidating %s applications', len(self.apps))

        for app in self.apps:
            app.invalidate()
813428
@Scheduled(fixedRate = 60000) // run every minute
	public void invalidateOldTokens() {
		List<String> invalidTokens = new ArrayList<String>(); // tokens to invalidate
		for (Map.Entry<String, TokenContainer> entry : tokens.entrySet()) {
			if (!entry.getValue().isValid()) {
				invalidTokens.add(entry.getKey());
			}
		}
		for (String token : invalidTokens) {
			logout(token);
		}
	}
231741
public function invalidate()
    {
        if ($this->cache !== null) {
            TagDependency::invalidate($this->cache, self::CACHE_TAG);
        }
    }
682744
private function destroyClient(): void
    {
        ++$this->reconnects;
        $this->client = null;
        $delay = mt_rand(0, (int)min(5000, (int)pow(2, $this->reconnects) * 100));
        usleep($delay * 1000);
    }
1342206
def exit(self):
        """"""
        if self.client is not None:
            self.client.close()
        if self.context is not None:
            self.context.destroy()
315913
def invalidate(self):
        """"""
        with self._mesh_generator_lock:
            self._mesh_generator_pending = None
            self._mesh_generator = None
        self._dispatch_changed_callbacks()
48958
public function invalidate() {

		if ( ! \wp_using_ext_object_cache() ) {
			// Clean up old transients.
			foreach ( $this->get_keys_from_database() as $old_transient ) {
				$this->delete( $old_transient, true );
			}
		}

		// Update incrementor.
		$this->incrementor = time();
		$this->set( $this->incrementor_key, $this->incrementor, 0, true );
	}
585596
public void invalidate ()
  {
    if (m_bInvalidated)
      throw new IllegalArgumentException ("Servlet pool already invalidated!");
    m_bInvalidated = true;

    // Destroy all servlets
    for (final ServletItem aServletItem : m_aServlets)
      try
      {
        aServletItem.getServlet ().destroy ();
      }
      catch (final Exception ex)
      {
        if (LOGGER.isErrorEnabled ())
          LOGGER.error ("Failed to destroy servlet " + aServletItem, ex);
      }

    m_aServlets.clear ();
  }
674957
public void invalidate() {
        if (mInvalid.compareAndSet(false, true)) {
            for (InvalidatedCallback callback : mOnInvalidatedCallbacks) {
                callback.onInvalidated();
            }
        }
    }
207679
def invalidate_all(self):
        ''''''

        LOG.debug('clearing cache')
        appcache = str(self.get_app_cache())
        for dirpath, dirnames, filenames in os.walk(appcache):
            for name in filenames:
                try:
                    pathlib.Path(dirpath, name).unlink()
                except OSError:
                    pass
1138536
public void invalidate(@Nullable Uri uri) {
    if (uri != null) {
      cache.clearKeyUri(uri.toString());
    }
  }
836505
def uninitialize_ui(self):
        

        LOGGER.debug("> Uninitializing '{0}' Component ui.".format(self.__class__.__name__))

        self.__remove_actions()

        # Signals / Slots.
        self.__view.expanded.disconnect(self.__view__expanded)
        self.__view.doubleClicked.disconnect(self.__view__doubleClicked)
        self.__view.selectionModel().selectionChanged.disconnect(self.__view_selectionModel__selectionChanged)
        self.__script_editor.Script_Editor_tabWidget.currentChanged.disconnect(
            self.__script_editor_Script_Editor_tabWidget__currentChanged)
        self.__script_editor.model.project_registered.disconnect(self.__script_editor_model__project_registered)

        self.__view_remove_actions()

        self.__model = None
        self.__delegate = None
        self.__view = None

        self.initialized_ui = False
        return True
368452
private void invalidate(String message) {
        isValid = Boolean.FALSE;
        messages.append(message).append(' ');
    }
975989
void invalidate() {
        TransactionOLTP localTx = localOLTPTransactionContainer.get();
        if (localTx != null) {
            localTx.close(ErrorMessage.SESSION_CLOSED.getMessage(keyspace()));
            localOLTPTransactionContainer.set(null);
        }
        isClosed = true;
    }
940984
public static function clearStatus()
    {
        self::_initialize();

        $newState = new ReleaseCurrentState(self::$_clientId);

        self::$_lastState = $newState;

        self::$_runtimeClient->setCurrentState($newState);
    }
1301663
protected static void invalidateSwitchPoints() {
            if (LOG_ENABLED) {
                 LOG.info("invalidating switch point");
            }
        	SwitchPoint old = switchPoint;
            switchPoint = new SwitchPoint();
            synchronized(IndyInterface.class) { SwitchPoint.invalidateAll(new SwitchPoint[]{old}); }
        }
147506
@Invalidate
    public void stop() {
        for (ServiceRegistration<Template> reg : registrations.values()) {
            try {
                reg.unregister();
            } catch (Exception e) { //NOSONAR
                // Ignore it.
            }
        }
        registrations.clear();
    }