Sets the {@link ExecutionPipeline} this vertex shall be part of.

@param executionPipeline
the execution pipeline this vertex shall be part of
975975
void setExecutionPipeline(final ExecutionPipeline executionPipeline) {

		final ExecutionPipeline oldPipeline = this.executionPipeline.getAndSet(executionPipeline);
		if (oldPipeline != null) {
			oldPipeline.removeFromPipeline(this);
		}

		executionPipeline.addToPipeline(this);
	}
570393
public void addProxyProtocol(ChannelPipeline pipeline)
    {
        pipeline.addLast(NAME, this);

        if (withProxyProtocol) {
            pipeline.addBefore(NAME, OptionalHAProxyMessageDecoder.NAME, new OptionalHAProxyMessageDecoder());
        }
    }
470091
func (s *ActionExecutionFilter) SetPipelineExecutionId(v string) *ActionExecutionFilter {
	s.PipelineExecutionId = &v
	return s
}
729200
@Override
    public void execute() throws BuildException {
        initialize();

        final Job job = getJob(tempDir, getProject());
        try {
            for (final ModuleElem m : modules) {
                m.setProject(getProject());
                m.setLocation(getLocation());
                final PipelineHashIO pipelineInput = new PipelineHashIO();
                for (final Map.Entry<String, String> e : attrs.entrySet()) {
                    pipelineInput.setAttribute(e.getKey(), e.getValue());
                }
                AbstractPipelineModule mod = getPipelineModule(m, pipelineInput);
                long start = System.currentTimeMillis();
                mod.setLogger(logger);
                mod.setJob(job);
                mod.execute(pipelineInput);
                long end = System.currentTimeMillis();
                logger.debug("{0} processing took {1} ms", mod.getClass().getSimpleName(), end - start);
            }
        } catch (final DITAOTException e) {
            throw new BuildException("Failed to run pipeline: " + e.getMessage(), e);
        }
    }
1338998
public void dequeue(final int executionId) {
    if (this.queuedFlowMap.containsKey(executionId)) {
      this.queuedFlowList.remove(this.queuedFlowMap.get(executionId));
      this.queuedFlowMap.remove(executionId);
    }
  }
204230
@Bean(name = "portalRenderingPipeline")
    @Qualifier(value = "main")
    public IPortalRenderingPipeline getPortalRenderingPipeline() {

        // Rendering Pipeline Branches (adopter extension point)
        final List<RenderingPipelineBranchPoint> sortedList =
                (branchPoints != null) ? new LinkedList<>(branchPoints) : Collections.emptyList();
        Collections.sort(sortedList);
        final List<RenderingPipelineBranchPoint> branches =
                Collections.unmodifiableList(sortedList);

        /*
         * Sanity check:  if you have multiple RenderingPipelineBranchPoint beans, you can specify
         * an 'order' property on some or all of them to control the sequence of processing.
         * Having 2 RenderingPipelineBranchPoint beans with the same order value will produce
         * non-deterministic results and is a likely source of misconfiguration.
         */
        final Set<Integer> usedOderValues = new HashSet<>();
        boolean hasCollision =
                branches.stream()
                        .anyMatch(
                                branchPoint -> {
                                    final boolean rslt =
                                            usedOderValues.contains(branchPoint.getOrder());
                                    usedOderValues.add(branchPoint.getOrder());
                                    return rslt;
                                });
        if (hasCollision) {
            throw new RenderingPipelineConfigurationException(
                    "Multiple RenderingPipelineBranchPoint beans have the same 'order' value, which likely a misconfiguration");
        }

        // "Standard" Pipeline
        final IPortalRenderingPipeline standardRenderingPipeline = getStandardRenderingPipeline();

        return new IPortalRenderingPipeline() {
            @Override
            public void renderState(HttpServletRequest req, HttpServletResponse res)
                    throws ServletException, IOException {
                for (RenderingPipelineBranchPoint branchPoint : branches) {
                    if (branchPoint.renderStateIfApplicable(req, res)) {
                        /*
                         * Rendering bas been processed by the branch point -- no need to continue.
                         */
                        return;
                    }
                }
                /*
                 * Reaching this point means that a branch was not followed; use the "standard"
                 * pipeline.
                 */
                standardRenderingPipeline.renderState(req, res);
            }
        };
    }
