Add an executable "post-run" dependent for this model.

@param executable the executable "post-run" dependent
@return the key to be used as parameter to taskResult(string) method to retrieve result of executing
the executable "post-run" dependent
516553
@SuppressWarnings("unchecked")
    protected void addPostRunDependent(Executable<? extends Indexable> executable) {
        TaskGroup.HasTaskGroup dependency = (TaskGroup.HasTaskGroup) executable;
        this.addPostRunDependent(dependency);
    }
1276209
public static MethodParameter createMethodParameter(Executable executable, int i) {
		MethodParameter methodParameter;
		if (executable instanceof Method) {
			methodParameter = new MethodParameter((Method) executable, i);
		} else if (executable instanceof Constructor){
			methodParameter = new MethodParameter((Constructor) executable, i);
		} else {
			throw new IllegalArgumentException("Unsupported Executable: " + executable);
		}
		methodParameter.initParameterNameDiscovery(new DefaultParameterNameDiscoverer());
		return methodParameter;
	}
1184795
public TaskResult add(String key, CharSequence value) {
    mBundle.putCharSequence(key, value);
    return this;
  }
1350570
private ProcessBuilder appendExecutablePath(ProcessBuilder builder) {
    String executable = builder.command().get(0);
    if (executable == null) {
      throw new IllegalArgumentException(
          "No executable provided to the Process Builder... we will do... nothing... ");
    }
    builder.command().set(0,
        FileUtils.getFileResourceId(configuration.getWorkerPath(), executable).toString());
    return builder;
  }
510613
def post_build_app
      command = BuildCommandGenerator.post_build

      return if command.empty?

      print_command(command, "Generated Post-Build Command") if FastlaneCore::Globals.verbose?
      FastlaneCore::CommandExecutor.execute(command: command,
                                          print_all: true,
                                      print_command: !Gym.config[:silent],
                                              error: proc do |output|
                                                ErrorHandler.handle_build_error(output)
                                              end)
    end
128162
@SuppressWarnings("unused")
    @Internal
    @UsedByGeneratedCode
    protected final AbstractBeanDefinition<T> addExecutableMethod(ExecutableMethod<T, ?> executableMethod) {
        MethodKey key = new MethodKey(executableMethod.getMethodName(), executableMethod.getArgumentTypes());
        executableMethodMap.put(key, executableMethod);
        return this;
    }
610474
public static <T extends Executable> Predicate<T> executableHasSameParameterTypesAs(T reference) {
        return candidate -> {
            if (candidate == null) {
                return false;
            }
            Class<?>[] candidateParameterTypes = candidate.getParameterTypes();
            Class<?>[] referenceParameterTypes = reference.getParameterTypes();
            if (candidateParameterTypes.length != referenceParameterTypes.length) {
                return false;
            }
            for (int i = 0; i < candidateParameterTypes.length; i++) {
                if (!candidateParameterTypes[i].equals(referenceParameterTypes[i])) {
                    return false;
                }
            }
            return true;
        };
    }
11417
public String addPostRunDependent(FunctionalTaskItem dependent) {
        Objects.requireNonNull(dependent);
        return this.taskGroup().addPostRunDependent(dependent);
    }
1105564
public Launch aSynchLaunch() throws LaunchException {
		JobDataMap jobDataMap = new JobDataMap();
		jobDataMap.put(Launch.PARAMETERS, this.launch.getParameters());
		jobDataMap.put(Launch.DEFAULT_EXECUTOR_KEY, this.launch.getExecutorService());
		try {
			this.launch.aSynchLaunch();
		} catch (org.parallelj.launching.LaunchException e) {
			throw new LaunchException(e);
		}
		this.legacyLaunchResult = new LaunchResult(launch.getLaunchId(), jobDataMap);
		
		return this;
	}
60869
@Override
    public void execute(DelegateExecution execution) {
        ActionDefinition actionDefinition = findRelatedActionDefinition(execution);

        Connector connector = getConnector(getImplementation(execution));
        IntegrationContext integrationContext = connector.apply(integrationContextBuilder.from(execution,
                                                                                    actionDefinition));

        execution.setVariables(outboundVariablesProvider.calculateVariables(integrationContext,
                                                                            actionDefinition));

        leave(execution);
    }
