Treat consecutive packets as if they are a discontinuous buffer.

The default behavior.

@see \phpseclib\Crypt\Base::disableContinuousBuffer()
@see self::enableContinuousBuffer()
@access public
541849
function disableContinuousBuffer()
    {
        parent::disableContinuousBuffer();
        if ($this->mode_3cbc) {
            $this->des[0]->disableContinuousBuffer();
            $this->des[1]->disableContinuousBuffer();
            $this->des[2]->disableContinuousBuffer();
        }
    }
423817
protected function flow(): void
	{
		// Erase output buffers and disable output buffering

		while(ob_get_level() > 0) ob_end_clean();

		// Send the stream

		$stream = $this->stream;

		$stream($this);

		// Send empty chunk to tell the client that we're done

		$this->flush(null, true);
	}
666364
public function enableRateLimiting(int $cycle = null, int $buffer = null)
    {
        $this->rateLimitingEnabled = true;

        if (!is_null($cycle)) {
            $this->rateLimitCycle = $cycle;
        }

        if (!is_null($cycle)) {
            $this->rateLimitCycleBuffer = $buffer;
        }

        return $this;
    }
613652
public function peek() {
		if ($this->_buffer) {
			return reset($this->_buffer);
		}
		if (!$next = $this->_fetch()) {
			return null;
		}
		$this->_buffer[] = $next;
		$first = reset($this->_buffer);
		return end($first);
	}
178606
private final void flushBuffer() throws IOException {
		if (bufOutput.position() > 0) {
			bufOutput.flip();
			fcOutput.write(bufOutput);
			bufOutput.clear();
			// log.debug("offsetOutputUncommited=" + offsetOutputUncommited + " offsetOutputCommited=" +
			// offsetOutputCommited + " fcOutput.position()=" + fcOutput.position());
			offsetOutputUncommited = offsetOutputCommited = fcOutput.position();
			if (syncOnFlush) {
				fcOutput.force(false);
				if (callback != null) {
					callback.synched(offsetOutputCommited);
				}
			}
		}
	}
231135
public function setPersistentSocket($b)
    {
        $was_persistent = ($this->_sock && $this->_persistentSocket);
        $this->_persistentSocket = (boolean)$b;
        if (!$this->_persistentSocket && $was_persistent) {
            fclose($this->_sock);
        }
    }
187
protected function flush($maxBufferLevel = null)
    {
        if (null === $maxBufferLevel) {
            $maxBufferLevel = ob_get_level();
        }

        while (ob_get_level() > $maxBufferLevel) {
            ob_end_flush();
        }
    }
193332
protected function flush()
    {
        $node = null;

        $this->isCode = false;

        if ($this->buffer) {
            switch ($this->state) {
            case self::STATE_TITLE:
                $data = implode("\n", $this->buffer);
                $level = $this->environment->getLevel($this->specialLetter);
                $token = $this->environment->createTitle($level);
                $node = $this->kernel->build('Nodes\TitleNode', $this->createSpan($data), $level, $token);
                break;
            case self::STATE_SEPARATOR:
                $level = $this->environment->getLevel($this->specialLetter);
                $node = $this->kernel->build('Nodes\SeparatorNode', $level);
                break;
            case self::STATE_CODE:
                $node = $this->kernel->build('Nodes\CodeNode', $this->buffer);
                break;
            case self::STATE_BLOCK:
                $node = $this->kernel->build('Nodes\QuoteNode', $this->buffer);
                $data = $node->getValue();
                $subParser = $this->getSubParser();
                $document = $subParser->parseLocal($data);
                $node->setValue($document);
                break;
            case self::STATE_LIST:
                $this->pushListLine(null, true);
                $node = $this->buffer;
                break;
            case self::STATE_TABLE:
                $node = $this->buffer;
                $node->finalize($this);
                break;
            case self::STATE_NORMAL:
                $this->isCode = $this->prepareCode();
                $node = $this->kernel->build('Nodes\ParagraphNode', $this->createSpan($this->buffer));
                break;
            }
        }

        if ($this->directive) {
            $currentDirective = $this->getCurrentDirective();
            if ($currentDirective) {
                $currentDirective->process($this, $node, $this->directive['variable'], $this->directive['data'], $this->directive['options']);
            }
            $node = null;
        }

        $this->directive = null;

        if ($node) {
            $this->document->addNode($node);
        }

        $this->init();
    }
