Current Path : C:/xampp/htdocs/moodle/lib/horde/framework/Horde/ |
Current File : C:/xampp/htdocs/moodle/lib/horde/framework/Horde/Stream.php |
<?php /** * Copyright 2012-2017 Horde LLC (http://www.horde.org/) * * See the enclosed file LICENSE for license information (LGPL). If you * did not receive this file, see http://www.horde.org/licenses/lgpl21. * * @category Horde * @copyright 2012-2017 Horde LLC * @license http://www.horde.org/licenses/lgpl21 LGPL 2.1 * @package Stream */ /** * Object that adds convenience/utility methods to interacting with PHP * streams. * * @author Michael Slusarz <slusarz@horde.org> * @category Horde * @copyright 2012-2017 Horde LLC * @license http://www.horde.org/licenses/lgpl21 LGPL 2.1 * @package Stream * * @property boolean $utf8_char Parse character as UTF-8 data instead of * single byte (@since 1.4.0). */ class Horde_Stream implements Serializable { /** * Stream resource. * * @var resource */ public $stream; /** * Configuration parameters. * * @var array */ protected $_params; /** * Parse character as UTF-8 data instead of single byte. * * @var boolean */ protected $_utf8_char = false; /** * Constructor. * * @param array $opts Configuration options. */ public function __construct(array $opts = array()) { $this->_params = $opts; $this->_init(); } /** * Initialization method. */ protected function _init() { // Sane default: read-write, 0-length stream. if (!$this->stream) { $this->stream = @fopen('php://temp', 'r+'); } } /** */ public function __get($name) { switch ($name) { case 'utf8_char': return $this->_utf8_char; } } /** */ public function __set($name, $value) { switch ($name) { case 'utf8_char': $this->_utf8_char = (bool)$value; break; } } /** */ public function __clone() { $data = strval($this); $this->stream = null; $this->_init(); $this->add($data); } /** * String representation of object. * * @since 1.1.0 * * @return string The full stream converted to a string. */ public function __toString() { $this->rewind(); return $this->substring(); } /** * Adds data to the stream. * * @param mixed $data Data to add to the stream. Can be a resource, * Horde_Stream object, or a string(-ish) value. * @param boolean $reset Reset stream pointer to initial position after * adding? */ public function add($data, $reset = false) { if ($reset) { $pos = $this->pos(); } if (is_resource($data)) { $dpos = ftell($data); while (!feof($data)) { $this->add(fread($data, 8192)); } fseek($data, $dpos); } elseif ($data instanceof Horde_Stream) { $dpos = $data->pos(); while (!$data->eof()) { $this->add($data->substring(0, 65536)); } $data->seek($dpos, false); } else { fwrite($this->stream, $data); } if ($reset) { $this->seek($pos, false); } } /** * Returns the length of the data. Does not change the stream position. * * @param boolean $utf8 If true, determines the UTF-8 length of the * stream (as of 1.4.0). If false, determines the * byte length of the stream. * * @return integer Stream size. * * @throws Horde_Stream_Exception */ public function length($utf8 = false) { $pos = $this->pos(); if ($utf8 && $this->_utf8_char) { $this->rewind(); $len = 0; while ($this->getChar() !== false) { ++$len; } } elseif (!$this->end()) { throw new Horde_Stream_Exception('ERROR'); } else { $len = $this->pos(); } if (!$this->seek($pos, false)) { throw new Horde_Stream_Exception('ERROR'); } return $len; } /** * Get a string up to a certain character (or EOF). * * @param string $end The character to stop reading at. As of 1.4.0, * $char can be a multi-character UTF-8 string. * @param boolean $all If true, strips all repetitions of $end from * the end. If false, stops at the first instance * of $end. (@since 1.5.0) * * @return string The string up to $end (stream is positioned after the * end character(s), all of which are stripped from the * return data). */ public function getToChar($end, $all = true) { if (($len = strlen($end)) === 1) { $out = ''; do { if (($tmp = stream_get_line($this->stream, 8192, $end)) === false) { return $out; } $out .= $tmp; if ((strlen($tmp) < 8192) || ($this->peek(-1) == $end)) { break; } } while (true); } else { $res = $this->search($end); if (is_null($res)) { return $this->substring(); } $out = substr($this->getString(null, $res + $len - 1), 0, $len * -1); } /* Remove all further characters also. */ if ($all) { while ($this->peek($len) == $end) { $this->seek($len); } } return $out; } /** * Return the current character(s) without moving the pointer. * * @param integer $length The peek length (since 1.4.0). * * @return string The current character. */ public function peek($length = 1) { $out = ''; for ($i = 0; $i < $length; ++$i) { if (($c = $this->getChar()) === false) { break; } $out .= $c; } $this->seek(strlen($out) * -1); return $out; } /** * Search for character(s) and return its position. * * @param string $char The character to search for. As of 1.4.0, * $char can be a multi-character UTF-8 string. * @param boolean $reverse Do a reverse search? * @param boolean $reset Reset the pointer to the original position? * * @return mixed The start position of the search string (integer), or * null if character not found. */ public function search($char, $reverse = false, $reset = true) { $found_pos = null; if ($len = strlen($char)) { $pos = $this->pos(); $single_char = ($len === 1); do { if ($reverse) { for ($i = $pos - 1; $i >= 0; --$i) { $this->seek($i, false); $c = $this->peek(); if ($c == ($single_char ? $char : substr($char, 0, strlen($c)))) { $found_pos = $i; break; } } } else { /* Optimization for the common use case of searching for * a single character in byte data. Reduces calling * getChar() a bunch of times. */ $fgetc = ($single_char && !$this->_utf8_char); while (($c = ($fgetc ? fgetc($this->stream) : $this->getChar())) !== false) { if ($c == ($single_char ? $char : substr($char, 0, strlen($c)))) { $found_pos = $this->pos() - ($single_char ? 1 : strlen($c)); break; } } } if ($single_char || is_null($found_pos) || ($this->getString($found_pos, $found_pos + $len - 1) == $char)) { break; } $this->seek($found_pos + ($reverse ? 0 : 1), false); $found_pos = null; } while (true); $this->seek( ($reset || is_null($found_pos)) ? $pos : $found_pos, false ); } return $found_pos; } /** * Returns the stream (or a portion of it) as a string. Position values * are the byte position in the stream. * * @param integer $start The starting position. If positive, start from * this position. If negative, starts this length * back from the current position. If null, starts * from the current position. * @param integer $end The ending position relative to the beginning of * the stream (if positive). If negative, end this * length back from the end of the stream. If null, * reads to the end of the stream. * * @return string A string. */ public function getString($start = null, $end = null) { if (!is_null($start) && ($start >= 0)) { $this->seek($start, false); $start = 0; } if (is_null($end)) { $len = null; } else { $end = ($end >= 0) ? $end - $this->pos() + 1 : $this->length() - $this->pos() + $end; $len = max($end, 0); } return $this->substring($start, $len); } /** * Return part of the stream as a string. * * @since 1.4.0 * * @param integer $start Start, as an offset from the current postion. * @param integer $length Length of string to return. If null, returns * rest of the stream. If negative, this many * characters will be omitted from the end of the * stream. * @param boolean $char If true, $start/$length is the length in * characters. If false, $start/$length is the * length in bytes. * * @return string The substring. */ public function substring($start = 0, $length = null, $char = false) { if ($start !== 0) { $this->seek($start, true, $char); } $out = ''; $to_end = is_null($length); /* If length is greater than remaining stream, use more efficient * algorithm below. Also, if doing a negative length, deal with that * below also. */ if ($char && $this->_utf8_char && !$to_end && ($length >= 0) && ($length < ($this->length() - $this->pos()))) { while ($length-- && (($char = $this->getChar()) !== false)) { $out .= $char; } return $out; } if (!$to_end && ($length < 0)) { $pos = $this->pos(); $this->end(); $this->seek($length, true, $char); $length = $this->pos() - $pos; $this->seek($pos, false); if ($length < 0) { return ''; } } while (!feof($this->stream) && ($to_end || $length)) { $read = fread($this->stream, $to_end ? 16384 : $length); $out .= $read; if (!$to_end) { $length -= strlen($read); } } return $out; } /** * Auto-determine the EOL string. * * @since 1.3.0 * * @return string The EOL string, or null if no EOL found. */ public function getEOL() { $pos = $this->pos(); $this->rewind(); $pos2 = $this->search("\n", false, false); if ($pos2) { $this->seek(-1); $eol = ($this->getChar() == "\r") ? "\r\n" : "\n"; } else { $eol = is_null($pos2) ? null : "\n"; } $this->seek($pos, false); return $eol; } /** * Return a character from the string. * * @since 1.4.0 * * @return string Character (single byte, or UTF-8 character if * $utf8_char is true). */ public function getChar() { $char = fgetc($this->stream); if (!$this->_utf8_char) { return $char; } $c = ord($char); if ($c < 0x80) { return $char; } if ($c < 0xe0) { $n = 1; } elseif ($c < 0xf0) { $n = 2; } elseif ($c < 0xf8) { $n = 3; } else { throw new Horde_Stream_Exception('ERROR'); } for ($i = 0; $i < $n; ++$i) { if (($c = fgetc($this->stream)) === false) { throw new Horde_Stream_Exception('ERROR'); } $char .= $c; } return $char; } /** * Return the current stream pointer position. * * @since 1.4.0 * * @return mixed The current position (integer), or false. */ public function pos() { return ftell($this->stream); } /** * Rewind the internal stream to the beginning. * * @since 1.4.0 * * @return boolean True if successful. */ public function rewind() { return rewind($this->stream); } /** * Move internal pointer. * * @since 1.4.0 * * @param integer $offset The offset. * @param boolean $curr If true, offset is from current position. If * false, offset is from beginning of stream. * @param boolean $char If true, $offset is the length in characters. * If false, $offset is the length in bytes. * * @return boolean True if successful. */ public function seek($offset = 0, $curr = true, $char = false) { if (!$offset) { return (bool)$curr ?: $this->rewind(); } if ($offset < 0) { if (!$curr) { return true; } elseif (abs($offset) > $this->pos()) { return $this->rewind(); } } if ($char && $this->_utf8_char) { if ($offset > 0) { if (!$curr) { $this->rewind(); } do { $this->getChar(); } while (--$offset); } else { $pos = $this->pos(); $offset = abs($offset); while ($pos-- && $offset) { fseek($this->stream, -1, SEEK_CUR); if ((ord($this->peek()) & 0xC0) != 0x80) { --$offset; } } } return true; } return (fseek($this->stream, $offset, $curr ? SEEK_CUR : SEEK_SET) === 0); } /** * Move internal pointer to the end of the stream. * * @since 1.4.0 * * @param integer $offset Move this offset from the end. * * @return boolean True if successful. */ public function end($offset = 0) { return (fseek($this->stream, $offset, SEEK_END) === 0); } /** * Has the end of the stream been reached? * * @since 1.4.0 * * @return boolean True if the end of the stream has been reached. */ public function eof() { return feof($this->stream); } /** * Close the stream. * * @since 1.4.0 */ public function close() { if ($this->stream) { fclose($this->stream); } } /* Serializable methods. */ /** */ public function serialize() { $this->_params['_pos'] = $this->pos(); return json_encode(array( strval($this), $this->_params )); } /** */ public function unserialize($data) { $this->_init(); $data = json_decode($data, true); $this->add($data[0]); $this->seek($data[1]['_pos'], false); unset($data[1]['_pos']); $this->_params = $data[1]; } }