<p>
(Optional) A list of all invocations.
</p>

@param commandInvocations
(Optional) A list of all invocations.
483960
public void setCommandInvocations(java.util.Collection<CommandInvocation> commandInvocations) {
        if (commandInvocations == null) {
            this.commandInvocations = null;
            return;
        }

        this.commandInvocations = new com.amazonaws.internal.SdkInternalList<CommandInvocation>(commandInvocations);
    }
14149
private void processCommand(List<String> command) throws Exception {
        processBuilder.command(command);
        Process p = processBuilder.start();
        checkReturnCode(p, processBuilder.command().toString(), 0);
    }
783039
public List<Execution> executeList(CommandContext commandContext, Map<String, Object> parameterMap, int firstResult, int maxResults) {
    return commandContext.getExecutionEntityManager().findExecutionsByNativeQuery(parameterMap, firstResult, maxResults);
  }
585811
public void setDeploymentApplicationConfigs(java.util.Collection<DeploymentApplicationConfig> deploymentApplicationConfigs) {
        if (deploymentApplicationConfigs == null) {
            this.deploymentApplicationConfigs = null;
            return;
        }

        this.deploymentApplicationConfigs = new java.util.ArrayList<DeploymentApplicationConfig>(deploymentApplicationConfigs);
    }
348218
public void defer(ICommandData[] commands) {
        deferredCommands.addAll(Arrays.asList(commands));
        for (ICommandData command : commands) {
            deferInternal(command);
        }
    }
880072
public void setOperations(java.util.Collection<BatchWriteOperation> operations) {
        if (operations == null) {
            this.operations = null;
            return;
        }

        this.operations = new java.util.ArrayList<BatchWriteOperation>(operations);
    }
985502
protected static String tryCommands (String[] cmds)
    {
        if (cmds == null) {
            return null;
        }

        String output;

        for (int ii = 0; ii < cmds.length; ii++) {
            output = runCommand(cmds[ii]);
            if (output != null) {
                return output;
            }
        }

        return null;
    }
1174644
@SuppressWarnings("unchecked")
    private void prepareKarafRbacInvocations(String fullName, Map<String, Object> mBeanInfo,
                                             Map<String, List<String>> queryForMBeans,
                                             Map<String, List<String>> queryForMBeanOperations) {
        queryForMBeans.put(fullName, new ArrayList<>());
        List<String> operations = operations((Map<String, Object>) mBeanInfo.get("op"));
        // prepare opByString for MBeainInfo
        Map<String, Map<String, Object>> opByString = new HashMap<>();
        mBeanInfo.put("opByString", opByString);
        if (operations.isEmpty()) {
            return;
        }

        queryForMBeanOperations.put(fullName, operations);
        for (String op : operations) {
            // ! no need to copy relevant map for "op['opname']" - hawtio uses only 'canInvoke' property
            opByString.put(op, new HashMap<>());
        }
    }
1304153
public static void updateInvocationStats(List<InvocationStat> snapshots) {
        for (InvocationStat snapshot : snapshots) {
            getInvocationStat(snapshot.getDimension()).update(snapshot);
        }
    }
751967
public void runCommands(final String[] commands) throws IOException {
		doLines(0, new LineReader() {
			private int commandC = 0;

			@Override
			public String getNextLine(String prompt) {
				if (commandC >= commands.length) {
					return null;
				} else {
					return commands[commandC++];
				}
			}
		}, true);
	}
336598
public void addCommands(Iterable<Command> commands) {
		Assert.notNull(commands, "Commands must not be null");
		for (Command command : commands) {
			addCommand(command);
		}
	}
1081929
private List<InvocationMessage> makePayloadInvocations() {
    final MessageFactory f = MessageFactoryHolder.FACTORY;

    final List<InvocationMessage> invocationMessages = new ArrayList<>();
    for (final AbstractRequest<?, ?> invocation : this.state.invocations) {
      // RequestData is produced by the generated subclass
      final RequestData data = invocation.getRequestData();
      final InvocationMessage message = f.invocation().as();

      // Operation; essentially a method descriptor
      message.setOperation(data.getOperation());

      // The arguments to the with() calls
      final Set<String> refsToSend = data.getPropertyRefs();
      if (!refsToSend.isEmpty()) {
        message.setPropertyRefs(refsToSend);
      }

      // Parameter values or references
      final List<Splittable> parameters = new ArrayList<>(data.getOrderedParameters().length);
      for (final Object param : data.getOrderedParameters()) {
        parameters.add(EntityCodex.encode(this, param));
      }
      if (!parameters.isEmpty()) {
        message.setParameters(parameters);
      }

      invocationMessages.add(message);
    }
    return invocationMessages;
  }
1243791
@SneakyThrows
    public final void recordMethodInvocation(final Class<?> targetClass, final String methodName, final Class<?>[] argumentTypes, final Object[] arguments) {
        jdbcMethodInvocations.add(new JdbcMethodInvocation(targetClass.getMethod(methodName, argumentTypes), arguments));
    }
1063153
public <T extends Commands> T getCommands(Class<T> commandInterface) {

        LettuceAssert.notNull(commandInterface, "Redis Command Interface must not be null");

        RedisCommandsMetadata metadata = new DefaultRedisCommandsMetadata(commandInterface);

        InvocationProxyFactory factory = new InvocationProxyFactory();
        factory.addInterface(commandInterface);

        BatchAwareCommandLookupStrategy lookupStrategy = new BatchAwareCommandLookupStrategy(
                new CompositeCommandLookupStrategy(), metadata);

        factory.addInterceptor(new DefaultMethodInvokingInterceptor());
        factory.addInterceptor(new CommandFactoryExecutorMethodInterceptor(metadata, lookupStrategy));

        return factory.createProxy(commandInterface.getClassLoader());
    }
355221
private void execCommand(String command,List args) 
		throws NoSuchMethodException,IllegalAccessException,InvocationTargetException
	{
		Class[] template = new Class[ args.size() ];
		for (int i=0; i<args.size(); i++) {
			template[i] = String.class;
		}
		Method m = MatchExptScript.class.getMethod(command, template );
		m.invoke(this, args.toArray(new String[0]));
	}
1330783
public List<HistoricDetail> executeList(CommandContext commandContext, Map<String, Object> parameterMap, int firstResult, int maxResults) {
    return commandContext.getHistoricDetailEntityManager().findHistoricDetailsByNativeQuery(parameterMap, firstResult, maxResults);
  }
1219342
public void setCommands(java.util.Collection<Command> commands) {
        if (commands == null) {
            this.commands = null;
            return;
        }

        this.commands = new com.amazonaws.internal.SdkInternalList<Command>(commands);
    }