Calls {@link AccessControlAction#execute(List)} on each of the embedded {@link AccessControlAction}s

{@inheritDoc}
@see org.apache.gobblin.data.management.retention.action.RetentionAction#execute(java.util.List)
484158
@Override
  public void execute(List<DatasetVersion> allVersions) throws IOException {
    for (AccessControlAction aca : this.embeddedAccessControlActions) {
      aca.execute(allVersions);
    }
  }
101482
@Override
  public void run() {
    if (isTriggerExpired()) {
      logger.info(this + " expired");
      return;
    }

    final boolean isTriggerConditionMet = this.triggerCondition.isMet();
    if (isTriggerConditionMet) {
      logger.info("Condition " + this.triggerCondition.getExpression() + " met");
      for (final TriggerAction action : this.actions) {
        try {
          action.doAction();
        } catch (final Exception e) {
          logger.error("Failed to do action " + action.getDescription()
              + " for execution " + azkaban.execapp.Trigger.this.execId, e);
        }
      }
    }
  }
161642
public void executeQueriesList(List<String> queriesList) {

        for (String query : queriesList) {
            this.session.execute(query);
        }
    }
345656
@Override
	public void execute(SQLiteDatabase database, int previuosVersion, int currentVersion) {
		List<String> executionList=null;
	
		if (inputStream==null) {
			File f = new File(schemaDefinitionFile);
			executionList = SQLiteUpdateTaskHelper.readSQLFromFile(schemaDefinitionFile);
			Logger.info("Load DDL from " + f.getAbsolutePath());
		} else {
			executionList = SQLiteUpdateTaskHelper.readSQLFromFile(inputStream);
			Logger.info("Load DDL from stream");
		}
		
		for (String item : executionList) {
			Logger.info(item);
			database.execSQL(item);
		}

	}
245270
List<Serializable> executeActionAndCollectData(Action action, String counterName,
			String sessionId, String threadId, String jobId, String cacheId) throws IOException {
		assert action != null;
		final URL actionUrl = getActionUrl(action, counterName, sessionId, threadId, jobId,
				cacheId);
		return collectForUrl(actionUrl);
	}
883338
@Override
    public boolean execute(String sql, String[] columnNames) throws SQLException
    {
        checkClosed();
        throw SQLError.noSupport();
    }
1178511
@Override
    public void execute(OperationContext context, ModelNode operation) throws OperationFailedException {

        nameValidator.validate(operation);
        final String newAlias = operation.require(NAME).asString();
        final ModelNode submodel = context.readResourceForUpdate(PathAddress.EMPTY_ADDRESS).getModel();
        final ModelNode currentValue = submodel.get(CacheContainerResource.ALIASES.getName()).clone();

        ModelNode newValue = addNewAliasToList(currentValue, newAlias) ;

        // now set the new ALIAS attribute
        final ModelNode syntheticOp = new ModelNode();
        syntheticOp.get(CacheContainerResource.ALIASES.getName()).set(newValue);
        CacheContainerResource.ALIASES.validateAndSet(syntheticOp, submodel);

        // since we modified the model, set reload required
        if (requiresRuntime(context)) {
            context.addStep((context1, operation1) -> {
                context1.reloadRequired();
                context1.completeStep(OperationContext.RollbackHandler.REVERT_RELOAD_REQUIRED_ROLLBACK_HANDLER);
            }, OperationContext.Stage.RUNTIME);
        }
    }
482452
def execute(self, elem_list):
        
        if self.condition.is_true(elem_list):
            return self.action.act(elem_list)
        else:
            return elem_list
839078
@Override
    public void executeListMultiActions() throws CmsRuntimeException {

        if (getParamListAction().equals(LIST_MACTION_DELETE)) {
            // execute the delete multiaction
            List<String> removedItems = new ArrayList<String>();
            try {
                Iterator<CmsListItem> itItems = getSelectedItems().iterator();
                while (itItems.hasNext()) {
                    CmsListItem listItem = itItems.next();
                    CmsUUID pId = new CmsUUID(listItem.getId());
                    getCms().deleteProject(pId);
                    removedItems.add(listItem.getId());
                }
            } catch (CmsException e) {
                throw new CmsRuntimeException(Messages.get().container(Messages.ERR_DELETE_SELECTED_PROJECTS_0), e);
            }
        } else if (getParamListAction().equals(LIST_MACTION_UNLOCK)) {
            // execute the unlock multiaction
            try {
                Iterator<CmsListItem> itItems = getSelectedItems().iterator();
                while (itItems.hasNext()) {
                    CmsListItem listItem = itItems.next();
                    CmsUUID pId = new CmsUUID(listItem.getId());
                    getCms().unlockProject(pId);
                }
            } catch (CmsException e) {
                throw new CmsRuntimeException(Messages.get().container(Messages.ERR_UNLOCK_SELECTED_PROJECTS_0), e);
            }
        } else {
            throwListUnsupportedActionException();
        }
        listSave();
    }
940529
function accessControl () {
    // if the query is for specific record(s) by id then the action type
    // is read. for all other queries the action type is list.
    this.action = defined(this.args.where.id) ? 'read' : 'list'
    // if allow override is set then skip access control
    if (this.args.allow) {
        return
    }
    // get global access control instance
    var accessControl = ImmutableAccessControl.getGlobal()
    // add scope of access allowed to args
    this.args.scope = accessControl.allowModelScope({
        action: this.action,
        model: this.model.name,
        session: this.session,
        states: this.accessControlStates(),
    })
    // if scope is undefined then throw access denied error
    if (!defined(this.args.scope)) {
        httpError(403, null, accessControl.audit)
    }
    // if scope is own add access control args
    if (this.args.scope === 'own') {
        this.accessControlOwn(accessControl)
    }
}
1227607
public void executeMethods(final List<Method> methods) throws Exception {

        for (final Method method : methods) {

            // TODO - curious about the findSuitableInstancesOf ? won't
            // method.getDeclaringClass be ok??

            for (final Object object : findSuitableInstancesOf(method.getDeclaringClass())) {

                method.invoke(object);

            }
        }
    }
1258082
@Override
    public List<Instance> executeWithoutAccessCheck()
        throws EFapsException
    {
        prepareQuery();
        final String sql = createSQLStatement();
        final QueryKey querykey = QueryKey.get(getKey(), sql);
        final Cache<QueryKey, Object> cache = QueryCache.getSqlCache();
        if (cache.containsKey(querykey)) {
            final Object object = cache.get(querykey);
            if (object instanceof List) {
                final List<?> values = (List<?>) object;
                for (final Object value : values) {
                    if (value instanceof Instance) {
                        getValues().add((Instance) value);
                    }
                }
            }
        } else {
            executeOneCompleteStmt(sql);
            QueryCache.put(this, querykey, getValues());
        }
        return getValues();
    }
549867
@SuppressWarnings({ "unchecked", "rawtypes" })
    @Override
    public List<ApiBuddy> execute() {
        BuddyList buddyList = extension.getParentZone()
                .getBuddyListManager()
                .getBuddyList(user);
        return (List) buddyList.getBuddies();
    }
991664
@Override
    public void execute() {
        try {
            String str = editor.readLine("Find:");
            editor.findNext(str);
            FindContext.setLastSearch(str);
        } catch (IOException e) {
            //noop
        }
    }
83512
public void execute(final Collection<T> targets, final ForceExecuteCallback<T> callback) throws SQLException {
        Collection<SQLException> exceptions = new LinkedList<>();
        for (T each : targets) {
            try {
                callback.execute(each);
            } catch (final SQLException ex) {
                exceptions.add(ex);
            }
        }
        throwSQLExceptionIfNecessary(exceptions);
    }
745172
@Override
    public void execute() throws TaskExecutionFailedException {
        if (AuditTask.ActionType.CREATE_SPACE.name().equals(task.getAction())) {
            String account = task.getAccount();
            log.info("new space audit task received for account {} received: {}", account, task);
            String storeId = task.getStoreId();
            String spaceId = task.getSpaceId();
            log.warn("New space notification: subdomain: {}, storeId: {}, spaceId: {}: ",
                     account, storeId, spaceId);

            newSpace(account,
                     task.getStoreId(),
                     task.getSpaceId(),
                     task.getDateTime(),
                     task.getUserId());
        } else {
            log.debug("This task {} is not a space creation task: it will be ignored.", task);
        }
    }
848622
public void execute() {
		if (condition == null) {
			throw new SystemException("Rule cannot be executed as it has no condition");
		}

		if (condition.isTrue()) {
			for (Action action : onTrue) {
				action.execute();
			}
		} else {
			for (Action action : onFalse) {
				action.execute();
			}
		}
	}