Get some system infos, including connection rates (in kbps).
@param bool $multicall
@return Structures\SystemInfos
543038
function getSystemInfo($multicall = false)
    {
        if ($multicall) {
            return $this->execute(ucfirst(__FUNCTION__), array(), $this->structHandler('SystemInfos'));
        }
        return Structures\SystemInfos::fromArray($this->execute(ucfirst(__FUNCTION__)));
    }
201920
function setModeScriptSettings($settings, $multicall = false)
    {
        if (!is_array($settings) || !$settings) {
            throw new InvalidArgumentException('settings = ' . print_r($settings, true));
        }

        return $this->execute(ucfirst(__FUNCTION__), array($settings), $multicall);
    }
750861
function getValidationReplay($player, $multicall = false)
    {
        $login = $this->getLogin($player);
        if ($login === false) {
            throw new InvalidArgumentException('player = ' . print_r($player, true));
        }

        if ($multicall) {
            return $this->execute(ucfirst(__FUNCTION__), array($login), function ($v) {
                return $v->scalar;
            });
        }
        return $this->execute(ucfirst(__FUNCTION__), array($login))->scalar;
    }
570559
public function readResponse($multiline = false)
    {
        try {
            $result = fgets($this->_socket);
        } catch (\Exception $e) {

        }

        if (!is_string($result)) {
            throw new \RuntimeException('read failed - connection closed?'.$e->getMessage());
        }

        $result = trim($result);
        if (strpos($result, ' ')) {
            list($status, $message) = explode(' ', $result, 2);
        } else {
            $status = $result;
            $message = '';
        }

        if ($status != '+OK') {
            throw new \RuntimeException($result);
        }

        if ($multiline) {
            $message = '';
            $line = fgets($this->_socket);
            while ($line && rtrim($line, "\r\n") != '.') {
                if ($line[0] == '.') {
                    $line = substr($line, 1);
                }
                $message .= $line;
                $line = fgets($this->_socket);
            };
        }

        return $message;
    }
108928
private function createCallStack(array $callConstructionOptions)
    {
        $callStack = function (Call $call, array $options) {
            $startCallMethod = $this->transportCallMethods[$call->getCallType()];
            return $this->transport->$startCallMethod($call, $options);
        };
        $callStack = new CredentialsWrapperMiddleware($callStack, $this->credentialsWrapper);
        $callStack = new FixedHeaderMiddleware($callStack, $this->agentHeader, true);
        $callStack = new RetryMiddleware($callStack, $callConstructionOptions['retrySettings']);
        $callStack = new OptionsFilterMiddleware($callStack, [
            'headers',
            'timeoutMillis',
            'transportOptions',
            'metadataCallback',
        ]);

        return $callStack;
    }
366470
function sendToServerAfterMatchEnd($link, $multicall = false)
    {
        if (!is_string($link)) {
            throw new InvalidArgumentException('link = ' . print_r($link, true));
        }

        $link = str_replace("maniaplanet://", "", $link);

        return $this->execute(ucfirst(__FUNCTION__), array($link), $multicall);
    }
1053898
function getModeScriptInfo($multicall = false)
    {
        if ($multicall) {
            return $this->execute(ucfirst(__FUNCTION__), array(), $this->structHandler('ScriptInfo'));
        }
        return Structures\ScriptInfo::fromArray($this->execute(ucfirst(__FUNCTION__)));
    }
1302178
function getSkinsDirectory($multicall = false)
    {
        if ($multicall) {
            return $this->execute(ucfirst(__FUNCTION__), array(), array($this, 'stripBom'));
        }
        return $this->stripBom($this->execute(ucfirst(__FUNCTION__)));
    }
333293
public function fetchCalls()
    {
      $url = URIResource::Make($this->path, array($this->id, "calls"));
      $res = $this->client->get($url);	
      $this->calls = new CallCollection(new DataPacketCollection($res));

      return $this->calls;
    }
