Disable all endpoints, except the ones in error.

@throws InputException
769433
private function disableAll()
    {
        // set all non-error endpoints to disabled
        $this->getEndpoints()->map(function (Endpoint $endpoint) {
            if ($endpoint->isError() === false) {
                $endpoint->setStatus(Endpoint::STATUS_DISABLED);
            }
        });
    }
252300
public void resetComponents() {
        nameTextField.clear();
        nameTextField.removeStyleName(SPUIStyleDefinitions.SP_TEXTFIELD_ERROR);
        controllerIDTextField.setEnabled(Boolean.TRUE);
        controllerIDTextField.removeStyleName(SPUIStyleDefinitions.SP_TEXTFIELD_ERROR);
        controllerIDTextField.clear();
        descTextArea.clear();
        editTarget = Boolean.FALSE;
    }
636188
public void resetInputs(String... expressions) {
        if (expressions == null || expressions.length == 0) {
            return;
        }

        resetInputs(Arrays.asList(expressions));
    }
668568
public void setEndpoint(String endpoint) {
        this.endpoint = endpoint;

        if (bugsnag != null) {
            bugsnag.setEndpoints(endpoint, null);
        }
    }
883501
public void setEndpoints(java.util.Collection<Endpoint> endpoints) {
        if (endpoints == null) {
            this.endpoints = null;
            return;
        }

        this.endpoints = new java.util.ArrayList<Endpoint>(endpoints);
    }
819134
public function shutdownInput()
    {
        if (@socket_shutdown($this->socket, 0) === false) {
            $this->throwSocketError();
        }
        $this->in = null;
    }
1200369
private void stopIn() throws IOException {
    if (inClosed) {
      return;
    }
    inClosed = true;

    LOG.log(Level.FINE, "Shutting down socket for input");

    // unblock all waiting readers
    setEof();

    // signal orchestrator thread it is ok to quit now as there will be no more input
    synchronized (orchestratorEvent) {
      shutdown = true;
      orchestratorEvent.notifyAll();
    }

    // close socket for input - that will cause readExecutor to throw EOFException
    // and exit orchestrator thread main loop; client can still write to the socket
    socket.shutdownInput();
  }
1269231
public void stop() {
        if (!Utils.isNullOrEmpty(context.getSettings().getExportFile())) {
            if (Utils.isNullOrEmpty(context.getSettings().getExportFilter())) {
                JAXB.marshal(export, new File(context.getSettings().getExportFile()));
            } else {
                Symbols exportFiltered = new Symbols();
                Pattern regexp = Pattern.compile(context.getSettings().getExportFilter());
                for (String symbol : export.getSymbols()) {
                    if (regexp.matcher(symbol).matches()) {
                        exportFiltered.getSymbols().add(symbol);
                    }
                }
                JAXB.marshal(exportFiltered, new File(context.getSettings().getExportFile()));
            }
        }
        if (context.getSettings().isClean()) {
            for (File file : oldFiles) {
                logInfo("deleting " + file.getName());
                if (!file.delete()) {
                    logInfo("failed");
                }
                ++deleted;
            }
        }
        try {
            final BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(java4cppHash));
            newHashes.store(out, "Generated by java4cpp");
            out.close();
        } catch (IOException e) {
            throw new RuntimeException("Failed to generate java4cpp.hash " + e.getMessage());
        }
        logInfo(String.format("generated: %d, imported: %d, skipped: %d, deleted: %d", generated, imported, skipped, deleted));
    }
1302385
function( enabled ) {
		var handlers, type,
			method = enabled ? "enable" : "disable";

		this._enabled = enabled;
		for ( var i = 0; i < this.inputHandlers.length; i++ ) {
			handlers = this.inputHandlers[ i ];
			if ( handlers )  {
				for ( type in handlers ) {
					handlers[ type ][ method ]();
				}
			}
		}
	}
1149412
private void stop() {
        finish(inputThread);

        try {
            err.flush();
        } catch (IOException e) {
            // ignore
        }
        try {
            out.flush();
        } catch (IOException e) {
            // ignore
        }
        finish(outputThread);
        finish(errorThread);
    }
792206
public function disable()
    {
        $this->assertIsDebugMode();

	    $extId = $this->getRequestParameter('id');
        $this->getExtensionManager()->setEnabled($extId, false);
	    MenuService::flushCache();
        $this->returnJson(array(
	        'success' => true,
	        'message' => __('Disabled %s', $this->getRequestParameter('id'))
	    ));
	}
175496
private void stop(RpcEndpointTerminationResult rpcEndpointTerminationResult) {
		if (rpcEndpointStopped.compareAndSet(false, true)) {
			this.rpcEndpointTerminationResult = rpcEndpointTerminationResult;
			getContext().stop(getSelf());
		}
	}
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);
            }
        }
    }
1065634
private void closeInputGates() throws IOException, InterruptedException {
		for (int i = 0; i < this.inputGates.size(); i++) {
			final InputGate<? extends IOReadableWritable> eig = this.inputGates.get(i);
			// Important: close must be called on each input gate exactly once
			eig.close();
		}

	}
337852
private Collection<String> processAllowedEndpoints(Collection<String> endpointIds) {
        if (endpointIds == null || endpointIds.isEmpty())
            return null;

        return endpointIds;
    }
7326
protected void closeInputs() throws IOException{
        while(true){
            if(in instanceof Transport)
                return;
            in.close();
            in = in.detachInput();
        }
    }
978649
void cancelAllSuperToasts() {
        removeMessages(Messages.SHOW_NEXT);
        removeMessages(Messages.DISPLAY_SUPERTOAST);
        removeMessages(Messages.REMOVE_SUPERTOAST);

        // Iterate through the Queue, polling and removing everything
        for (SuperToast superToast : superToastPriorityQueue) {
            if (superToast instanceof SuperActivityToast) {
                if (superToast.isShowing()) {
                    try{
                        ((SuperActivityToast) superToast).getViewGroup().removeView(superToast.getView());
                        ((SuperActivityToast) superToast).getViewGroup().invalidate();
                    } catch (NullPointerException|IllegalStateException exception) {
                        Log.e(getClass().getName(), exception.toString());
                    }
                }
            } else {
                final WindowManager windowManager = (WindowManager) superToast.getContext()
                        .getApplicationContext().getSystemService(Context.WINDOW_SERVICE);
                if (superToast.isShowing()) {
                    try{
                        windowManager.removeView(superToast.getView());
                    } catch (NullPointerException|IllegalArgumentException exception) {
                        Log.e(getClass().getName(), exception.toString());
                    }
                }
            }
        }
        superToastPriorityQueue.clear();
    }