{@link IMap#executeOnEntries(EntryProcessor, Predicate)}
432351
public void executeOnEntriesInternal(EntryProcessor entryProcessor, Predicate predicate, List<Data> result) {
        try {
            Map<Integer, Object> results;
            if (predicate instanceof PartitionPredicate) {
                PartitionPredicate partitionPredicate = (PartitionPredicate) predicate;
                Data key = toData(partitionPredicate.getPartitionKey());
                int partitionId = partitionService.getPartitionId(key);
                handleHazelcastInstanceAwareParams(partitionPredicate.getTarget());

                OperationFactory operation = operationProvider.createPartitionWideEntryWithPredicateOperationFactory(
                        name, entryProcessor, partitionPredicate.getTarget());
                results = operationService.invokeOnPartitions(SERVICE_NAME, operation, singletonList(partitionId));
            } else {
                OperationFactory operation = operationProvider.createPartitionWideEntryWithPredicateOperationFactory(
                        name, entryProcessor, predicate);
                results = operationService.invokeOnAllPartitions(SERVICE_NAME, operation);
            }
            for (Object object : results.values()) {
                if (object != null) {
                    MapEntries mapEntries = (MapEntries) object;
                    for (int i = 0; i < mapEntries.size(); i++) {
                        result.add(mapEntries.getKey(i));
                        result.add(mapEntries.getValue(i));
                    }
                }
            }
        } catch (Throwable t) {
            throw rethrow(t);
        }
    }
837411
@Override
    public ModelNode execute(final ModelNode operation, final OperationMessageHandler handler, final OperationTransactionControl control, final OperationAttachments attachments) {
        SecurityIdentity securityIdentity = securityIdentitySupplier.get();
        OperationResponse or = securityIdentity.runAs((PrivilegedAction<OperationResponse>) () -> internalExecute(operation,
                handler, control, attachments, prepareStep, false, partialModelIndicator.isModelPartial()));

        ModelNode result = or.getResponseNode();
        try {
            or.close();
        } catch (IOException e) {
            ROOT_LOGGER.debugf(e, "Caught exception closing response to %s whose associated streams, " +
                    "if any, were not wanted", operation);
        }
        return result;
    }
1182773
@Override
  public V putIfAbsent(K key, final V value) {
    return cache.invoke(key, new EntryProcessor<K, V, V>() {
      @Override
      public V process(MutableCacheEntry<K, V> e) {
        if (!e.exists()) {
          e.setValue(value);
          return null;
        }
        return e.getValue();
      }
    });
  }
50912
public static <K, V> Predicate<Map<K, V>> forEntries(
      final Predicate<? super Set<Map.Entry<K, V>>> p) {
    return new Predicate<Map<K, V>>() {
      @Override
      public boolean apply(Map<K, V> obj) {
        return p.apply(obj.entrySet());
      }
    };
  }
406463
@Override
    protected void executeImpl() throws TaskExecutionFailedException {

        try {
            String account = task.getAccount();
            String storeId = task.getStoreId();
            String spaceId = task.getSpaceId();
            String contentId = task.getContentId();
            String action = task.getAction();
            Map<String, String> props = task.getContentProperties();
            String acls = task.getSpaceACLs();
            Date timestamp = new Date(Long.valueOf(task.getDateTime()));

            auditLogStore.write(account,
                                storeId,
                                spaceId,
                                contentId,
                                task.getContentChecksum(),
                                task.getContentMimetype(),
                                task.getContentSize(),
                                task.getUserId(),
                                action,
                                props != null ? AuditLogStoreUtil.serialize(props) : null,
                                acls,
                                task.getSourceSpaceId(),
                                task.getSourceContentId(),
                                timestamp);

            log.debug("audit task successfully processed: {}", task);
        } catch (TransactionSystemException e) {
            log.error("failed to write item  ( account={} storeId={} spaceId={} contentId={} timestamp={} ) " +
                      "to the database due to a transactional error. Likely cause: duplicate entry. Details: {}. " +
                      "Ignoring...",
                      task.getAccount(),
                      task.getStoreId(),
                      task.getSpaceId(),
                      task.getContentId(),
                      new Date(Long.valueOf(task.getDateTime())),
                      e.getMessage());
        } catch (Exception e) {
            String message = "Failed to execute " + task + ": " + e.getMessage();
            log.debug(message, e);
            throw new TaskExecutionFailedException(message, e);
        }
    }
115532
public static <K, V> Predicate<Map<K, V>> allEntries(
      Predicate<? super Map.Entry<K, V>> p) {
    return forEntries(Predicates.<Map.Entry<K, V>>all(p));
  }
354596
public void processAnnotations(Class<?> classHierarchy)
                    throws InjectionException
    {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "processAnnotations: " + classHierarchy);

        for (Class<?> klass = classHierarchy; klass != null && klass != Object.class; klass = klass.getSuperclass())
        {
            Field[] fields = getAllDeclaredFields(klass, classHierarchy);

            for (int processorIndex = 0; processorIndex < ivProviders.size(); processorIndex++)
            {
                InjectionProcessorProvider<?, ?> provider = ivProviders.get(processorIndex);

                processClassAnnotations(processorIndex, provider, klass);

                if (fields != null)
                {
                    processMemberAnnotations(processorIndex, provider, fields, fields);
                }
            }
        }

        Method[] methods = getAllDeclaredMethods(classHierarchy);
        for (int processorIndex = 0; processorIndex < ivProviders.size(); processorIndex++)
        {
            processMemberAnnotations(processorIndex, ivProviders.get(processorIndex), methods, methods);
        }

        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "processAnnotations");
    }
