Process this action.
Override this for functionality.
@param strAction The action command or message.
@param iOptions options
@return true if handled.
556158
public boolean doAction(String strAction, int iOptions)
    {
        if (Constants.CLOSE.equalsIgnoreCase(strAction))
        {
            Frame frame = ScreenUtil.getFrame(this);
            if (frame != null)
                ((JBaseFrame)frame).free();
            return true;
        }
        else if (ThinMenuConstants.PRINT.equalsIgnoreCase(strAction))
        {
            return ScreenPrinter.onPrint(this);
        }
        else if (ThinMenuConstants.ABOUT.equalsIgnoreCase(strAction))
        {
            return this.getBaseApplet().onAbout();
        }
        else if (ThinMenuConstants.LOGON.equalsIgnoreCase(strAction))
        {
            int iErrorCode = this.getBaseApplet().onLogonDialog();
            if (iErrorCode == JOptionPane.CANCEL_OPTION)
                return true;    // User clicked the cancel button
            if (iErrorCode == Constants.NORMAL_RETURN)
                return true;    // Success
            // Display the error message and return!
            String strDisplay = this.getBaseApplet().getLastError(iErrorCode);
            JOptionPane.showConfirmDialog(this, strDisplay, "Error", JOptionPane.OK_CANCEL_OPTION);
            return true;   // Handled
        }
        else if (ThinMenuConstants.LOGOUT.equalsIgnoreCase(strAction))
        {
            int iErrorCode = this.getBaseApplet().getApplication().login(this.getBaseApplet(), null, null, null); // Logout
            if (iErrorCode == Constants.NORMAL_RETURN)
                return true;    // Success, handled
            // Display the error message and return!
            String strDisplay = this.getBaseApplet().getLastError(iErrorCode);
            JOptionPane.showConfirmDialog(this, strDisplay, "Error", JOptionPane.OK_CANCEL_OPTION);
            return true;   // Handled
        }
        else if (ThinMenuConstants.CHANGE_PASSWORD.equalsIgnoreCase(strAction))
        {
            int iErrorCode = this.getBaseApplet().onChangePassword();
            if (iErrorCode == JOptionPane.CANCEL_OPTION)
                return true;    // User clicked the cancel button
            if (iErrorCode == Constants.NORMAL_RETURN)
                return true;    // Success
            // Display the error message and return!
            String strDisplay = this.getBaseApplet().getLastError(iErrorCode);
            JOptionPane.showConfirmDialog(this, strDisplay, "Error", JOptionPane.OK_CANCEL_OPTION);
            return true;   // Handled
        }
        else if (ThinMenuConstants.PREFERENCES.equalsIgnoreCase(strAction))
        {
            return this.getBaseApplet().onSetFont();
        }
        return false;
    }
394311
@SuppressWarnings("PMD.UseVarargs")
    public boolean handles(Eligible event, Eligible[] channels) {
        return filter.includes(event, channels);
    }
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);
    }
1073914
@Override
    public void handleOps(int ops) {
        if ((ops & SelectionKey.OP_ACCEPT) == 0 || closing) {
            return;
        }
        synchronized (channels) {
            if (connLimiter != null && !connLimiter.tryAcquire()) {
                return;
            }
            try {
                SocketChannel socketChannel = serverSocketChannel.accept();
                if (socketChannel == null) {
                    // "False alarm"
                    if (connLimiter != null) {
                        connLimiter.release();
                    }
                    return;
                }
                channels.add(new TcpChannelImpl(socketChannel));
            } catch (IOException e) {
                fire(new IOError(null, e));
            }
        }
    }
282443
public boolean execute() throws IOException {
    if (stopOnError) {
      for (int i = 0; i < actions.length; i++) {
        if (!actions[i].execute()) {
          return false;
        }
      }

      return true;
    } else {
      boolean status = true;
      IOException exception = null;

      for (int i = 0; i < actions.length; i++) {
        try {
          status &= actions[i].execute();
        } catch (IOException ex) {
          status = false;

          if (exception == null) {
            exception = ex;
          }
        }
      }

      if (exception != null) {
        throw exception;
      }

      return status;
    }
  }
