@return Result

@SuppressWarnings(PHPMD.UnusedFormalParameter)
336013
public function getData(array $options)
    {
        $user = $this->getServer()->getUserDetails($this->accessToken);

        $imageUrl = null;
        if ($user->imageUrl) {
            $imageUrl = str_replace('_normal', '', $user->imageUrl);
        }

        $data = [
            'externalId' => $user->uid,
            'name'       => $user->name,
            'profileUrl' => 'http://twitter.com/' . $user->nickname,
            'photoUrl'   => $imageUrl,
            'location'   => $user->location,
            'language'   => $user->lang,
            'email'      => isset($user->email) ? $user->email : null
        ];

        return new Result($data);
    }
556195
public function result()
    {
        $keys      = array_keys($this->data);
        $first_key = reset($keys);

        return (!is_int($first_key)) ? $this->associativeColumns() : $this->columns();
    }
143135
public function getResults()
    {
        if (is_null($this->_resultsCache)) {
            $this->_resultsCache = call_user_func($this->getMapper());

            if ($this->prefetchRelatedLookups && !$this->_prefetchRelatedDone) {
                $this->_prefetchRelatedObjects();
            }
        }

        return $this->_resultsCache;
    }
100182
public function getStatus(): Result
    {
        $result = new Result();
        try {
            $this->connect();
            $connection = DriverManager::getConnection(['pdo' => $this->databaseHandle]);
        } catch (\Exception $exception) {
            $result->addError(new Error($exception->getMessage(), $exception->getCode(), [], 'Connection failed'));
            return $result;
        }
        try {
            $cacheTableExists = $connection->getSchemaManager()->tablesExist([$this->cacheTableName]);
            $tagsTableExists = $connection->getSchemaManager()->tablesExist([$this->tagsTableName]);
        } /** @noinspection PhpRedundantCatchClauseInspection */ catch (DBALException $exception) {
            $result->addError(new Error($exception->getMessage(), $exception->getCode(), [], 'Connection failed'));
            return $result;
        }
        $result->addNotice(new Notice((string)$connection->getDatabase(), null, [], 'Database'));
        $result->addNotice(new Notice((string)$connection->getDriver()->getName(), null, [], 'Driver'));

        if (!$cacheTableExists) {
            $result->addError(new Error('%s (missing)', null, [$this->cacheTableName], 'Table'));
        }
        if (!$tagsTableExists) {
            $result->addError(new Error('%s (missing)', null, [$this->tagsTableName], 'Table'));
        }
        if (!$cacheTableExists || !$tagsTableExists) {
            return $result;
        }
        $fromSchema = $connection->getSchemaManager()->createSchema();
        $schemaDiff = (new Comparator())->compare($fromSchema, $this->getCacheTablesSchema());
        try {
            $statements = $schemaDiff->toSaveSql($connection->getDatabasePlatform());
        } catch (DBALException $exception) {
            $result->addError(new Error($exception->getMessage(), $exception->getCode(), [], 'Connection failed'));
            return $result;
        }
        if ($statements !== []) {
            $result->addError(new Error('The schema of the cache tables is not up-to-date', null, [], 'Table schema'));
            foreach ($statements as $statement) {
                $result->addWarning(new Warning($statement, null, [], 'Required statement'));
            }
        }
        return $result;
    }
778410
public function result()
    {
        // Store rows here
        $rows = [];

        // Start showing connections
        $rows[] = array(
            'type' => 'header',
            'columns' =>

            // Not hiding mac address?
            !$this->_hide_mac ? array(
                'IP Address',
                'MAC Address',
                'Hostname',
                'Lease End',
            ) :

            // Hiding it indeed
                array(
                'IP Address',
                'Hostname',
                'Lease End',
            ),
        );

        // Append each lease
        foreach ($this->_leases as $lease) {
            $rows[] = array(
                'type' => 'values',
                'columns' =>

                // Not hiding mac addresses?
                !$this->_hide_mac ? array(
                    $lease['ip'],
                    $lease['mac'],
                    array_key_exists('hostname', $lease) ?
                        $lease['hostname'] : '<em>unknown</em>',
                    date(self::DATE_FORMAT, $lease['lease_end']),
                ) :

                // Hiding them indeed
                array(
                    $lease['ip'],
                    array_key_exists('hostname', $lease) ?
                        $lease['hostname'] : '<em>unknown</em>',
                    date(self::DATE_FORMAT, $lease['lease_end']),
                ),
            );
        }

        // Give it off
        return array(
            'root_title' => 'DnsMasq DHCPD IP Leases',
            'rows' => $rows,
        );
    }
383464
private function _getResultData()
    {
        $def = $this->actionChain->getCurrentAction();
        $result = $def['result'];
        if (is_string($result)) {
            return $this->getAttribute($result);
        } elseif (is_array($result)) {
            return array_pop($result);
        } else {
            return null;
        }
    }