733792
protected function receive($multiline = false)
    {
        $result = @fgets($this->socket);
        $status = $result = trim($result);
        $message = '';

        if (strpos($result, ' ')) {
            list($status, $message) = explode(' ', $result, 2);
        }

        if ($status != '+OK') {
            return false;
        }

        if ($multiline) {
            $message = '';
            $line = fgets($this->socket);
            while ($line && rtrim($line, "\r\n") != '.') {
                if ($line[0] == '.') {
                    $line = substr($line, 1);
                }
                $this->debug('Receiving: '.$line);
                $message .= $line;
                $line = fgets($this->socket);
            };
        }

        return $message;
    }
738099
public function filterCall(Call $call)
    {
        if ($container = $this->getContainer($call)) {
            $autowirer = new ArgumentAutowirer($container);
            $newArguments = $autowirer->autowireArguments($call->getCallee()->getReflection(), $call->getArguments());

            return $this->repackageCallIfNewArguments($call, $newArguments);
        }

        return $call;
    }
996185
function getManialinkPageAnswers($multicall = false)
    {
        if ($multicall) {
            return $this->execute(ucfirst(__FUNCTION__), array(), $this->structHandler('PlayerAnswer', true));
        }
        return Structures\PlayerAnswer::fromArrayOfArray($this->execute(ucfirst(__FUNCTION__)));
    }
1117267
public function getCallerId()
    {
        if ($this->clidInstance === false) {
            $this->clidInstance = new CallerIdFacade($this);
        }
        return $this->clidInstance;
    }
1279870
protected function getMultisite()
    {
        $sites = [];
        $multiSiteFile = sprintf(
            '%s/sites/sites.php',
            $this->appRoot
        );

        if (file_exists($multiSiteFile)) {
            include $multiSiteFile;
        }

        if (!$sites) {
            $this->getIo()->error(
                $this->trans('commands.debug.multisite.messages.no-multisites')
            );

            return 1;
        }

        return $sites;
    }
255057
function sendModeScriptCommands($commands, $multicall = false)
    {
        if (!is_array($commands) || !$commands) {
            throw new InvalidArgumentException('commands = ' . print_r($commands, true));
        }

        return $this->execute(ucfirst(__FUNCTION__), array($commands), $multicall);
    }
972032
public function get($functionName, CompilationContext $compilationContext, Call $call, $exists)
    {
        if (isset($this->cache[$functionName])) {
            return $this->cache[$functionName].', '.SlotsCache::getExistingFunctionSlot($functionName);
        }

        if (!$exists) {
            return 'NULL, 0';
        }

        $cacheSlot = SlotsCache::getFunctionSlot($functionName);

        $number = 0;
        if (!$compilationContext->insideCycle) {
            $gatherer = $this->gatherer;
            if ($gatherer) {
                $number = $gatherer->getNumberOfFunctionCalls($functionName);
                if ($number <= 1) {
                    return 'NULL, '.$cacheSlot;
                }
            }
        }

        if ($compilationContext->insideCycle || $number > 1) {
            $functionCacheVariable = $compilationContext->symbolTable->getTempVariableForWrite('zephir_fcall_cache_entry', $compilationContext);
            $functionCacheVariable->setMustInitNull(true);
            $functionCacheVariable->setReusable(false);
            $functionCache = '&'.$functionCacheVariable->getName();
        } else {
            $functionCache = 'NULL';
        }

        $this->cache[$functionName] = $functionCache;

        return $functionCache.', '.$cacheSlot;
    }
265095
public function getInfos($asFlat = false)
    {
        $iterator = true === $asFlat
            ? $this->getRecursiveIterator()
            : $this;

	    $infos = array();
	    foreach ($iterator as $element) {
	        if ($element->getType() == self::TYPE_INFO) {
	            $infos[] = $element;
	        }
	    }
	    return $infos;
	}