结尾方法自定义处理
@param array $arguments
163496
protected function __linkLast($arguments,$operation)
	{
		if (isset($arguments[0]))
		{
			$field = $arguments[0];
		}
		else
		{
			$field = '*';
		}
		$this->operationOption['field'] = array($operation . '(' . $field . ')');
		return $this->getScalar();
	}
1112076
public function setArguments(array $arguments)
    {
        $options = [];
        if (!empty($arguments)) {
            if (
                !$this->checkFixedArray($arguments, count($arguments) > 1 ? 2 : 1) ||
                !is_numeric($arguments[0]) ||
                (isset($arguments[1]) && !is_array($arguments[1]))
            ) {
                throw new InvalidCommandArgumentException($this, $arguments);
            }

            if (isset($arguments[1])) {
                $options = $arguments[1];
                $this->checkOptionsInt($options, ['count']);
                $this->checkOptionsString($options, ['queue', 'reply']);
                $this->checkOptionsArray($options, ['state']);
            }
        }

        $this->arguments = array_merge([
            !empty($arguments) ? (int) $arguments[0] : 0
        ], $this->toArguments($options));
    }
1022328
public function setArguments($arguments = array())
    {
        // add additional arguments
        if (!$arguments) {
            $arguments = array();
        }
        if (!is_array($arguments)) {
            throw new BaseException('Arguments must be always an array');
        }
        $this->arguments = $args = array_merge($this->arguments, $arguments);
        foreach ($args as $arg => $val) {
            if (is_null($val)) {
                unset($this->arguments[$arg]);
            }
        }

        return $this;
    }
748645
protected function validateMissingArguments(array $arguments): bool
    {
        $missingArguments = \array_filter($arguments, function ($argument) {
            return empty($this->argument($argument));
        });

        if (\count($missingArguments) > 1) {
            throw new RuntimeException(\sprintf('Not enough arguments (missing: "%s").', \implode(', ', $missingArguments)));
        }

        return true;
    }
265906
public function setArguments(array $arguments)
    {
    	foreach ($arguments as $k => $v) {
    		$this->arguments[$k] = $v;
    	}
        
        return $this;
    }
746287
protected function verifyAction(array $arguments)
    {
        $this->verifierProcess->run($arguments, $this->processTimeout, $this->processIdleTimeout);
    }
1015587
public function setArguments($arguments = [])
    {
        $this->arguments = [];
        $this->requiredCount = 0;
        $this->hasOptional = false;
        $this->hasAnArrayArgument = false;
        $this->addArguments($arguments);
    }
865581
protected function setRange($arguments)
    {
        $this->query->setStart($this->getOffset($arguments));
        $this->query->setRows($this->getCount($arguments));
    }
1160991
public function handle(string $method, array $arguments)
    {
        $upMethod = strtoupper($method);
        //读
        if (in_array($upMethod, self::$readOperation) && !empty($this->slaves)) {
            $rand          = array_rand($this->slaves);
            $redisPoolName = $this->slaves[$rand];
        } else {
            //写
            $redisPoolName = $this->master;
        }

        // EVALMOCK在指定了脚本仅读操作时，可以在从节点上执行
        if ($upMethod == 'EVALMOCK' && isset($arguments[4])) {
            if ($arguments[4]) {
                $rand          = array_rand($this->slaves);
                $redisPoolName = $this->slaves[$rand];
            }

            array_pop($arguments);
        }

        if (!isset(RedisProxyFactory::$redisCoroutines[$redisPoolName])) {
            if (getInstance()->getAsynPool($redisPoolName) == null) {
                return false;
            }
            RedisProxyFactory::$redisCoroutines[$redisPoolName] = getInstance()->getAsynPool($redisPoolName)->getCoroutine();
        }
        $redisPoolCoroutine = RedisProxyFactory::$redisCoroutines[$redisPoolName];

        if ($method === 'cache' || $method === 'evalMock') {
            return $redisPoolCoroutine->$method(...$arguments);
        } else {
            return $redisPoolCoroutine->__call($method, $arguments);
        }
    }
540098
public function actionIndex(...$arguments)
    {
        if ($this->getContext()->getInput()->getHeader('x-rpc') && isset($arguments[0])) {
            $this->parseHttpArgument($arguments);
            yield $this->runMethod();
        } else {
            $this->outputJson([], 400);
        }
    }
785754
public function invokeWith($arguments = [])
    {
        if (!$arguments instanceof Arguments) {
            $arguments = new Arguments($arguments);
        }

        return $this->invoker->callWith($this->customCallback, $arguments);
    }
1200487
protected function setProperties(array $arguments)
    {
        if (isset($arguments[0])) {
            $this->phoneNumber = $arguments[0];
        }
        if (isset($arguments[1])) {
            $this->message = $arguments[1];
        }
    }
199821
private function execute($name, array $arguments)
    {
        return $this->functions[$name]->call($this->mapper, $this->connection, $this->strategies, $this->environment, $arguments, []);
    }
200997
protected function handleFunctionCall(array $arguments)
    {
        $invocation = $this->invocations->recordCall($arguments);
        if (null !== $this->callMap && $this->callMap->hasResultFor('function', $invocation)) {
            return $this->callMap->resultFor('function', $arguments, $invocation);
        }

        if ($this->parentCallsAllowed) {
            $originalFunction = $this->invocations->name();
            return $originalFunction(...$arguments);
        }

        return null;
    }
964515
private function validateReferences(array $arguments)
    {
        foreach ($arguments as $argument) {
            if (is_array($argument)) {
                $this->validateReferences($argument);
            } elseif ($argument instanceof Reference) {
                $targetDefinition = $this->getDefinition((string) $argument);

                if (null !== $targetDefinition && $targetDefinition->isAbstract()) {
                    throw new RuntimeException(sprintf(
                        'The definition "%s" has a reference to an abstract definition "%s". '
                       .'Abstract definitions cannot be the target of references.',
                       $this->currentId,
                       $argument
                    ));
                }
            }
        }
    }
1070752
private function callSessionMethod(string $name, array $arguments)
    {
        return \call_user_func_array(
            [
                $this->getFactory()->getSession(),
                $name
            ],
            $arguments
        );
    }
355744
public function __callBefore($name, $arguments)
	{
		if(isset($arguments[0]))
		{
			// getBy字段支持：
			$arr = explode('getBy',$name);
			if(''===$arr[0] && isset($arr[1]))
			{
				return $this->getBy($arr[1], $arguments[0]);
			}
			// selectBy字段支持：
			$arr = explode('selectBy',$name);
			if(''===$arr[0] && isset($arr[1]))
			{
				return $this->selectBy($arr[1], $arguments[0]);
			}
			unset($arr);
			// 全部转为小写，照顾所有大小写习惯的用户
			$name = strtolower($name);
		}
	}