737094
private void setPipeliningProperties() {
        if (ctx.channel().attr(Constants.MAX_RESPONSES_ALLOWED_TO_BE_QUEUED).get() == null) {
            ctx.channel().attr(Constants.MAX_RESPONSES_ALLOWED_TO_BE_QUEUED).set(pipeliningLimit);
        }
        if (ctx.channel().attr(Constants.RESPONSE_QUEUE).get() == null) {
            ctx.channel().attr(Constants.RESPONSE_QUEUE).set(holdingQueue);
        }
        if (ctx.channel().attr(Constants.NEXT_SEQUENCE_NUMBER).get() == null) {
            ctx.channel().attr(Constants.NEXT_SEQUENCE_NUMBER).set(EXPECTED_SEQUENCE_NUMBER);
        }

        if (ctx.channel().attr(Constants.PIPELINING_EXECUTOR).get() == null) {
            ctx.channel().attr(Constants.PIPELINING_EXECUTOR).set(pipeliningGroup);
        }
    }
773109
public void attachPipe(Pipe pipe)
    {
        assert (!isTerminating());
        assert (this.pipe == null);
        assert (pipe != null);
        this.pipe = pipe;
        this.pipe.setEventSink(this);
    }
1226906
Pipeline createPipeline(Language lang, Language motherTongue, TextChecker.QueryParams params, UserConfig userConfig)
    throws Exception { // package-private for mocking
    Pipeline lt = new Pipeline(lang, params.altLanguages, motherTongue, cache, userConfig);
    lt.setMaxErrorsPerWordRate(config.getMaxErrorsPerWordRate());
    if (config.getLanguageModelDir() != null) {
      lt.activateLanguageModelRules(config.getLanguageModelDir());
    }
    if (config.getWord2VecModelDir () != null) {
      lt.activateWord2VecModelRules(config.getWord2VecModelDir());
    }
    if (config.getRulesConfigFile() != null) {
      configureFromRulesFile(lt, lang);
    } else {
      configureFromGUI(lt, lang);
    }
    if (params.useQuerySettings) {
      Tools.selectRules(lt, new HashSet<>(params.disabledCategories), new HashSet<>(params.enabledCategories),
        new HashSet<>(params.disabledRules), new HashSet<>(params.enabledRules), params.useEnabledOnly);
    }
    if (pool != null) {
      lt.setupFinished();
    }
    return lt;
  }
849211
@Override
    public EventPipeline newEventPipeline(ExecutorService executorService) {
        return new CheckingPipelineFilter(
            new EventProcessor(tree(), executorService), channel());
    }
761010
public void setPipelines(java.util.Collection<PipelineSummary> pipelines) {
        if (pipelines == null) {
            this.pipelines = null;
            return;
        }

        this.pipelines = new java.util.ArrayList<PipelineSummary>(pipelines);
    }
316590
public GetPipelineResponse getPipeline(String pipelineName) {
        GetPipelineRequest request = new GetPipelineRequest();
        request.setPipelineName(pipelineName);
        return getPipeline(request);
    }
286793
public boolean isExistingPipeline(String pipelineName) throws IOException {
        logger.debug("is existing pipeline [{}]", pipelineName);
        try {
            return client.ingest().getPipeline(new GetPipelineRequest(pipelineName), RequestOptions.DEFAULT).isFound();
        } catch (ElasticsearchStatusException e) {
            if (e.status().getStatus() == 404) {
                return false;
            }
            throw new IOException(e);
        }
    }
1271497
public void setParallelism(int parallelism) {
		Preconditions.checkArgument(
				parallelism > 0 || parallelism == ExecutionConfig.PARALLELISM_DEFAULT,
				"The parallelism must be at least one, or ExecutionConfig.PARALLELISM_DEFAULT (use system default).");
		this.parallelism = parallelism;
	}
712207
func (s *RetryStageExecutionInput) SetPipelineExecutionId(v string) *RetryStageExecutionInput {
	s.PipelineExecutionId = &v
	return s
}
816845
public void setPipelineDescriptionList(java.util.Collection<PipelineDescription> pipelineDescriptionList) {
        if (pipelineDescriptionList == null) {
            this.pipelineDescriptionList = null;
            return;
        }

        this.pipelineDescriptionList = new com.amazonaws.internal.SdkInternalList<PipelineDescription>(pipelineDescriptionList);
    }
1184250
private static void transformPipelineService(IDisconfUpdatePipeline iDisconfUpdatePipeline) {

        DisconfStorePipelineProcessor disconfStorePipelineProcessor = DisconfStoreProcessorFactory
                .getDisconfStorePipelineProcessor();
        disconfStorePipelineProcessor.setDisconfUpdatePipeline(iDisconfUpdatePipeline);
    }