829414
public function end()
    {
        if ($this->_discardActiveBufferOnEnd) {
            $this->_discardActiveBufferOnEnd = false;
            ob_end_clean();

            return;
        }
        if ($this->_active) {
            $mode = end($this->_active);
            $active = key($this->_active);
            $content = ob_get_clean();
            if ($mode === ViewBlock::OVERRIDE) {
                $this->_blocks[$active] = $content;
            } else {
                $this->concat($active, $content, $mode);
            }
            array_pop($this->_active);
        }
    }
420949
protected function acceptUnknowBrackets()
    {
        $level  = 0;
        $result = '';

        do
        {
            switch ( $this->buffer[0] )
            {
                case '{':
                    $level++;
                    $result .= '{';
                    $this->buffer = substr( $this->buffer, 1 );
                    break;

                case '}':
                    $level--;
                    $result .= '}';
                    $this->buffer = substr( $this->buffer, 1 );
                    break;

                default:
                    $newBuffer = preg_replace(
                        '/^[^\{\}]+/', '',
                        $this->buffer
                    );

                    $result .= substr(
                        $this->buffer,
                        0,
                        strlen( $this->buffer ) - strlen( $newBuffer )
                    );

                    $this->buffer = $newBuffer;
                    break;
            }
        }
        while ( $level > 0 );

        return $result;
    }
1144106
public function endChunk() 
    {
        // Compute Crc32 for type + data
        $data = $this->buffer;
        $crc = crc32($data);

        $this->buffer = 
            $this->chunkPreviousBuffer .
            
            // Length
            pack('N', strlen($data) - 4) .

            // Content 
            $data .

            // Crc32
            pack('N', $crc);
    }
516856
function disableContinuousBuffer()
    {
        $this->continuousBuffer = false;
        $this->encryptIV = $this->iv;
        $this->decryptIV = $this->iv;

        if ($this->mode == CRYPT_DES_MODE_3CBC) {
            $this->des[0]->disableContinuousBuffer();
            $this->des[1]->disableContinuousBuffer();
            $this->des[2]->disableContinuousBuffer();
        }
    }
1120371
private void advanceBufferIfNecessary() {
    ReadableBuffer buffer = buffers.peek();
    if (buffer.readableBytes() == 0) {
      buffers.remove().close();
    }
  }
1318158
private void disableRed() throws IOException {
		byte[] dis = "\u001B[0m".getBytes();
		super.write(dis, 0, dis.length);
		writing = false;
	}
870054
protected function controlAccessExecuteCron()
    {
        if (strcmp($this->getQuery('key', ''), $this->cron->getKey()) !== 0) {
            $this->response->outputError403(false);
        }
    }
413351
protected function ackOrNackBlock()
    {
        if (! $this->lastDeliveryTag) {
            return;
        }

        $result = $this->flushDeferred();

        switch ($result) {
            case FlushDeferredResult::MSG_ACK():
                $this->ack();
                break;
            case FlushDeferredResult::MSG_REJECT():
                $this->nackAll(false);
                break;
            case FlushDeferredResult::MSG_REJECT_REQUEUE():
                $this->nackAll(true);
                break;
        }
    }
1332637
protected static function _buffer($queue){
        $should_flush_buffer = false;

        $event_buffer_counted       = self::$_busy_event_buffer_counter + self::$_idle_event_buffer_counter;
        $event_buffer_time_consumed = time() - self::$_buffer_last_flush_ts;

        if ( $event_buffer_counted >= self::$_event_buffer_count_limit) {
            self::log('[ Info ] event buffer counter limit reached . time cost : ' .$event_buffer_time_consumed);
            $should_flush_buffer = true;
        }

        if ( $event_buffer_time_consumed >= self::$_event_buffer_time_limit ) {
            self::log('[ Info ] event buffer time limit reached .');
            $should_flush_buffer = true;
        }

        if ($should_flush_buffer) {
            self::log('[ Info ] start flushing to redis...');
            self::_flush($queue);
        }
    }