Treat consecutive packets as if they are a discontinuous buffer.

The default behavior.

@see Crypt_TripleDES::enableContinuousBuffer()
@access public
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();
        }
    }
1332473
public static function startOutputBuffer()
    {
        if (ob_get_level() > 1) {
            return;
        }
        
        $outputCallback = null;
        if (GZIP_SUPPORTED && !DISABLE_GZIP) {
            $outputCallback = 'ob_gzhandler';
        }
        
        if (in_array($outputCallback, ob_list_handlers())) {
            return; // don't start same handler twice
        }
        
        ob_start($outputCallback);
    }
1127744
public function unserialize($buffer)
    {
        $this->__construct([]);
        $this->_buffer = unserialize($buffer);
        $this->_started = true;
        $this->_finished = true;
    }
210736
public WrappedByteBuffer putBuffer(WrappedByteBuffer v) {
        _autoExpand(v.remaining());
        _buf.put(v._buf);
        return this;
    }
9176
protected static function process_buffer() {
        // Reset the buffers first in case we get exception from processor.
        $messages = self::$buffer;
        self::$buffer = array();
        $convmessages = self::$convmessagebuffer;
        self::$convmessagebuffer = array();

        foreach ($messages as $message) {
            list($eventdata, $savemessage, $processorlist) = $message;
            self::send_message_to_processors($eventdata, $savemessage, $processorlist);
        }

        foreach ($convmessages as $convmessage) {
            list($eventprocmap, $eventdata, $savemessage) = $convmessage;
            self::send_conversation_message_to_processors($eventprocmap, $eventdata, $savemessage);
        }
    }
541849
function disableContinuousBuffer()
    {
        parent::disableContinuousBuffer();
        if ($this->mode_3cbc) {
            $this->des[0]->disableContinuousBuffer();
            $this->des[1]->disableContinuousBuffer();
            $this->des[2]->disableContinuousBuffer();
        }
    }
758276
public static function enable()
    {
        self::$startValues = array(
            'time' => microtime(true),
            'realmem' => memory_get_usage(true),
            // 'emalloc' => memory_get_usage(false)
        );
        self::$_enabled = true;
    }
183508
protected function bufferize($types = [])
    {
        while (true) {
            $this->buffer = $this->findNextMessages($types);

            if (\count($this->buffer) > 0) {
                break;
            }

            usleep($this->pause);
        }
    }
818909
protected AbstractBuffer reset(long offset, long capacity, long maxCapacity) {
    this.offset = offset;
    this.capacity = 0;
    this.initialCapacity = capacity;
    this.maxCapacity = maxCapacity;
    capacity(initialCapacity);
    references.set(0);
    rewind();
    return this;
  }
429015
public void resetBuffer()
    {
        if (isCommitted())
            throw new IllegalStateException("Committed");
        
        ((HttpOutputStream)_httpResponse.getOutputStream()).resetBuffer();
        if (_writer!=null) _writer.reset();
    }
864726
public function allowsRecursion(): bool
    {
        foreach ($this->resolvers as $resolver) {
            if ($resolver->allowsRecursion()) {
                return true;
            }
        }

        return false;
    }
220579
public void setBuffer (byte[] bytes, int offset, int count) {
		if (bytes == null) throw new IllegalArgumentException("bytes cannot be null.");
		buffer = bytes;
		position = offset;
		limit = offset + count;
		capacity = bytes.length;
		total = 0;
		inputStream = null;
	}
910355
public function commitBuffer(): void
    {
        if (!$this->buffering) {
            throw new \RuntimeException('Not buffering.');
        }
        $this->buffering = false;
        if ($this->changed) {
            $this->xliff->save($this->filename);
            $this->changed = false;
        }
    }
357013
private function flushBuffer()
    {
        $bufferLength = $this->numberOfBytes($this->buffer);
        if ($bufferLength == 0) {
            return;
        }

        $bytesWritten = $this->decoratedObject->write($this->buffer);
        if ($bytesWritten < $bufferLength) {
            throw new \RuntimeException(
                sprintf(
                    'Expected to flush buffer of %d bytes but only %d bytes were written.',
                    $bufferLength,
                    $bytesWritten
                )
            );
        }

        $this->buffer = '';
    }
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);
	}
1232113
public function setContiguous($contiguous = FALSE)
	{
		$this->_contiguous = (bool) $contiguous;
		if (!$contiguous) {
			$this->_contiguousRow = -1;
		}

		return $this;
	}
119518
public void wrap(final MutableDirectBuffer buffer, final int offset)
    {
        Objects.requireNonNull(buffer, "Buffer must not be null");
        if (!buffer.isExpandable())
        {
            throw new IllegalStateException("buffer must be expandable.");
        }

        this.buffer = buffer;
        this.offset = offset;
        this.position = 0;
    }