459613
@Override
    protected void executeImpl() throws TaskExecutionFailedException {
        final String account = task.getAccount();
        final String storeId = task.getStoreId();
        final String spaceId = task.getSpaceId();

        // open text file
        final File bitLogDir = new File(config.getWorkDirectoryPath()
                                        + File.separator + "bit-integrity-reports");
        if (!bitLogDir.exists()) {
            bitLogDir.mkdirs();
        }

        final File bitLog = createNewLogFile(account,
                                             storeId,
                                             spaceId,
                                             bitLogDir);

        try {
            List<BitLogItem> errors = writeLog(bitLog, account, storeId, spaceId);

            ChecksumUtil util = new ChecksumUtil(Algorithm.MD5);
            final String checksum = util.generateChecksum(bitLog);
            // upload to duracloud
            final String reportSpaceId = "x-duracloud-admin";
            final String reportContentId = "bit-integrity/" + spaceId + "/" + storeId + "/"
                                           + bitLog.getName();

            new Retrier().execute(new Retriable() {
                @Override
                public Object retry() throws Exception {
                    Iterator<String> spaces = store.getSpaces();
                    while (spaces.hasNext()) {
                        if (spaces.next().equals(reportSpaceId)) {
                            return null;
                        }
                    }

                    store.createSpace(reportSpaceId);
                    return null;
                }
            });

            new Retrier().execute(new Retriable() {

                @Override
                public Object retry() throws Exception {
                    return store.addContent(reportSpaceId,
                                            reportContentId,
                                            "text/tsv",
                                            null,
                                            bitLog.length(),
                                            checksum,
                                            new FileInputStream(bitLog));
                }
            });

            BitIntegrityReportResult result = BitIntegrityReportResult.SUCCESS;

            if (errors.size() > 0) {
                result = BitIntegrityReportResult.FAILURE;
            }

            BitIntegrityReport report = bitLogStore.addReport(account,
                                                              storeId,
                                                              spaceId,
                                                              reportSpaceId,
                                                              reportContentId,
                                                              result,
                                                              new Date());

            if (errors.size() > 0) {
                log.warn(
                    "Bit integirty errors: subdomain: {}, storeId: {}, spaceId: {}: ",
                    account, storeId, spaceId);

                notifyManagerOfBitIntegrityErrors(report, errors);
            }

            try {
                // delete all bit integrity log items for space.
                bitLogStore.delete(account, storeId, spaceId);
                log.info("Deleted Bit Log Items for account: {}, storeId: {}, spaceId: {}: ",
                         account, storeId, spaceId);

            } catch (Exception ex) {
                log.warn(MessageFormat.format(
                    "failed to delete bit log items where account={0}, store_id = {1}, space_id = {2} due to: {3}",
                    account, storeId, spaceId, ex.getMessage()), ex);
            }

        } catch (Exception ex) {
            throw new TaskExecutionFailedException("task processing failed: " + ex.getMessage(), ex);
        } finally {
            try {
                bitLog.delete();
            } catch (Exception ex) {
                log.warn("failed to delete bit log: " + bitLog.getAbsolutePath(), ex);
            }
        }

    }
1204527
private void createExecutableSettings()
	{

		executablePathLabel = new JLabel("Path to executables: ");
		executablePathLabel.setBounds(10, 10, 250, 25);
		this.add(executablePathLabel);

		// ------------------------------------------------------------------//
		// 7ZIP / P7ZIP SETTINGS //
		// ------------------------------------------------------------------//

		sevenZipEnableBox = new JCheckBox();
		sevenZipEnableBox.setBounds(10, 45, 25, 25);

		this.add(sevenZipEnableBox);

		sevenZipLabel = new JLabel("7Zip Executable: ");
		sevenZipLabel.setBorder(BorderFactory.createRaisedBevelBorder());
		sevenZipLabel.setBounds(40, 45, 120, 25);
		this.add(sevenZipLabel);

		sevenZipPathField = new JTextField();
		sevenZipPathField.setBounds(170, 45, 300, 25);
		this.add(sevenZipPathField);

		sevenZipSearchButton = new JButton("Search");
		sevenZipSearchButton.setBounds(480, 45, 80, 25);

		sevenZipSearchButton.addActionListener(new ActionListener()
		{
			@Override
			public void actionPerformed(final ActionEvent e)
			{

				JFileChooser fc = new JFileChooser();
				if (fc.showOpenDialog(new JPanel()) == JFileChooser.APPROVE_OPTION) {
					sevenZipPathField.setText(fc.getSelectedFile().getPath());
				}
			}
		});

		this.add(sevenZipSearchButton);

		sevenZipEnableBox.addActionListener(new ActionListener()
		{
			@Override
			public void actionPerformed(final ActionEvent e)
			{
				boolean flag = !controller.is7ZipEnabled();
				controller.setEnable7Zip(flag);

				sevenZipLabel.setEnabled(flag);
				sevenZipPathField.setEnabled(flag);
				sevenZipSearchButton.setEnabled(flag);
			}
		});

	}