954447
void processScope(Scope scope) {
    boolean shouldAddToBlockStack = !scope.isHoistScope();
    this.narrowScope = scope;
    if (shouldAddToBlockStack) {
      blockStack.add(new BasicBlock(null, scope.getRootNode()));
    }
    (new NodeTraversal(compiler, this, scopeCreator)).traverseAtScope(scope);
    if (shouldAddToBlockStack) {
      pop(blockStack);
    }
    this.narrowScope = null;
  }
268815
public static void executeCommand(String[] args) throws IOException {

            OptionParser parser = getParser();

            // declare parameters
            String url = null;

            // parse command-line input
            OptionSet options = parser.parse(args);
            if(options.has(AdminParserUtils.OPT_HELP)) {
                printHelp(System.out);
                return;
            }

            // check required options and/or conflicting options
            AdminParserUtils.checkRequired(options, AdminParserUtils.OPT_URL);

            // load parameters
            url = (String) options.valueOf(AdminParserUtils.OPT_URL);

            // execute command
            AdminClient adminClient = AdminToolUtils.getAdminClient(url);

            doMetaCheckVersion(adminClient);
        }
988058
public void processEvent(SystemEvent event)
    {
        Map<String, Object> scope = null;
        
        if (event instanceof PreDestroyViewMapEvent)
        {
            UIViewRoot viewRoot = (UIViewRoot) ((PreDestroyViewMapEvent) event).getComponent();
            scope = viewRoot.getViewMap(false);
            if (scope == null)
            {
                // view map does not exist --> nothing to destroy
                return;
            }
        }
        else if (event instanceof PreDestroyCustomScopeEvent)
        {
            ScopeContext scopeContext = ((PreDestroyCustomScopeEvent) event).getContext();
            scope = scopeContext.getScope();
        }
        else
        {
            // wrong event
            return;
        }
        
        if (!scope.isEmpty())
        {
            Set<String> keySet = scope.keySet();
            String[] keys = keySet.toArray(new String[keySet.size()]);
            
            for (String key : keys)
            {
                Object value = scope.get(key);
                this.destroy(key, value);
            }
        }
    }
494956
void processCommand(final HttpServerExchange exchange, final RequestData requestData, final MCMPAction action) throws IOException {
        if (exchange.getRequestPath().equals("*") || exchange.getRequestPath().endsWith("/*")) {
            processNodeCommand(exchange, requestData, action);
        } else {
            processAppCommand(exchange, requestData, action);
        }
    }
324578
private void processRangeOptions(final Map<String, String> properties) {
    final String featuresRange = properties.get("range");
    final String[] rangeArray = Flags
        .processLemmaBaselineFeaturesRange(featuresRange);
    if (rangeArray[0].equalsIgnoreCase("pos")) {
      this.isPos = true;
    }
    if (rangeArray[1].equalsIgnoreCase("posclass")) {
      this.isPosClass = true;
    }
    this.attributes = properties;
  }
780062
protected void handleOptions(HttpServletRequest request,
                              HttpServletResponse response)
        throws IOException
    {
        // Handle OPTIONS request for entire server
        if ("*".equals(request.getRequestURI()))
        {
            // 9.2
            response.setIntHeader(HttpFields.__ContentLength,0);
            response.setHeader(HttpFields.__Allow,__AllowString);                
            response.flushBuffer();
        }
        else
            response.sendError(HttpResponse.__404_Not_Found);
    }
295581
public void setOptions(Set<Option> options) {
        this.options = (options == null)
                       ? Collections.<Option>emptySet()
                       : new HashSet<Option>(options);
    }
