Process this action.
@param strAction The command to execute.
@return True if handled.
6331
public boolean doAction(String strAction, int iOptions)
    {
        if (Constants.BACK.equalsIgnoreCase(strAction))
        {
            String strPrevAction = this.getBaseApplet().popHistory(1, true);   // Current screen
            strAction = getBaseApplet().popHistory(1, true);   // Last screen
            if (strAction != null)
            {
                if (!Constants.BACK.equalsIgnoreCase(strAction)) // Never (prevent endless recursion)
                    return this.handleAction(strAction, this, iOptions);
            }
            else if (strPrevAction != null)
                this.getBaseApplet().pushHistory(strPrevAction, ((iOptions & Constants.DONT_PUSH_TO_BROWSER) == Constants.PUSH_TO_BROWSER));    // If top of stack, leave it alone.
        }
        else
        { // The only other actions are URLS, so change the page.
            URL url = null;
            try {
            	url = new URL(strAction);
            } catch (MalformedURLException e) {
            	url = JHtmlView.getURLFromPath(strAction, this.getBaseApplet());
            }
            if (url != null)
            	m_editorPane.linkActivated(url, this.getBaseApplet(), 0);
        }
        return true;    // Handled
    }
493495
@Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        if (CollectionUtils.isNotEmpty(annotations)) {
            Set<? extends Element> elements = roundEnv.getElementsAnnotatedWith(Interceptor.class);
            try {
                parseInterceptors(elements);
            } catch (Exception e) {
                logger.error(e);
            }
            return true;
        }

        return false;
    }
14149
private void processCommand(List<String> command) throws Exception {
        processBuilder.command(command);
        Process p = processBuilder.start();
        checkReturnCode(p, processBuilder.command().toString(), 0);
    }
709394
public boolean onClone()
    {
        String strLastCommand = this.getScreenURL();
        if ((strLastCommand == null) || (strLastCommand.length() == 0))
            return false; // Can't process this
        else
            this.handleCommand(strLastCommand, this, ScreenConstants.USE_NEW_WINDOW | ScreenConstants.DONT_PUSH_TO_BROWSER);        // Process the last command in a new window
        return true;    // Handled
    }
437615
public void step() throws IOException {
        if (closed) {
            throw new ClosedChannelException();
        }
        if (input.position() == header.length) {
            if (command == null) {
                command = CommandFactory.create(input);
            }

            if (command.complete()) {
                command.process();
                protocolHandler.execute(command, this);
                command = null;
                input.rewind();
            }
        }
    }
62787
@Override
	public void process(Packet message, MessageContext ctx)
	{
		Container c = ctx.getServerHandler().player.openContainer;
		if (message.windowId != c.windowId || !(c instanceof MalisisInventoryContainer))
			return;

		MalisisInventoryContainer container = (MalisisInventoryContainer) c;
		container.handleAction(message.action, message.inventoryId, message.slotNumber, message.code);
		container.detectAndSendChanges();
	}
847709
function (handle) {
        var pos = this.eventStreamListeners.indexOf(handle);
        if (pos === -1) {
            return false;
        }
        this.eventStreamListeners.splice(this.eventStreamListeners.indexOf(handle), 1);
        return true;
    }
1359430
@SuppressWarnings("unchecked")
    @Override
    public Boolean execute() {
        User sfsSender = CommandUtil.getSfsUser(sender, api);
        User sfsRecipient = CommandUtil.getSfsUser(recipient, api);
        if(sfsSender == null || sfsRecipient == null)
            return Boolean.FALSE;
        message = (message == null) ? "" : message;
        ISFSObject sfsParams = null;
        if(params != null) {
            MessageParamsClass clazz = context.getMessageParamsClass(params.getClass());
            if(clazz != null) 
                sfsParams = new ResponseParamSerializer().object2params(clazz.getUnwrapper(), params);
        }
        if(sfsParams == null) sfsParams = new SFSObject();
        try {
            api.sendBuddyMessage(sfsSender, sfsRecipient, message, sfsParams);
        } catch (SFSBuddyListException e) {
            throw new IllegalStateException(e);
        }
        return Boolean.TRUE;
    }
375651
public void receive(byte[] byteArray) throws IOException {
		//register the current application for this thread
		// in case a subsystem logs to the environment
		if (interpreter.isInSubProcessMode()) {
			if (!abortSubprocessModeIfNecessary(byteArray)) {
				/*			case CTRLC:
				   interpreter.abortSubprocessMode();
				   break;*/
				if (echoEnabled) {
					echoBytesToClient(byteArray);
				}
				//every byte is forwarded because the subprocess will interprete the input
				interpreter.processRawInput(byteArray);
			}
		} else {
			processInput(byteArray);
		}
	}
