/*-------------------------------------------------[ Actions ]---------------------------------------------------
554032
public Set<String> publishMethods(){
        Set<String> methods = new TreeSet<String>();
        for(Rule rule: rules.values()){
            for(Node node: rule.nodes()){
                if(node.action instanceof PublishAction)
                    methods.add(((PublishAction)node.action).name);
            }
        }
        return methods;
    }
322901
public function runAction(Action $action)
    {
        $priorAction = $this->_action;
        $this->_action = $action;
        if ($this->beforeAction($action)) {
            if (false === $action->runWithParams($this->getActionParams())) {
                $this->invalidActionParams($action);
            } else {
                $this->afterAction($action);
            }
        }
        $this->_action = $priorAction;
    }
491975
public void addAction(M element, short value)
    {
        actions.put(element, Short.valueOf(value));
    }
727814
@Override
    public void forEachRemaining(Consumer<? super U> action) {

        source.forEachRemaining(e->{
            action.accept( current=function.apply(current,e));

        });

    }
733237
function(name, action) {

        var handlers = this.__handlers__ || (this.__handlers__={});

        if (!action) {
            handlers[name] = [];
            return;
        }
        if (handlers[name]) {
            var hdls = handlers[name];
            var retains = [];
            for (var i = 0; i < hdls.length; i++) {
                if (action && hdls[i].action !== action) {
                    retains.push(hdls[i]);
                }
            }
            handlers[name] = retains;
        }

        return this;
    }
980466
private void refineAction(final Action action, final FilterKey key) {
        if (key.value != null && bindingMap != null && !bindingMap.isEmpty()) {
            final Map<String, Set<Element>> schemeMap = bindingMap.get(key.attribute);
            if (schemeMap != null && !schemeMap.isEmpty()) {
                for (final Set<Element> submap: schemeMap.values()) {
                    for (final Element e: submap) {
                        final Element subRoot = searchForKey(e, key.value);
                        if (subRoot != null) {
                            insertAction(subRoot, key.attribute, action);
                        }
                    }
                }
            }
        }
    }
899013
function (jax) {
      var SRE = jax.root.SRE, actions = SRE.action, j, state = {};
      SRE.width = jax.sreGetRootWidth(state);
      for (j = actions.length-1; j >= 0; j--) actions[j].selection = 2;
      for (j = actions.length-1; j >= 0; j--) {
        var action = actions[j];
        if (action.SREwidth == null) {
          action.selection = 1;
          action.SREwidth = jax.sreGetActionWidth(state,action);
        }
      }
      SRE.actionWidths = true;
    }
659496
private void createActionStack() throws ParserException, GrammarException {
	boolean accepted = false;
	do {
	    checkTimeout();
	    stepCounter++;
	    if (logger.isTraceEnabled()) {
		logger.trace(toString());
	    }
	    if (streamPosition > maxPosition) {
		maxPosition = streamPosition;
	    }
	    final ParserActionSet actionSet;
	    final Token token;
	    if (streamPosition < getTokenStream().size()) {
		token = getTokenStream().get(streamPosition);
		actionSet = parserTable.getActionSet(stateStack.peek(), new Terminal(token.getName(), token.getText()));
	    } else {
		token = null;
		actionSet = parserTable.getActionSet(stateStack.peek(), FinishTerminal.getInstance());
	    }
	    if (logger.isTraceEnabled()) {
		logger.trace(actionSet.toString());
	    }
	    final ParserAction action = getAction(actionSet);
	    switch (action.getAction()) {
	    case SHIFT:
		shift(action);
		break;
	    case REDUCE:
		reduce(action);
		break;
	    case ACCEPT:
		accept(action);
		accepted = true;
		break;
	    case ERROR:
		error();
		break;
	    default:
		throw new ParserException("Invalid action '" + action + "'for parser near '"
			+ getTokenStream().getCodeSample(maxPosition) + "'!");
	    }
	} while (!accepted);
    }
769484
public function showAction()
    {
        $this->showParameters = $this->showParameters + $this->defaultTokenParameters;
        $this->showSnippets   = $this->getToken()->getShowSnippetNames();

        parent::showAction();
    }
335245
public void setActions(java.util.Collection<DatasetAction> actions) {
        if (actions == null) {
            this.actions = null;
            return;
        }

        this.actions = new java.util.ArrayList<DatasetAction>(actions);
    }
1098935
def setActions( self, actions ):
        
        self.uiActionTREE.blockSignals(True)
        self.uiActionTREE.setUpdatesEnabled(False)
        
        self.uiActionTREE.clear()
        for action in actions:
            self.uiActionTREE.addTopLevelItem(ActionItem(action))
        
        self.uiActionTREE.sortByColumn(0, Qt.AscendingOrder)
        self.uiActionTREE.blockSignals(False)
        self.uiActionTREE.setUpdatesEnabled(True)
912468
function(name, action, context) {
        if (!name || !action) {
            return;
        }
        var handlers = this.__handlers__ || (this.__handlers__={});
        if (!handlers[name]) {
            handlers[name] = [];
        }
        else {
            if (this.has(name, action)) {
                return;
            }
        }
        var handler = new Handler(action, context || this);
        handlers[name].push(handler);

        return this;
    }
1284214
@Override
    public void actionPerformed(ActionEvent e) {
        String cmd = e.getActionCommand();
        if (cmd.equals("Cut")) {
            // textArea.cut();
        } else if (cmd.equals("Copy")) {
            textArea.copy();
        } else if (cmd.equals("Paste")) {
            // textArea.paste();
        }
    }
1263484
function(action) {
			var list = this._trackedtypes[action.type];
			if (list) {
				list.forEach(function(checks) {
					var handler = checks[0];
					var matches = checks[1] === action.global;
					var hacking = handler === this.spirit && this.$handleownaction;
					if (matches && (handler !== action.target || hacking)) {
						handler.onaction(action);
					}
				}, this);
			}
		}
324523
public void saveAndStopActions() {
		for (Interruptible action : getInterruptibleActions()) {
			if (action.isInProgress()) {
				action.save();
				action.stop();
			}
		}
	}
1317726
function () {
            var self = this;
            base._create.apply(self, arguments);

            if (self.options.actions.listAction) {
                self._adaptListActionforAbp();
            }

            if (self.options.actions.createAction) {
                self._adaptCreateActionforAbp();
            }

            if (self.options.actions.updateAction) {
                self._adaptUpdateActionforAbp();
            }

            if (self.options.actions.deleteAction) {
                self._adaptDeleteActionforAbp();
            }
        }
654159
function (actions) {
      this.register(function (payload) {
        if (payload.actionType) {
          if (factory.isFunction(actions[payload.actionType])) {
            actions[payload.actionType].call(this, payload);
          }
        }
      }.bind(this));
    }