688752
@Trivial
    Map<String, String> getExecutionProperties(Object task) {
        Map<String, String> execProps = task instanceof ManagedTask ? ((ManagedTask) task).getExecutionProperties() : null;
        if (execProps == null)
            execProps = defaultExecProps;
        else {
            Map<String, String> mergedProps = new TreeMap<String, String>(defaultExecProps);
            mergedProps.putAll(execProps);
            execProps = mergedProps;
        }
        return execProps;
    }
772815
public function setExecutable($executable)
    {
        $this->executable = (string) $executable;

        $message = sprintf("Set executable to [%s].", $this->executable);
        $this->log($message, Project::MSG_DEBUG);
    }
1144579
private int doAfterRun(Map<String, Command> references) throws Exception
	{
		if (status == Command.COMMAND_EXECUTED)
		{
			// System.out.println("doAfterRun(): command " + getResultType() + "
			// processed...");
			Vector<Command> toBeRemoved = new Vector<Command>();
			try
			{
				Statement[] statements = null;

				for (int i = 0; i < operations.size(); ++i)
				{
					Command cmd = operations.elementAt(i);

					if (cmd.isArrayElement())
					{

						if (cmd.isResolved())
						{
							if (statements == null)
							{
								statements = new Statement[operations.size()];
							}
							statements[i] = new Statement(getResultValue(), "set", new Object[] { Integer.valueOf(i), //$NON-NLS-1$
									cmd.getResultValue() });
							if ((i + 1) == operations.size())
							{
								for (int j = 0; j < operations.size(); ++j)
								{
									statements[j].execute();
								}
								toBeRemoved.addAll(operations);
							}
						}
						else
						{
							break;
						}

					}
					else
					{
						// since the call is Array.set()
						if (!isArray())
						{
							cmd.setTarget(getResultValue());
						}
						cmd.exec(references);

						if (cmd.isResolved())
						{
							// System.out.println("doAfterRun(): cmd = " +
							// cmd.methodName + " is resolved");
							toBeRemoved.add(cmd);
						}
						else
						{
							// System.out.println("doAfterRun(): cmd = " +
							// cmd.methodName + " is unresolved");
							break;
						}

					}

				}
			}
			catch (Exception e)
			{
				throw new Exception(e);
			}
			finally
			{
				operations.removeAll(toBeRemoved);
			}

			// if (operations.size() == 0) {
			// System.out.println("doAfterRun(): command " + getResultType()
			// + " completely processed.");
			// } else {
			// System.out.println("doAfterRun(): command " + getResultType()
			// + " contains incomplete " +
			// operations.size() + " commands.");
			// }
			return (operations.size() == 0) ? Command.CHILDREN_PROCESSED : status;
		}
		return status;
	}
32546
JobSubmissionResult finalizeExecute() throws ProgramInvocationException {
		return client.run(detachedPlan, jarFilesToAttach, classpathsToAttach, userCodeClassLoader, savepointSettings);
	}
577051
public void executeAsyncTimed(final long timeout) {
		if (executeThread != null) {
			throw new IllegalStateException("use executable once per call");
		}
		final Executable nestedExec = this;
		helperExecutable = new Executable() {
			public Object execute() throws Throwable {
				return nestedExec.executeTimed(timeout);
			}
		};
		helperExecutable.executeAsync();
	}