Resumes reading after a call to pauseRecv.

@return void
329027
public function resumeRecv()
    {
        if ($this->_isPaused === true) {
            Worker::$globalEvent->add($this->_socket, EventInterface::EV_READ, array($this, 'baseRead'));
            $this->_isPaused = false;
            $this->baseRead($this->_socket, false);
        }
    }
241092
public function rewind()
    {
        $this->file->rewind();
        if (null !== $this->headerRowNumber) {
            $this->file->seek($this->headerRowNumber + 1);
        }
    }
11592
public function pause()
    {
        if ($this->paused) { return $this; }
        $this->input->pause();
        $this->paused = true;
        $this->emit('pause');
        return $this;
    }
155654
private function resume()
    {
        $newChangeStream = call_user_func($this->resumeCallable, $this->resumeToken);
        $this->csIt = $newChangeStream->csIt;
        $this->csIt->rewind();
    }
1082523
protected function handleRead()
    {
        if ($this->paused)
        {
            return;
        }

        $data = @fread($this->resource, static::BUFFER_SIZE);

        if ($data === false || $data === '')
        {
            return;
        }

        $this->buffer .= $data;

        while ($this->buffer !== '')
        {
            if ($this->prefix !== '' && !isset($this->resources[$this->prefix]))
            {
                $this->prefix = '';
            }

            if ($this->prefix === '')
            {
                if (!preg_match('/([a-zA-Z0-9]{32})\r?\n(.*)/s', $this->buffer, $matches))
                {
                    return;
                }

                $this->prefix = $matches[1];
                $this->buffer = $matches[2];
            }

            $resource = $this->resources[$this->prefix];
            $data = '';
            $status = -1;
            $successSuffix = $resource->getSuccessSuffix();
            $failureSuffix = $resource->getFailureSuffix();

            $this->buffer = preg_replace_callback(
                sprintf('/(.*)(%s|%s):(\d*)\r?\n/s', $successSuffix, $failureSuffix),
                function($matches) use($resource, &$data, &$status) {
                    $data   = $matches[1];
                    $status = (int) $matches[3];
                    return '';
                },
                $this->buffer
            );

            if ($status === -1)
            {
                $data = $this->buffer;
                $this->buffer = '';
            }
            else
            {
                $this->removeResource($this->prefix);
                $this->prefix = '';
            }

            $parts = str_split($data, $resource->getBufferSize());
            unset($data);

            foreach ($parts as &$part)
            {
                $resource->emit('data', [ $resource, $part ]);
            }
            unset($parts);
            unset($part);

            if ($status === 0)
            {
                $resource->emit('end', [ $resource ]);
                $resource->close();
            }
            else if ($status > 0)
            {
                $resource->emit('error', [ $resource, new ReadException($status) ]);
                $resource->close();
            }
        }

        $this->handleRead();
    }
123887
public function onRead()
    {
        while (!is_null($line = $this->readline())) {
            $finish =
                (mb_orig_strpos($line, $s = "\xff\xf4\xff\xfd\x06") !== false)
                || (mb_orig_strpos($line, $s = "\xff\xec") !== false)
                || (mb_orig_strpos($line, $s = "\x03") !== false)
                || (mb_orig_strpos($line, $s = "\x04") !== false);

            $e = explode(' ', rtrim($line, "\r\n"), 2);

            $cmd = trim($e[0]);

            if ($cmd === 'ping') {
                $this->writeln('pong');
            } elseif (
                ($cmd === 'exit')
                || ($cmd === 'quit')
            ) {
                $this->finish();
            } else {
                $this->writeln('Unknown command "' . $cmd . '"');
            }

            if (
                (mb_orig_strlen($line) > 1024)
                || $finish
            ) {
                $this->finish();
            }
        }
    }
564646
public synchronized void resumeReceives() {
        receivesSuspended = false;if(Thread.currentThread() == channel.getIoThread()) {
            doResume();
        } else {
            channel.getIoThread().execute(new Runnable() {
                @Override
                public void run() {
                    doResume();
                }
            });
        }
    }
764330
public function onRead()
    {
        start:
        if ($this->type === 'udp') {
            $this->onUdpPacket($this->read($this->getInputLength()));
            return;
        }
        if ($this->state === self::STATE_ROOT) {
            if (false === ($hdr = $this->readExact(2))) {
                return; // not enough data
            }
            $this->pctSize = Binary::bytes2int($hdr);
            $this->setWatermark($this->pctSize);
            $this->state = self::STATE_PACKET;
        }
        if ($this->state === self::STATE_PACKET) {
            if (false === ($pct = $this->readExact($this->pctSize))) {
                return; // not enough data
            }
            $this->state = self::STATE_ROOT;
            $this->setWatermark(2);
            $this->onUdpPacket($pct);
        }
        goto start;
    }
889575
public function rewind()
    {
        $this->parser->setOffset($this->offset);
        $this->position = -1;
        $this->next();
    }
829710
private function _process_paused() {

        // copy all requests to another variable
        $urls = $this->_requests;

        // while there are URLs to process
        while (!empty($urls)) {

            // get from the entire list of requests as many as specified by the "threads" property
            $this->_requests = array_splice($urls, 0, $this->threads, array());

            // process those requests
            $this->_process();

            // wait for as many seconds as specified by the "pause_interval" property
            if (!empty($urls)) sleep($this->pause_interval);

        }

    }
927572
function pause() {
        $this->paused = true;
        
        if($this->started && !$this->closed) {
            $this->driver->pauseStreamConsumption();
        }
    }
563996
private function resumeSection()
    {
        $this->session->resume();

        if (!isset($_SESSION[$this->name])) {
            $_SESSION[$this->name] = [];
        }
    }
38353
protected function readFrame(): void
    {
        $header = $this->forceRead(8);

        if (\strlen($header) < 8) {
            return;
        }

        $decoded = \unpack('C1type/C3/N1size', $header);
        $output = $this->forceRead($decoded['size']);
        $callbackList = [];

        if (0 === $decoded['type']) {
            $callbackList = $this->onStdinCallables;
        }

        if (1 === $decoded['type']) {
            $callbackList = $this->onStdoutCallables;
        }

        if (2 === $decoded['type']) {
            $callbackList = $this->onStderrCallables;
        }

        foreach ($callbackList as $callback) {
            $callback($output);
        }
    }
1231631
public function rewind()
    {
        $this->xmlReader = new \XMLReader();
        $this->xmlReader->open($this->inputFile);
        $this->currentElement   = null;
        $this->currentElementId = null;
    }
1065666
public function rewind()
    {
        if ($this->cacheFilesIterator === null) {
            $this->cacheFilesIterator = new \DirectoryIterator($this->cacheDirectory);
        }
        $this->cacheFilesIterator->rewind();
        while (substr($this->cacheFilesIterator->getFilename(), 0, 1) === '.' && $this->cacheFilesIterator->valid()) {
            $this->cacheFilesIterator->next();
        }
    }
650925
private function read()
    {
        flock($this->file, LOCK_SH);
        rewind($this->file);
        $content = fgets($this->file);
        flock($this->file, LOCK_UN);

        $this->records = unserialize($content);
    }
642569
public function rewind()
        {
            rewind($this->_getFilePointer());

            $this->_currentRow = $this->_readLine();
            $this->_rowCounter = 0;
        }