Forward increment() method params to incrementInternal() method.
@param  OperationArguments $args
@return bool
779078
private function forwardIncrement(OperationArguments $args)
    {
        if ($args->has('offset')) {
            if ($args->has('initial')) {
                if ($args->has('expiry')) {
                    return $this->incrementInternal(
                        $args->getKey(),
                        $args->getOffset(),
                        $args->getInitial(),
                        $args->getExpiry()
                    );
                }
                return $this->incrementInternal($args->getKey(), $args->getOffset(), $args->getInitial());
            }
            return $this->incrementInternal($args->getKey(), $args->getOffset());
        }
        return $this->incrementInternal($args->getKey());
    }
1300001
public static function extractArgs(array $args, ?PaginationType $paginationType, ?int $paginateMaxCount): array
    {
        if ($paginationType->isConnection()) {
            /** @var int $first */
            $first = $args['first'];
            $page = self::calculateCurrentPage(
                $first,
                Cursor::decode($args)
            );
        } else {
            /** @var int $first */
            $first = $args[config('lighthouse.pagination_amount_argument')];
            $page = Arr::get($args, 'page', 1);
        }

        if ($first <= 0) {
            throw new Error(
                "Requested pagination amount must be more than 0, got $first"
            );
        }

        // Make sure the maximum pagination count is not exceeded
        if (
            $paginateMaxCount !== null
            && $first > $paginateMaxCount
        ) {
            throw new Error(
                "Maximum number of {$paginateMaxCount} requested items exceeded. Fetch smaller chunks."
            );
        }

        return [$first, $page];
    }
748296
public function milestones($args = null)
    {
        $this->areArgumentsValid($args, ['getProgress']);

        return $this->client->get("$this->endpoint/$this->id/milestones", $args)->response();
    }
116464
public function runCommand($commandName, array $args = [])
    {
        $application = $this->getApplication();

        $command = $application->find($commandName);

        $arrayInput = new ArrayInput($args);

        $arrayInput->setInteractive(false);

        $command->run($arrayInput, $this->getOutput());
    }
82931
public static function add(callable ...$args): callable
    {
        $sum = function ($x, ... $args) {
            $function = 0;
            foreach ($args as $arg) {
                $function += $arg($x);
            }
            return $function;
        };

        return function ($x) use ($args, $sum) {
            return $sum(...array_merge([$x], $args));
        };
    }
853403
protected function fireOnOperationException($operation, OperationArguments $args, Exception $exception)
    {
        $returnValue = null;
        $this->getEventManager()->triggerEvent(
            new OperationEvent('onOperationException', $this, $operation, $args, $returnValue, $exception)
        );
    }
382636
private function forwardAdd(OperationArguments $args)
    {
        if ($args->has('expiry')) {
            return $this->addInternal($args->getKey(), $args->getValue(), $args->getExpiry());
        }
        return $this->addInternal($args->getKey(), $args->getValue());
    }
1188907
public function forward(Argument $args)
    {
        $args = $this->protectArgs($args);
        $limit = $args['first'];
        $offset = $this->connectionBuilder->getOffsetWithDefault($args['after'], 0);

        // If we don't have a cursor or if it's not valid, then we must not use the slice method
        if (!\is_numeric($this->connectionBuilder->cursorToOffset($args['after'])) || !$args['after']) {
            $entities = \call_user_func($this->fetcher, $offset, $limit ? $limit + 1 : $limit);

            return $this->handleEntities($entities, function ($entities) use ($args) {
                return $this->connectionBuilder->connectionFromArray($entities, $args);
            });
        } else {
            $entities = \call_user_func($this->fetcher, $offset, $limit ? $limit + 2 : $limit);

            return $this->handleEntities($entities, function ($entities) use ($args, $offset) {
                return $this->connectionBuilder->connectionFromArraySlice($entities, $args, [
                    'sliceStart' => $offset,
                    'arrayLength' => $offset + \count($entities),
                ]);
            });
        }
    }
751165
private function forwardGet(OperationArguments $args)
    {
        if ($args->has('casToken')) {
            return $this->getInternal($args->getKey(), $args->getCasToken());
        }
        return $this->getInternal($args->getKey());
    }
441565
public function handleUpdate(Args $args)
    {
        $flags = $args->isOptionSet('force')
            ? RepositoryManager::OVERRIDE | RepositoryManager::IGNORE_FILE_NOT_FOUND
            : RepositoryManager::OVERRIDE;
        $repositoryPath = Path::makeAbsolute($args->getArgument('path'), $this->currentPath);
        $mappingToUpdate = $this->repoManager->getRootPathMapping($repositoryPath);
        $pathReferences = array_flip($mappingToUpdate->getPathReferences());

        foreach ($args->getOption('add') as $pathReference) {
            $pathReferences[$pathReference] = true;
        }

        foreach ($args->getOption('remove') as $pathReference) {
            unset($pathReferences[$pathReference]);
        }

        if (0 === count($pathReferences)) {
            $this->repoManager->removeRootPathMapping($repositoryPath);

            return 0;
        }

        $updatedMapping = new PathMapping($repositoryPath, array_keys($pathReferences));

        if ($this->mappingsEqual($mappingToUpdate, $updatedMapping)) {
            throw new RuntimeException('Nothing to update.');
        }

        $this->repoManager->addRootPathMapping($updatedMapping, $flags);

        return 0;
    }
815042
protected function setArgument($arg)
    {
        if ($this->checkDiscription($arg)) {
            $this->advanceArg($arg);
        } else {
            $this->simpleArg($arg);
        }
    }
265619
protected function executePayload($payload, $args)
    {
        array_unshift($args, $this->wrapped);

        if ($payload instanceof Mutator) {
            /** @var $payload callable */
            $this->wrapped = call_user_func_array($payload, $args);

            return $this;
        } else {
            return call_user_func_array($payload, $args);
        }
    }
340081
public function increment($key, $offset = 1, $initial = 0, $expiry = 0)
    {
        $operation = __FUNCTION__;
        $arguments = (new OperationArguments($operation))->setKey($key);
        if (func_num_args() > 1) {
            $arguments->setOffset($offset);
            if (func_num_args() > 2) {
                $arguments->setInitial($initial);
                if (func_num_args() > 3) {
                    $arguments->setExpiry($expiry);
                }
            }
        }
        return $this->doOperation($operation, $arguments);
    }
1192562
public function handleRename(Args $args)
    {
        $moduleName = $args->getArgument('name');
        $newName = $args->getArgument('new-name');

        $this->moduleManager->renameModule($moduleName, $newName);

        return 0;
    }
564215
public static function multiply(callable ...$args): callable
    {
        $product = function ($x, ... $args) {
            $function = 1;
            foreach ($args as $arg) {
                $function *= $arg($x);
            }
            return $function;
        };

        return function ($x) use ($args, $product) {
            return $product(...array_merge([$x], $args));
        };
    }
305744
private function runInit($args)
    {
        $cmd = new InitCommand($this->cwd);

        return $cmd->run(array_slice($args, 1));
    }
88912
public function forward($logic, ...$params)
    {
        $context = clone $this;
        $context->depth++;
        $context->params = $params;
        return call_user_func($this->forwarder, $context, $logic);
    }