811055
public function getResultsAction()
    {
        $datatable = $this->get('olix_security.datatable.user');
        $datatable->buildDatatable(array(
            'entity' => $this->container->getParameter('fos_user.model.user.class'),
            'delay'  => $this->container->getParameter('olix.security.activity.delay'),
        ));
        
        $query = $this->get('sg_datatables.query')->getQueryFrom($datatable);
        
        return $query->getResponse();
    }
616172
public function result()
    {

        // Don't bother if it didn't go well
        if ($this->_res == false) {
            return false;
        }

        // it did; continue
        else {

            // Store rows here
            $rows = [];

            // start off printers list
            $rows[] = array(
                'type' => 'header',
                'columns' => array(
                    array(5, 'Printers'),
                ),
            );
            $rows[] = array(
                'type' => 'header',
                'columns' => array(
                    'Name',
                    array(4, 'Status'),
                ),
            );

            // show printers if we have them
            if (count($this->_res['printers']) == 0) {
                $rows[] = array('type' => 'none', 'columns' => array(array(5, 'None found')));
            } else {
                foreach ($this->_res['printers'] as $printer) {
                    $rows[] = array(
                        'type' => 'values',
                        'columns' => array(
                            $printer['name'],
                            array(4, $printer['status']),
                        ),
                    );
                }
            }

            // show printer queue list
            $rows[] = array(
                'type' => 'header',
                'columns' => array(
                    array(5, 'Queue'),
                ),
            );

            $rows[] = array(
                'type' => 'header',
                'columns' => array(
                    'Rank',
                    'Owner',
                    'Job',
                    'Files',
                    'Size',
                ),
            );

            // Go through each item in the lsit
            if (count($this->_res['queue']) == 0) {
                $rows[] = array('type' => 'none', 'columns' => array(array(5, 'Empty')));
            } else {
                foreach ($this->_res['queue'] as $job) {
                    $rows[] = array(
                        'type' => 'values',
                        'columns' => array(
                            $job['rank'],
                            $job['owner'],
                            $job['job'],
                            $job['files'],
                            $job['size'],
                        ),
                    );
                }
            }

            // give info
            return array(
                'root_title' => 'CUPS Printer Status',
                'rows' => $rows,
            );
        }
    }
225471
public function loadResult()
	{
		$this->connect();

		$ret = null;

		// Execute the query and get the result set cursor.
		if (!($cursor = $this->execute()))
		{
			return null;
		}

		// Get the first row from the result set as an array.
		$row = $this->fetchArray($cursor);

		if ($row)
		{
			$ret = $row[0];
		}

		// Free up system resources and return.
		$this->freeResult($cursor);

		return $ret;
	}
843664
public function getResults()
    {
        if(!$this->statManager->checkStatus()){
            $this->runValidation($this->options);
        }
        return $this->statManager->getStatus();
    }
867954
public function getSessionValidationResult()
    {
        $resultData = $this->getSession()->get("FormInfo.{$this->FormName()}.result");
        if (isset($resultData)) {
            return unserialize($resultData);
        }
        return null;
    }
974451
function get_result() {
        $off = $this->_off;
        $len = $this->_len;
        $txt = $this->_txt;
        $this->_res = array();
        while (($off < $len) && (ord($txt[$off]) <= 0x20)) {
            if ($txt[$off] == "\r" || $txt[$off] == "\n") {
                $this->_off = $off + 1;
                $this->_put_res($off, 0, 1, 'un');
                return $this->_res;
            }
            $off++;
        }
        if ($off >= $len) return false;
        // try to parse the sentence
        $this->_off = $off;
        $ch = $txt[$off];
        $cx = ord($ch);
        if ($this->_char_token($ch)) {
            $this->_off++;
            $this->_put_res($off, 0, 1, 'un');
            return $this->_res;
        }
        $clen = $this->_ztab[$cx];
        $zlen = 1;
        $pflag = ($clen > 1 ? PSCWS4_PFLAG_WITH_MB : ($this->_is_alnum($cx) ? PSCWS4_PFLAG_ALNUM : 0));
        while (($off = ($off + $clen)) < $len) {
            $ch = $txt[$off];
            $cx = ord($ch);
            if ($cx <= 0x20 || $this->_char_token($ch)) break;
            $clen = $this->_ztab[$cx];
            if (!($pflag & PSCWS4_PFLAG_WITH_MB)) {
                // pure single-byte -> multibyte (2bytes)
                if ($clen == 1) {
                    if (($pflag & PSCWS4_PFLAG_ALNUM) && !$this->_is_alnum($cx))
                        $pflag ^= PSCWS4_PFLAG_ALNUM;
                } else {
                    if (!($pflag & PSCWS4_PFLAG_ALNUM) || $zlen > 2) break;
                    $pflag |= PSCWS4_PFLAG_WITH_MB;
                }
            } else if (($pflag & PSCWS4_PFLAG_WITH_MB) && $clen == 1) {
                // mb + single-byte. allowd: alpha+num + 中文
                if (!$this->_is_alnum($cx)) break;
                $pflag &= ~PSCWS4_PFLAG_VALID;
                for ($i = $off + 1; $i < ($off + 3); $i++) {
                    $ch = $txt[$i];
                    $cx = ord($ch);
                    if (($i >= $len) || ($cx <= 0x20) || ($this->_ztab[$cx] > 1)) {
                        $pflag |= PSCWS4_PFLAG_VALID;
                        break;
                    }
                    if (!$this->_is_alnum($cx)) break;
                }
                if (!($pflag & PSCWS4_PFLAG_VALID)) break;
                $clen += ($i - $off - 1);
            }
            // hightman.070813: add max zlen limit
            if (++$zlen >= PSCWS4_MAX_ZLEN) break;
        }
        // hightman.070624: 处理半个字的问题
        if (($ch = $off) > $len)
            $off -= $clen;
        // do the real segment
        if ($off <= $this->_off) return false;
        else if ($pflag & PSCWS4_PFLAG_WITH_MB) $this->_msegment($off, $zlen);
        else if (!($pflag & PSCWS4_PFLAG_ALNUM) || (($off - $this->_off) >= PSCWS4_MAX_EWLEN)) $this->_ssegment($off);
        else {
            $zlen = $off - $this->_off;
            $this->_put_res($this->_off, 2.5 * log($zlen), $zlen, 'en');
        }
        // reutrn the result
        $this->_off = ($ch > $len ? $len : $off);
        if (count($this->_res) == 0)
            return $this->get_result();
        return $this->_res;
    }
