@param int      $ruleIndex
@param iterable $opsAndArgs

@return iterable
333362
private function validateFilterArguments(int $ruleIndex, iterable $opsAndArgs): iterable
    {
        foreach ($opsAndArgs as $operation => $arguments) {
            yield $operation => $this->validateValues($ruleIndex, $arguments);
        }
    }
90205
public static function callRuleAlgorithm(
        ContextInterface $context,
        array $rulesData,
        LoggerInterface $logger = null
    ): array {
        return static::callAlgorithm(
            static::getCallable($rulesData),
            $context,
            static::getTargets($rulesData),
            static::getRules($rulesData),
            $logger
        );
    }
437896
@Override
	public Iterable<T> findAllById(final Iterable<ID> ids) {
		return arangoOperations.find(ids, domainClass);
	}
826180
public function deleteAccessControlRule($publicKey, $ruleId) {
        $this->validatePublicKeyName($publicKey);

        return $this->getCommand('DeleteAccessControlRule', array(
            'publicKey' => $publicKey,
            'id' => $ruleId,
        ))->execute();
    }
312293
protected static function isArray(RuleInterface $next = null): RuleInterface
    {
        return $next === null ? new AsArray() : new AndOperator(new AsArray(), $next);
    }
832542
public function withRule(Rule $rule): RulesCollection
    {
        $rules = array_merge($this->rules, [$rule]);

        return new RulesCollection($rules);
    }
1088433
public static function getRuleIndex(array $singleRuleIndexes): int
    {
        assert(array_key_exists(static::RULES_SINGLE_INDEX, $singleRuleIndexes));
        $result = $singleRuleIndexes[static::RULES_SINGLE_INDEX];

        return $result;
    }
16302
public function drupalLetmein($opts = [
        'user' => null,
        'path' => null
    ])
    {
        $this->executeCommandHook(__FUNCTION__, 'before');
        /** @var DrupalProjectType $instance */
        $instance = $this->getProjectInstance();
        $instance->createDrupalLoginLink($opts['user'], $opts['path']);
        $this->executeCommandHook(__FUNCTION__, 'after');
    }
535422
private function getValidatedFilters(): iterable
    {
        $ruleIndexes = $this->serializerClass::readFilterRulesIndexes($this->getSerializedRuleSet());

        if ($ruleIndexes === null) {
            // without validation
            foreach ($this->getFilterParameters() as $field => $operationsWithArgs) {
                yield $field => $this->parseOperationsAndArguments(static::PARAM_FILTER, $operationsWithArgs);
            }
        } else {
            // with validation
            $mainIndexes = $this->serializerClass::readRuleMainIndexes($ruleIndexes);
            $this->validationStarts(static::PARAM_FILTER, $ruleIndexes);
            foreach ($this->getFilterParameters() as $field => $operationsWithArgs) {
                if (is_string($field) === false || empty($field) === true ||
                    is_array($operationsWithArgs) === false || empty($operationsWithArgs) === true
                ) {
                    throw new InvalidQueryParametersException($this->createParameterError(
                        static::PARAM_FILTER,
                        $this->getInvalidParamMessage()
                    ));
                }

                if (array_key_exists($field, $mainIndexes) === false) {
                    // unknown field set type
                    $this->getValidationErrors()->add(
                        new ValidationError(
                            static::PARAM_FILTER,
                            $field,
                            ErrorCodes::INVALID_VALUE,
                            Messages::INVALID_VALUE,
                            []
                        )
                    );
                } else {
                    // for field a validation rule is defined so input value will be validated
                    $ruleIndex = $mainIndexes[$field];
                    $parsed    = $this->parseOperationsAndArguments(static::PARAM_FILTER, $operationsWithArgs);

                    yield $field => $this->validateFilterArguments($ruleIndex, $parsed);
                }
            }
            $this->validateEnds(static::PARAM_FILTER, $ruleIndexes);
        }
    }
714439
public com.google.appengine.v1.UrlDispatchRuleOrBuilder getDispatchRulesOrBuilder(
      int index) {
    return dispatchRules_.get(index);
  }
66815
public static Query logical(LogOp op, Collection<Query> expressions) {
        Query q = new Query(true);
        for (Query x : expressions) {
            ((ArrayNode) q.node).add(x.toJson());
        }
        Query a = new Query(false);
        a.add(op.toString(), q.toJson());
        return a;
    }
652049
public function ignoreRelationsFor(callable $operation, array $relations)
    {
        InvalidArgumentException::verifyAllInstanceOf(__METHOD__, 'relations', $relations, IRelation::class);
        $this->ignoreRelationStack[] = $relations;
        $result                      = $operation();
        array_pop($this->ignoreRelationStack);

        return $result;
    }
85750
public function addRule($index, $method = null, ...$params)
    {
        $this->rules[$index] = [$method, $params];
        return $this;
    }
1370085
public function getSources(string $fieldType, $sources, string $indexFrom, string $indexTo)
    {
        $mappedSources = $sources;
        if (is_array($sources)) {
            $mappedSources = [];
            $sources = array_filter($sources);
            foreach ($sources as $source) {
                $mappedSources[] = $this->getSource($fieldType, $source, $indexFrom, $indexTo);
            }
        }

        return $mappedSources;
    }
48319
public NegateMultiPos<S, Integer, Integer> setBetns(int leftIndex, int rightIndex) {
		return new NegateMultiPos<S, Integer, Integer>(leftIndex, rightIndex) {

			@Override protected S result() {
				return delegateQueue('I', left, right, pos, position, null, plusminus, filltgt);
			}
		};
	}
1151631
public function getRules($css, $existingRules = [])
    {
        $css = $this->doCleanup($css);
        $rulesProcessor = new RuleProcessor();
        $rulesByMediaQuery = $rulesProcessor->splitIntoSeparateMediaQueries($css);

        return $rulesProcessor->convertArrayToObjects($rulesByMediaQuery, $existingRules);
    }
1323913
public function digipolisCleanDir($dirs, $opts = ['sort' => PartialCleanDirsTask::SORT_NAME])
    {
        $dirsArg = array();
        foreach (array_map('trim', explode(',', $dirs)) as $dir) {
            $dirParts = explode(':', $dir);
            if (count($dirParts) > 1) {
                $dirsArg[$dirParts[0]] = $dirParts[1];
                continue;
            }
            $dirsArg[] = $dirParts[0];
        }
        return $this->taskPartialCleanDirs($dirsArg)
            ->sortBy($opts['sort'])
            ->run();
    }