@param bool $processSections
@param int $scannerMode

@return Ini

@api
501489
public static function new(bool $processSections = false, int $scannerMode = INI_SCANNER_NORMAL): Ini
    {
        return new self($processSections, $scannerMode);
    }
168234
private void processComponents(MAPDialogImpl mapDialogImpl, Component[] components) {

        // Now let us decode the Components
        for (Component c : components) {

            doProcessComponent(mapDialogImpl, c);
        }
    }
1048335
protected boolean startProcessDocs(final RootDoc rootDoc) throws IOException {
        for (String[] options : rootDoc.options()) {
            parseOption(options);
        }

        // Make sure the user specified a settings directory OR that we should use the defaults.
        // Both are not allowed.
        // Neither are not allowed.
        if ( (useDefaultTemplates && isSettingsDirSet) ||
                (!useDefaultTemplates && !isSettingsDirSet)) {
            throw new RuntimeException("ERROR: must specify only ONE of: " + USE_DEFAULT_TEMPLATES_OPTION + " , " + SETTINGS_DIR_OPTION);
        }

        // Make sure we can use the directory for settings we have set:
        if (!useDefaultTemplates) {
            validateSettingsDir();
        }

        // Make sure we're in a good state to run:
        validateDocletStartingState();



        processDocs(rootDoc);
        return true;
    }
215448
public function process(ServerRequestInterface $request, DelegateInterface $delegate)
    {
        $body = $request->getBody();

        if ($contents = $body->getContents()) {
            $body->rewind();
            $request = $request->withParsedBody($this->bodyParser->parse($contents));
        }

        return $delegate->process($request);
    }
929358
private static function processSectionContents(array $contents)
    {
        $result = array();
        
        // loop through each line and convert it to an array
        foreach ($contents as $path => $value) {
            // convert all a.b.c.d to multi-dimensional arrays
            $process = self::processContentEntry($path, $value);
            
            // merge the current line with all previous ones
            $result = self::arrayMergeRecursive($result, $process);
        }
        
        return $result;
    }
885620
function process( $tpl, &$textElements, $functionName, $functionChildren, $functionParameters, $functionPlacement, $rootNamespace, $currentNamespace )
    {
        switch ( $functionName )
        {
            case $this->BlockName:
            {
                // Check for disabled cache.
                $ini = eZINI::instance();
                if ( $ini->variable( 'TemplateSettings', 'TemplateCache' ) != 'enabled' )
                {
                    $text = eZTemplateCacheFunction::processUncached( $tpl, $functionChildren,
                                                                      $rootNamespace, $currentNamespace );
                    $textElements[] = $text;
                    return;
                }
                else
                {
                    $text = eZTemplateCacheFunction::processCachedPreprocess( $tpl,  $functionChildren,
                                                                              $functionParameters, $functionPlacement,
                                                                              $rootNamespace, $currentNamespace );
                    $textElements[] = $text;
                }
            } break;
        }
    }
58397
@Override
  public void parseProcess(Element processElement, ProcessDefinitionEntity processDefinition) {
    addStartEventListener(processDefinition);
    addEndEventListener(processDefinition);
  }
1315562
@Override
	public boolean execute(final ProcessInstance processInstance) {
		getBundleSelector().selectBundle(processInstance);
		List<Lock> locks = ContextUtils.getLocks(processInstance,getLockFactory(),"nz.co.senanque.workflow.Executor.execute(ProcessInstance)");
		LockTemplate lockTemplate = new LockTemplate(locks, new LockAction() {
			
			public void doAction() {
				log.debug("executing {}",processInstance.getId());
				getWorkflowManager().execute(processInstance.getId());
			}});
		return lockTemplate.doAction();
	}
1359051
public void setProcessPath(java.util.Collection<StringFilter> processPath) {
        if (processPath == null) {
            this.processPath = null;
            return;
        }

        this.processPath = new java.util.ArrayList<StringFilter>(processPath);
    }