892830
public boolean process(ElementListener listener) {
        try {
            Chunk chunk;
            Iterator i = getChunks().iterator();
            boolean localDestination = (reference != null && reference.startsWith("#"));
            boolean notGotoOK = true;
            while (i.hasNext()) {
                chunk = (Chunk) i.next();
                if (name != null && notGotoOK && !chunk.isEmpty()) {
                    chunk.setLocalDestination(name);
                    notGotoOK = false;
                }
                if (localDestination) {
                    chunk.setLocalGoto(reference.substring(1));
                }
                listener.add(chunk);
            }
            return true;
        }
        catch(DocumentException de) {
            return false;
        }
    }
240034
public boolean doAction(String strAction, int iOptions)
    {
        if (SEND.equalsIgnoreCase(strAction))
        {
            String strMessage = m_tfTextIn.getText();
            m_tfTextIn.setText(Constants.BLANK);

            Map<String,Object> properties = new Hashtable<String,Object>();
            properties.put(MESSAGE_PARAM, strMessage);
            BaseMessage message = new MapMessage(new BaseMessageHeader(CHAT_TYPE, MessageConstants.INTRANET_QUEUE, null, null), properties);
            this.getBaseApplet().getApplication().getMessageManager().sendMessage(message);
            return true;
        }
        return super.doAction(strAction, iOptions);
    }
541596
@Override
    public boolean process( Namespace ns ) {

        Chainr chainr;
        try {
            chainr = ChainrFactory.fromFile((File) ns.get("spec"));
        } catch ( Exception e ) {
            JoltCliUtilities.printToStandardOut( "Chainr failed to load spec file.", SUPPRESS_OUTPUT );
            e.printStackTrace( System.out );
            return false;
        }

        File file = ns.get( "input" );
        Object input = JoltCliUtilities.readJsonInput( file, SUPPRESS_OUTPUT );

        Object output;
        try {
            output = chainr.transform( input );
        } catch ( Exception e ) {
            JoltCliUtilities.printToStandardOut( "Chainr failed to run spec file.", SUPPRESS_OUTPUT );
            return false;
        }

        Boolean uglyPrint = ns.getBoolean( "u" );
        return JoltCliUtilities.printJsonObject( output, uglyPrint, SUPPRESS_OUTPUT );
    }
805149
@Override
  public void process(Node externsRoot, Node jsRoot) {
    checkNotNull(scopeCreator);
    checkNotNull(topScope);

    Node externsAndJs = jsRoot.getParent();
    checkState(externsAndJs != null);
    checkState(externsRoot == null || externsAndJs.hasChild(externsRoot));

    if (externsRoot != null) {
      check(externsRoot, true);
    }
    check(jsRoot, false);
  }
984784
public void doForward(String command)
	{
		if (command != null)
			if (command.startsWith("#"))
				command = command.substring(1);
		Util.getLogger().info("Browser forward: java browser command=" + command + " = target: " + this.cleanCommand(command));
 		BaseApplet.handleAction(this.cleanCommand(command), this, this, Constants.DONT_PUSH_TO_BROWSER);
	}
968358
@Override
    public boolean handle(Exception e, @Nonnull Run<?, ?> run, @Nonnull TaskListener listener) {
        Result toSet = Result.fromString(trimToEmpty(result));

        listener.error("[GitHub Commit Status Setter] - %s, setting build result to %s", e.getMessage(), toSet);

        run.setResult(toSet);
        return true;
    }
926015
private void performHandle(final Wave wave, final Method method) throws WaveException {

        // Build parameter list of the searched method
        final List<Object> parameterValues = new ArrayList<>();

        // Don't add WaveType parameters if we us the default processWave method
        if (!AbstractComponent.PROCESS_WAVE_METHOD_NAME.equals(method.getName())) {
            for (final WaveData<?> wd : wave.waveDatas()) {
                // Add only wave items defined as parameter
                if (wd.key().isParameter()) {
                    parameterValues.add(wd.value());
                }
            }
        }

        // Add the current wave to process
        parameterValues.add(wave);

        try {

            ClassUtility.callMethod(method, getWaveReady(), parameterValues.toArray());

        } catch (final CoreException e) {
            LOGGER.error(WAVE_DISPATCH_ERROR, e);
            // Propagate the wave exception
            throw new WaveException(wave, e);
        }

    }
427083
public function run()
    {
        stream_set_blocking(STDIN,0);

        $r = array(STDIN);
        $w = array();
        $e = array();

        $n = @stream_select($r,$w,$e,1);

        if ($n && in_array(STDIN, $r)) {
            $this->readline();
        }

        return true;
    }