Override the parent, this protocol is returned differently

@param Buffer $buffer
@param Result $result

@see Gamespy3::processPlayersAndTeams()
357287
protected function processPlayersAndTeams(Buffer &$buffer, Result &$result)
    {
        // Loop until we run out of data
        while ($buffer->getLength()) {
            $result->addPlayer('name', $buffer->readString());
            $result->addPlayer('steamid', $buffer->readString());
            $result->addPlayer('ping', $buffer->readInt16());
        }
    }
286104
protected function processPlayersAndTeams(Buffer &$buffer, Result &$result)
    {

        /*
         * Explode the data into groups. First is player, next is team (item_t)
         * Each group should be as follows:
         *
         * [0] => item_
         * [1] => information for item_
         * ...
         */
        $data = explode("\x00\x00", $buffer->getBuffer());

        // By default item_group is blank, this will be set for each loop thru the data
        $item_group = '';
        // By default the item_type is blank, this will be set on each loop
        $item_type = '';
        // Loop through all of the $data for information and pull it out into the result
        for ($x = 0; $x < count($data) - 1; $x++) {
            // Pull out the item
            $item = $data[$x];
            // If this is an empty item, move on
            if ($item == '' || $item == "\x00") {
                continue;
            }
            /*
            * Left as reference:
            *
            * Each block of player_ and team_t have preceding junk chars
            *
            * player_ is actually \x01player_
            * team_t is actually \x00\x02team_t
            *
            * Probably a by-product of the change to exploding the data from the original.
            *
            * For now we just strip out these characters
            */
            // Check to see if $item has a _ at the end, this is player info
            if (substr($item, -1) == '_') {
                // Set the item group
                $item_group = 'players';
                // Set the item type, rip off any trailing stuff and bad chars
                $item_type = rtrim(str_replace("\x01", '', $item), '_');
            } elseif (substr($item, -2) == '_t') {
                // Check to see if $item has a _t at the end, this is team info
                // Set the item group
                $item_group = 'teams';
                // Set the item type, rip off any trailing stuff and bad chars
                $item_type = rtrim(str_replace(["\x00", "\x02"], '', $item), '_t');
            } else {
                // We can assume it is data belonging to a previously defined item

                // Make a temp buffer so we have easier access to the data
                $buf_temp = new Buffer($item, Buffer::NUMBER_TYPE_BIGENDIAN);
                // Get the values
                while ($buf_temp->getLength()) {
                    // No value so break the loop, end of string
                    if (($val = $buf_temp->readString()) === '') {
                        break;
                    }
                    // Add the value to the proper item in the correct group
                    $result->addSub($item_group, $item_type, utf8_encode(trim($val)));
                }
                // Unset our buffer
                unset($buf_temp);
            }
        }
        // Free up some memory
        unset($data, $item, $item_group, $item_type, $val);
    }
421999
protected static function processingApiResult($endpoint, array $result)
    {
        if (!isset($result['return_code']) || $result['return_code'] != 'SUCCESS') {
            throw new GatewayException(
                'Get Wechat API Error:'.($result['return_msg'] ?? $result['retmsg'] ?? ''),
                $result
            );
        }

        if (isset($result['result_code']) && $result['result_code'] != 'SUCCESS') {
            throw new BusinessException(
                'Wechat Business Error: '.$result['err_code'].' - '.$result['err_code_des'],
                $result
            );
        }

        if ($endpoint === 'pay/getsignkey' ||
            strpos($endpoint, 'mmpaymkttransfers') !== false ||
            self::generateSign($result) === $result['sign']) {
            return new Collection($result);
        }

        Events::dispatch(Events::SIGN_FAILED, new Events\SignFailed('Wechat', '', $result));

        throw new InvalidSignException('Wechat Sign Verify FAILED', $result);
    }
93105
protected function processDetails(Buffer &$buffer, Result &$result)
    {
        parent::processDetails($buffer, $result);

        // Add in map
        $result->add('mapname', 'Panau');
        $result->add('dedicated', 'true');
    }
123755
public function renderOnSuccess($result, SilexKernel $silexKernel)
    {
        if (is_object($result) && method_exists($result, '__toString')) {
            $result = (string)$result;
        }
        elseif (is_bool($result)) {
            $result = $result ? "true" : "false";
        }
        elseif (is_scalar($result)) {
            $result = (string)$result;
        }
        elseif (is_array($result)) {
            $result = nl2br(str_replace(' ', '&nbsp;', json_encode($result, JSON_PRETTY_PRINT)));
        }
        elseif (!is_string($result)) {
            return $this->renderOnException(
                new WrappedExceptionInfo(
                    new \RuntimeException("Unsupported type of result: " . print_r($result, true)),
                    Response::HTTP_INTERNAL_SERVER_ERROR
                ),
                $silexKernel
            );
        }
        
        return new Response($result);
    }
877630
protected function processChannelsAndUsers(array $data, Result &$result)
    {

        // Let's add all of the channel information
        foreach ($data as $key => $value) {
            // We will handle these later
            if (in_array($key, ['channels', 'users'])) {
                // skip
                continue;
            }

            // Add the channel property as a team
            $result->addTeam($key, $value);
        }

        // Itereate over the users in this channel
        foreach ($data['users'] as $user) {
            foreach ($user as $key => $value) {
                $result->addPlayer($key, $value);
            }
        }

        // Offload more channels to parse
        foreach ($data['channels'] as $channel) {
            $this->processChannelsAndUsers($channel, $result);
        }
    }
