TODO implement addAction, addOrReplaceAction, removeAction, removeActions, replaceActions
188537
protected void updateTransientActions() {
        Vector<Action> ta = new Vector<>();

        for (LabelAtomProperty p : properties)
            ta.addAll(p.getActions(this));

        transientActions = ta;
    }
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);
                        }
                    }
                }
            }
        }
    }
28333
function( clip, optionalRoot ) {

		var action = this.existingAction( clip, optionalRoot );

		if ( action !== null ) {

			this._deactivateAction( action );
			this._removeInactiveAction( action );

		}

	}
569783
function _fillAction(entity, actionObj, actionType) {

    if (!(entity instanceof Scope) && !entity.id) {
      throw new Error('This entity does not have an ID.');
    }

    var ret = actionObj;

    if (Utils.isArray(actionObj)) {

      ret = actionObj.map(function (singleAction) {
        return _fillAction(entity, singleAction, actionType);
      });

    } else {
      ret.type = actionType !== 'all' && actionType ||  actionObj.type || '';
      _addEntityIdentifier(entity, ret);
    }

    return ret;
  }
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;
    }
313924
private static void packagingAction(Method[] methods, Object handlerBean) {
        if (ArrayUtils.isEmpty(methods)) {
            return;
        }
        // 参数唯一，且为public
        Predicate<Method> commonFilter = method -> Modifier.isPublic(method.getModifiers())
                && method.getParameterCount() == 1
                && Objects.isNull(handlerBean) == Modifier.isStatic(method.getModifiers());

        Arrays.stream(methods).filter(commonFilter).forEach(method -> ConverterContext.setAction(method, handlerBean));
    }
398043
def removed_or_inserted_action(mapper, connection, target):
    """"""
    current_access.delete_action_cache(get_action_cache_key(target.action,
                                                            target.argument))
690683
@Nonnull
    public ParametersAction createUpdated(Collection<? extends ParameterValue> overrides) {
        if(overrides == null) {
            ParametersAction parametersAction = new ParametersAction(parameters);
            parametersAction.safeParameters = this.safeParameters;
            return parametersAction;
        }
        List<ParameterValue> combinedParameters = Lists.<ParameterValue>newArrayList(overrides);
        Set<String> names = newHashSet();

        for(ParameterValue v : overrides) {
            if (v == null) continue;
            names.add(v.getName());
        }

        for (ParameterValue v : parameters) {
            if (v == null) continue;
            if (!names.contains(v.getName())) {
                combinedParameters.add(v);
            }
        }

        return new ParametersAction(combinedParameters, this.safeParameters);
    }
494155
public void addAction(M element, int value)
    {
        actions.put(element, Integer.valueOf(value));
    }
493653
public void registerAction(IDisable actionElement) {
        if (registeredActions == null) {
            registeredActions = new ArrayList<>();
        }

        registeredActions.add(actionElement);
        actionElement.setDisabled(isDisabled());
    }
727814
@Override
    public void forEachRemaining(Consumer<? super U> action) {

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

        });

    }
1190208
function TextActions(editor, undoStack, find) {
		this.editor = editor;
		this.undoStack = undoStack;
		this._incrementalFind = new mFind.IncrementalFind(editor);
		this._find = find ? find : new mFindUI.FindUI(editor, undoStack);
		this._lastEditLocation = null;
		this.init();
	}
573037
@Override
    @Deprecated
    public void forEachRemaining(java.util.function.Consumer<? super Pair<A, B>> action) {
        super.forEachRemaining(action);
    }
629821
function(actionName) {
		self[actionName] = function() {
			var args = arguments;
			self._stack.push({action : actionName, args : args});
			return self;
		};
	}
19356
def addAction(self, action, checked=None, autoBuild=True):
        
        # clear the holder
        actions = self._actionGroup.actions()
        if actions and actions[0].objectName() == 'place_holder':
            self._actionGroup.removeAction(actions[0])
            actions[0].deleteLater()
        
        # create an action from the name
        if not isinstance(action, QAction):
            action_name = nativestring(action)
            action = QAction(action_name, self)
            action.setObjectName(action_name)
            action.setCheckable(self.isCheckable())
            
            # auto-check the first option
            if checked or (not self._actionGroup.actions() and checked is None):
                action.setChecked(True)
        
        elif self.isCheckable():
            action.setCheckable(True)
            if not self.currentAction():
                action.setChecked(True)
        
        self._actionGroup.addAction(action)
        
        if autoBuild:
            self.rebuild()
        
        return action
149907
function() {
    this._super();

    if (!this._options.implicit) {
      this.removeOverride('<plural>');
      this.removeOverride('<singular>Objects');
      this.removeOverride('add<Singular>');
      this.removeOverride('add<Plural>');
      this.removeOverride('remove<Singular>');
      this.removeOverride('remove<Plural>');
      this.removeOverride('clear<Plural>');

      this.overrideProperty('<singular>', 'item', 'set');
      this.addHelper('get<Singular>', 'item');
      this.addHelper('set<Singular>', 'set');
      this.addHelper('fetch<Singular>', 'fetch');
    }
  }
675714
function (action) {
        var targetID = action.originalTarget.id,
            element = this.targets[targetID]

        if (!element) {
            return
        }

        var actionIndex = element.actions.indexOf(action)

        if (actionIndex == -1) {
            return
        }

        if (this.currentTarget == element) {
            element.currentActionSalvaged = true
        }

        element.actions[actionIndex] = null
        element.actions.splice(actionIndex, 1); // Delete array item

        if (element.actions.length === 0) {
            if (this.currentTarget == element) {
                this.currentTargetSalvaged = true
            }
        }

    }