466217
protected void executeExecutionListeners(HasExecutionListeners elementWithExecutionListeners,
      ExecutionEntity executionEntity, String eventType) {
    commandContext.getProcessEngineConfiguration().getListenerNotificationHelper()
      .executeExecutionListeners(elementWithExecutionListeners, executionEntity, eventType);
  }
200168
public void queueEntry(String entryPath, InputStream inStream,
                           int maxBytes)
                           throws IOException, TarMalformatException {
        entryQueue.add(new TarEntrySupplicant(entryPath, inStream, maxBytes,
                                              '0', archive));
    }
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);
    }
800289
void registerEntry(ListIterator<PathElement> iterator, String elementValue, ConcreteNotificationHandlerRegistration.NotificationHandlerEntry entry) {
        final NotificationHandlerNodeRegistry newRegistry = new NotificationHandlerNodeRegistry(elementValue, this);
        final NotificationHandlerNodeRegistry existingRegistry = childRegistriesUpdater.putIfAbsent(this, elementValue, newRegistry);

        final NotificationHandlerNodeRegistry registry = existingRegistry != null ? existingRegistry : newRegistry;
        registry.registerEntry(iterator, entry);
    }
569806
protected void writeParamsForSinglePreparedEntry(StringBuilder sb, SortedMap<String, String> paramMap, ExecutionInfo execInfo, List<QueryInfo> queryInfoList) {
        sb.append("[");
        for (Map.Entry<String, String> paramEntry : paramMap.entrySet()) {
            Object value = paramEntry.getValue();
            if (value == null) {
                sb.append("null");
            } else {
                sb.append("\"");
                sb.append(escapeSpecialCharacter(value.toString()));
                sb.append("\"");
            }
            sb.append(",");
        }
        chompIfEndWith(sb, ',');
        sb.append("],");
    }
288759
public static <T extends Executable> Predicate<T> executableIsSynthetic() {
        return candidate -> candidate != null && candidate.isSynthetic();
    }
293816
public static Predicate<InetAddress> ofExact(String address) {
        requireNonNull(address, "address");
        try {
            final InetAddress inetAddress = InetAddress.getByName(address);
            return ofExact(inetAddress);
        } catch (UnknownHostException e) {
            throw new IllegalArgumentException("Invalid address: " + address, e);
        }
    }
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);
		}

	}