585670
private void initBeforeList() {
        final List<ProcessAdvice> beforeRequestProcessAdvices = new ArrayList<>();

        final Method invokeHolder = getInvokeHolder();
        final Class<?> processorClass = invokeHolder.getDeclaringClass();

        // 1. process class advice
        if (null != processorClass && processorClass.isAnnotationPresent(Before.class)) {
            final Class<? extends ProcessAdvice>[] bcs = processorClass.getAnnotation(Before.class).value();
            for (int i = 0; i < bcs.length; i++) {
                final Class<? extends ProcessAdvice> bc = bcs[i];
                final ProcessAdvice beforeRequestProcessAdvice = BeanManager.getInstance().getReference(bc);
                beforeRequestProcessAdvices.add(beforeRequestProcessAdvice);
            }
        }
        // 2. process method advice
        if (invokeHolder.isAnnotationPresent(Before.class)) {
            final Class<? extends ProcessAdvice>[] bcs = invokeHolder.getAnnotation(Before.class).value();
            for (int i = 0; i < bcs.length; i++) {
                final Class<? extends ProcessAdvice> bc = bcs[i];
                final ProcessAdvice beforeRequestProcessAdvice = BeanManager.getInstance().getReference(bc);
                beforeRequestProcessAdvices.add(beforeRequestProcessAdvice);
            }
        }

        this.beforeRequestProcessAdvices = beforeRequestProcessAdvices;
    }
375213
protected void processClass(ClassDoc doc) {
        defaultProcess(doc, true);
        for ( MemberDoc member : doc.fields() ) {
            processMember(member);
        }
        for ( MemberDoc member : doc.constructors() ) {
            processMember(member);
        }
        for ( MemberDoc member : doc.methods() ) {
            processMember(member);
        }
        if ( doc instanceof AnnotationTypeDoc ) {
            for ( MemberDoc member : ((AnnotationTypeDoc)doc).elements() ) {
                processMember(member);
            }
        }
    }
475666
public function updateSection($sectionId, Request $request)
    {
        $createStruct = $this->inputDispatcher->parse(
            new Message(
                array('Content-Type' => $request->headers->get('Content-Type')),
                $request->getContent()
            )
        );

        try {
            return $this->sectionService->updateSection(
                $this->sectionService->loadSection($sectionId),
                $this->mapToUpdateStruct($createStruct)
            );
        } catch (InvalidArgumentException $e) {
            throw new ForbiddenException($e->getMessage());
        }
    }
282754
protected function processAction($action, FormInterface $form = null, $statusCode = Response::HTTP_NO_CONTENT)
    {
        $statusCode = $this->getParameterResolver()->resolveStatusCode($statusCode);

        $this->getRestEventDispatcher()->dispatch(
            RestEvents::ACTION,
            $event = new ActionEvent($this->resource, $action, $form, $statusCode)
        );

        $view = $event->getView();
        $statusCode = $view->getStatusCode();

        return $statusCode >= 300 && $statusCode < 400
            ? $this->handleView($view)
            : $this->processView($action, $view);
    }
1202731
public function create($appId, $scanId, $input, array $queryParams = [])
    {
        $response = $this->api
            ->applications()
            ->scans()
            ->processes()
            ->create($appId, $scanId, $input->toArray(), $queryParams);

        return new ProcessResponse($response);
    }
266661
function() {
							// Pass processingMode to Fragments only
							if (oClass.getMetadata().isA("sap.ui.core.Fragment") && node.getAttribute("type") !== "JS" && oView._sProcessingMode === "sequential") {
								mSettings.processingMode = "sequential";
							}
							if (oView.fnScopedRunWithOwner) {
								return oView.fnScopedRunWithOwner(function() {
									return new oClass(mSettings);
								});
							} else {
								return new oClass(mSettings);
							}
						}
246679
def _process_execs(self, contents, modulename, atype, mode="insert"):
        """"""
        #We only want to look at text after the contains statement
        match = self.RE_CONTAINS.search(contents)

        #It is possible for the type to not have any executables
        if match is not None:
            exectext = match.group("remainder")
            self._process_execs_contents(exectext, modulename, atype, mode)
800318
public function setSection(string $section, $container) : SectionedMap
    {
        if ($section === '') {
            throw new \InvalidArgumentException('Arg \'section\' cannot be empty.');
        }
        if (is_array($container)) {
            $this->arrayAccess[$section] = true;
        } elseif (is_object($container)) {
            $this->arrayAccess[$section] = $container instanceof \ArrayAccess;
        } else {
            throw new \TypeError('Arg \'container\' type[' . gettype($container) . '] is not object|array.');
        }
        $this->map[$section] = $container;

        return $this;
    }