347127
public function getResultForMultiStatus()
    {
        $r = [
            200 => [],
            404 => [],
        ];
        foreach ($this->result as $propertyName => $info) {
            if (!isset($r[$info[0]])) {
                $r[$info[0]] = [$propertyName => $info[1]];
            } else {
                $r[$info[0]][$propertyName] = $info[1];
            }
        }
        // Removing the 404's for multi-status requests.
        if (self::ALLPROPS === $this->requestType) {
            unset($r[404]);
        }

        return $r;
    }
744140
public function getResult()
    {
        if (!$this->isDone() || is_null($this->lastProtoResponse->getResponse())) {
            return null;
        }

        /** @var Any $anyResponse */
        $anyResponse = $this->lastProtoResponse->getResponse();
        if (is_null($this->operationReturnType)) {
            return $anyResponse;
        }
        $operationReturnType = $this->operationReturnType;
        /** @var Message $response */
        $response = new $operationReturnType();
        $response->mergeFromString($anyResponse->getValue());
        return $response;
    }
171721
public function getResults()
    {
        $skip = ($this->page-1)*$this->limit;
        
        $cursor = $this->getCursor();
        $cursor->skip($skip);

        $results = array();
        $i = 0;

        while($cursor->valid() && $cursor->current() && $i++ < $this->limit) {

            $object = new $this->modelName();
            $object->writeAttributes($cursor->current());

            $pseudoCursor = new \stdClass();
            foreach ($object as $key => $value) {
                $pseudoCursor->$key = $value;
            }

            $results[] = $pseudoCursor;
            $cursor->skip();
        }

        return $results;
    }
254865
public function getSingleResult()
    {
        $originalLimit = $this->limit;
        $originalUseIdentifierKeys = $this->useIdentifierKeys;

        $this->reset();
        $this->limit(1);
        $this->setUseIdentifierKeys(false);

        $result = current($this->toArray()) ?: null;

        $this->reset();
        $this->limit($originalLimit);
        $this->setUseIdentifierKeys($originalUseIdentifierKeys);

        return $result;
    }
1051564
public function execute() {
        if (!$this->checkExists()) {
            if ($this->current === self::OP_SELECT) {
                return new ArrayCollection();
            }

            return false;
        }
        $this->createQuery();

        $model = ($this->expected) ? $this->getRowModel() : null;
        if ($this->current === self::OP_SELECT && $this->isCached()) {
            $result = $this->getCached();
        }
        if (!$result) {
            if ($this->preserveQueries && $this->current !== self::OP_SELECT) // keep all queries except selects
                    $this->doPreserveQueries();
            $result = $this->connection->doPrepare($this->query, $this->values,
                    array(
                'multipleRows' => $this->multiple,
                'model' => $model
            ));

            if ($this->current === self::OP_SELECT) $this->saveCache($result);
            else $this->removeCache();
        }

        if ($this->current === self::OP_SELECT)
                $result = $this->returnSelect($result);
        $this->lastQuery = $this->query . '<pre><code>' . print_r($this->values,
                        true) . '</code></pre>';
        $this->resetQuery();
        return $result;
    }