519847
private String process() throws IOException
    {
        final StringBuilder out = new StringBuilder();
        final Block parent = this.readLines();
        parent.removeSurroundingEmptyLines();

        this.recurse(parent, false);
        Block block = parent.blocks;
        while (block != null)
        {
            this.emitter.emit(out, block);
            block = block.next;
        }

        return out.toString();
    }
157666
private boolean processLine(final CommandLine line, final Options options)
            throws Exception {
        if (line.hasOption(OPTION_VERSION)) {
            log.info(getVersion(true));
            return false;
        }
        if (line.hasOption(OPTION_HELP)) {
            produceHelp(options);
            return false;
        }
        if (line.hasOption(OPTION_INPUT)) {
            setXsdInput(line.getOptionValue(OPTION_INPUT).trim());
        }
        if (line.hasOption(OPTION_OUTPUT)) {
            setOutput(line.getOptionValue(OPTION_OUTPUT).trim());
        }
        if (line.hasOption(OPTION_AVRO_NAMESPACE_PREFIX)) {
            setAvroNamespacePrefix(line.getOptionValue(OPTION_AVRO_NAMESPACE_PREFIX).trim());
        }

        return true;
    }
1001110
public void initOptions(CompilerOptions options) {
    this.options = options;
    this.setFeatureSet(options.getLanguageIn().toFeatureSet());
    if (errorManager == null) {
      if (this.outStream == null) {
        setErrorManager(
            new LoggerErrorManager(createMessageFormatter(), logger));
      } else {
        ImmutableSet.Builder<ErrorReportGenerator> builder = ImmutableSet.builder();
        builder.add(
            new PrintStreamErrorReportGenerator(
                createMessageFormatter(), this.outStream, options.summaryDetailLevel));
        builder.addAll(options.getExtraReportGenerators());
        setErrorManager(new SortingErrorManager(builder.build()));
      }
    }

    moduleLoader = ModuleLoader.EMPTY;

    reconcileOptionsWithGuards();

    // TODO(johnlenz): generally, the compiler should not be changing the options object
    // provided by the user.  This should be handled a different way.

    // Turn off type-based optimizations when type checking is off
    if (!options.isTypecheckingEnabled()) {
      options.setUseTypesForLocalOptimization(false);
      options.setUseTypesForOptimization(false);
    }

    if (options.legacyCodeCompile) {
      options.setDisambiguateProperties(false);
      options.setAmbiguateProperties(false);
      options.useNonStrictWarningsGuard();
    }

    if (options.assumeForwardDeclaredForMissingTypes) {
      this.forwardDeclaredTypes =
          new AbstractSet<String>() {
            @Override
            public boolean contains(Object o) {
              return true; // Report all types as forward declared types.
            }

            @Override
            public boolean add(String e) {
              return false;
            }

            @Override
            public Iterator<String> iterator() {
              return Collections.<String>emptySet().iterator();
            }

            @Override
            public int size() {
              return 0;
            }
          };
    }

    initWarningsGuard(options.getWarningsGuard());
  }
1163937
public boolean hasOption(String opt)
    {
        opt = Util.stripLeadingHyphens(opt);

        return shortOpts.containsKey(opt) || longOpts.containsKey(opt);
    }
303768
@SuppressWarnings("unchecked")
	private void collectDrilldownOptions(final Options options) {
		List<? extends IProcessableOption> drilldownPoints = options.getMarkedForProcessing(DrilldownPoint.PROCESSING_KEY);
		for (DrilldownPoint drilldownPoint : (List<DrilldownPoint>) drilldownPoints) {
			Options drilldownOptions = drilldownPoint.getDrilldownOptions();
			if (!getDrilldownOptions().contains(drilldownOptions)) {
				getDrilldownOptions().add(drilldownOptions);
				collectDrilldownOptions(drilldownOptions);
			}
			drilldownPoint.setDrilldownOptionsIndex(getDrilldownOptions().indexOf(drilldownOptions));
		}
	}