1029634
@Override
  public final IEntityProcessor lazyGet(final Map<String, Object> pAddParam,
    final String pBeanName) throws Exception {
    IEntityProcessor proc = this.processorsMap.get(pBeanName);
    if (proc == null) {
      // locking:
      synchronized (this.processorsMap) {
        // make sure again whether it's null after locking:
        proc = this.processorsMap.get(pBeanName);
        if (proc == null) {
          if (pBeanName.equals(PrcHasSeSellerSave.class.getSimpleName())) {
            proc = lazyGetPrcHasSeSellerSave(pAddParam);
          } else if (pBeanName.equals(PrcHasSeSellerDel
            .class.getSimpleName())) {
            proc = lazyGetPrcHasSeSellerDel(pAddParam);
          } else if (pBeanName.equals(PrcSeGoodsSpecSave
            .class.getSimpleName())) {
            proc = lazyGetPrcSeGoodsSpecSave(pAddParam);
          } else if (pBeanName.equals(PrCuOrSeSv
            .class.getSimpleName())) {
            proc = lazyGetPrCuOrSeSv(pAddParam);
          } else if (pBeanName.equals(PrcSeServiceSpecSave
            .class.getSimpleName())) {
            proc = lazyGetPrcSeServiceSpecSave(pAddParam);
          } else if (pBeanName.equals(PrcSeGdSpecEmbFlSave
            .class.getSimpleName())) {
            proc = lazyGetPrcSeGdSpecEmbFlSave(pAddParam);
          } else if (pBeanName.equals(PrcSeGdSpecEmbFlDel
            .class.getSimpleName())) {
            proc = lazyGetPrcSeGdSpecEmbFlDel(pAddParam);
          } else if (pBeanName.equals(PrcSeSrvSpecEmbFlSave
            .class.getSimpleName())) {
            proc = lazyGetPrcSeSrvSpecEmbFlSave(pAddParam);
          } else if (pBeanName.equals(PrcSeSrvSpecEmbFlDel
            .class.getSimpleName())) {
            proc = lazyGetPrcSeSrvSpecEmbFlDel(pAddParam);
          } else {
            proc = this.fctBnEntitiesProcessors.lazyGet(pAddParam, pBeanName);
          }
        }
      }
    }
    if (proc == null) {
      throw new ExceptionWithCode(ExceptionWithCode.CONFIGURATION_MISTAKE,
        "There is no processor with name " + pBeanName);
    }
    return proc;
  }
603348
protected function executeInternal()
    {
        if (!class_exists(SwiftMailerMessage::class)) {
            throw new FinisherException('The "neos/swiftmailer" doesn\'t seem to be installed, but is required for the EmailFinisher to work!', 1503392532);
        }
        $formRuntime = $this->finisherContext->getFormRuntime();
        $standaloneView = $this->initializeStandaloneView();
        $standaloneView->assign('form', $formRuntime);
        $referrer = $formRuntime->getRequest()->getHttpRequest()->getUri();
        $standaloneView->assign('referrer', $referrer);
        $message = $standaloneView->render();

        $subject = $this->parseOption('subject');
        $recipientAddress = $this->parseOption('recipientAddress');
        $recipientName = $this->parseOption('recipientName');
        $senderAddress = $this->parseOption('senderAddress');
        $senderName = $this->parseOption('senderName');
        $replyToAddress = $this->parseOption('replyToAddress');
        $carbonCopyAddress = $this->parseOption('carbonCopyAddress');
        $blindCarbonCopyAddress = $this->parseOption('blindCarbonCopyAddress');
        $format = $this->parseOption('format');
        $testMode = $this->parseOption('testMode');

        if ($subject === null) {
            throw new FinisherException('The option "subject" must be set for the EmailFinisher.', 1327060320);
        }
        if ($recipientAddress === null) {
            throw new FinisherException('The option "recipientAddress" must be set for the EmailFinisher.', 1327060200);
        }
        if (is_array($recipientAddress) && !empty($recipientName)) {
            throw new FinisherException('The option "recipientName" cannot be used with multiple recipients in the EmailFinisher.', 1483365977);
        }
        if ($senderAddress === null) {
            throw new FinisherException('The option "senderAddress" must be set for the EmailFinisher.', 1327060210);
        }

        $mail = new SwiftMailerMessage();

        $mail
            ->setFrom(array($senderAddress => $senderName))
            ->setSubject($subject);

        if (is_array($recipientAddress)) {
            $mail->setTo($recipientAddress);
        } else {
            $mail->setTo(array($recipientAddress => $recipientName));
        }

        if ($replyToAddress !== null) {
            $mail->setReplyTo($replyToAddress);
        }

        if ($carbonCopyAddress !== null) {
            $mail->setCc($carbonCopyAddress);
        }

        if ($blindCarbonCopyAddress !== null) {
            $mail->setBcc($blindCarbonCopyAddress);
        }

        if ($format === self::FORMAT_PLAINTEXT) {
            $mail->setBody($message, 'text/plain');
        } else {
            $mail->setBody($message, 'text/html');
        }
        $this->addAttachments($mail);

        if ($testMode === true) {
            \Neos\Flow\var_dump(
                array(
                    'sender' => array($senderAddress => $senderName),
                    'recipients' => is_array($recipientAddress) ? $recipientAddress : array($recipientAddress => $recipientName),
                    'replyToAddress' => $replyToAddress,
                    'carbonCopyAddress' => $carbonCopyAddress,
                    'blindCarbonCopyAddress' => $blindCarbonCopyAddress,
                    'message' => $message,
                    'format' => $format,
                ),
                'E-Mail "' . $subject . '"'
            );
        } else {
            $mail->send();
        }
    }