122357
protected function processDetails(Buffer &$buffer, Result &$result)
    {

        // We go until we hit an empty key
        while ($buffer->getLength()) {
            $key = $buffer->readString();
            if (strlen($key) == 0) {
                break;
            }
            $result->add($key, utf8_encode($buffer->readString()));
        }
    }
540759
public function apply(array $result, Server $server)
    {

        // No result passed so just return
        if (empty($result)) {
            return $result;
        }

        //$data = [];
        //$data['raw'][ $server->id() ] = $result;

        // Switch based on the base (not game) protocol
        switch ($server->protocol()->getProtocol()) {
            case 'quake2':
            case 'quake3':
            case 'doom3':
                array_walk_recursive($result, [$this, 'stripQuake']);
                break;
            case 'unreal2':
            case 'ut3':
            case 'gamespy3':  //not sure if gamespy3 supports ut colors but won't hurt
            case 'gamespy2':
                array_walk_recursive($result, [$this, 'stripUnreal']);
                break;
        }

        /*$data['filtered'][ $server->id() ] = $result;
        file_put_contents(
            sprintf(
                '%s/../../../tests/Filters/Providers/Stripcolors\%s_1.json',
                __DIR__,
                $server->protocol()->getProtocol()
            ),
            json_encode($data, JSON_UNESCAPED_UNICODE | JSON_PARTIAL_OUTPUT_ON_ERROR)
        );*/

        // Return the stripped result
        return $result;
    }
1136049
protected function realMatchRoute(ResultInterface $result)/*# : bool */
    {
        $res = false;
        $param = ['result' => $result];
        if ($this->trigger(self::EVENT_BEFORE_MATCH, $param) &&
            $this->match($result) &&
            $this->trigger(self::EVENT_AFTER_MATCH, $param)
        ) {
            $res = true;
        }

        $this->setCollectorHandler($result);
        return $res;
    }
275840
protected function writeBufferedOutput(BufferedOutput $buffer, $result)
    {
        if ($result === 0 && $buffer->getVerbosity() < OutputInterface::VERBOSITY_VERBOSE) {
            return;
        }

        $this->io->write($buffer->fetch());
    }
794014
protected function processPlayers(Buffer $buffer)
    {

        // Decode into items
        $items = $this->decode($buffer);

        // Set the result to a new result instance
        $result = new Result();

        // Number of data points per player
        $numTags = $items[1];

        // Grab the tags for each player
        $tags = array_slice($items, 2, $numTags);

        // Get the player count
        $playerCount = $items[$numTags + 2];

        // Iterate over the index until we run out of players
        for ($i = 0, $x = $numTags + 3; $i < $playerCount; $i++, $x += $numTags) {
            // Loop over the player tags and extract the info for that tag
            foreach ($tags as $index => $tag) {
                $result->addPlayer($tag, $items[($x + $index)]);
            }
        }

        return $result->fetch();
    }
1249730
protected function processKeyValuePairs(Buffer &$buffer, Result &$result)
    {

        // Key / value pairs
        while ($buffer->getLength()) {
            $key = $buffer->readPascalString(1, true);

            // If we have an empty key, we've reached the end
            if (empty($key)) {
                break;
            }

            // Otherwise, add the pair
            $result->add(
                $key,
                $buffer->readPascalString(1, true)
            );
        }

        unset($key);
    }
593563
protected function getChildrenRecursive($name, &$result)
    {
        if (isset($this->_children[$name])) {
            foreach ($this->_children[$name] as $child) {
                $result[$child] = true;
                $this->getChildrenRecursive($child, $result);
            }
        }
    }
1147198
public function afterProcess(&$result)
    {
        if ($this->hasEventHandlers(self::EVENT_AFTER_PROCESS)) {
            $event = new ProcessEvent($this->message, $this->getWechat());
            $event->result = $result;
            $this->trigger(self::EVENT_AFTER_PROCESS, $event);
            $result = $event->result;
        }
    }
70833
private function postExecute($result): ExecutionResult
    {
        if ($result instanceof Promise) {
            $result = $this->promiseAdapter->wait($result);
        }

        $this->checkExecutionResult($result);

        return $this->dispatcher->dispatch(Events::POST_EXECUTOR, new ExecutorResultEvent($result))->getResult();
    }
1325973
protected function processPlayer($data, $fieldCount, Result &$result)
    {

        // Split the items on the comma
        $items = explode(",", $data, $fieldCount);

        // Iterate over the items for this player
        foreach ($items as $item) {
            // Split the key=value pair
            list($key, $value) = explode("=", $item, 2);

            $result->addPlayer(strtolower($key), utf8_encode($value));
        }
    }
214791
private void fireResultAdded(Result child, Result parent) {
    if(LOG.isDebugging()) {
      LOG.debug("Result added: " + child + " <- " + parent);
    }
    for(int i = listenerList.size(); --i >= 0;) {
      listenerList.get(i).resultAdded(child, parent);
    }
  }