/framework/vendor/swift/lib/classes/Swift/ByteStream/ArrayByteStream.php

  1<?php
  2
  3/*
  4 * This file is part of SwiftMailer.
  5 * (c) 2004-2009 Chris Corbyn
  6 *
  7 * For the full copyright and license information, please view the LICENSE
  8 * file that was distributed with this source code.
  9 */
 10
 11//@require 'Swift/InputByteStream.php';
 12//@require 'Swift/OutputByteStream.php';
 13
 14/**
 15 * Allows reading and writing of bytes to and from an array.
 16 * @package Swift
 17 * @subpackage ByteStream
 18 * @author Chris Corbyn
 19 */
 20class Swift_ByteStream_ArrayByteStream
 21  implements Swift_InputByteStream, Swift_OutputByteStream
 22{
 23
 24  /**
 25   * The internal stack of bytes.
 26   * @var string[]
 27   * @access private
 28   */
 29  private $_array = array();
 30
 31  /**
 32   * The size of the stack
 33   * @var int
 34   * @access private
 35   */
 36  private $_arraySize = 0;
 37
 38  /**
 39   * The internal pointer offset.
 40   * @var int
 41   * @access private
 42   */
 43  private $_offset = 0;
 44  
 45  /** Bound streams */
 46  private $_mirrors = array();
 47  
 48  /**
 49   * Create a new ArrayByteStream.
 50   * If $stack is given the stream will be populated with the bytes it contains.
 51   * @param mixed $stack of bytes in string or array form, optional
 52   */
 53  public function __construct($stack = null)
 54  {
 55    if (is_array($stack))
 56    {
 57      $this->_array = $stack;
 58      $this->_arraySize = count($stack);
 59    }
 60    elseif (is_string($stack))
 61    {
 62      $this->write($stack);
 63    }
 64    else
 65    {
 66      $this->_array = array();
 67    }
 68  }
 69
 70  /**
 71   * Reads $length bytes from the stream into a string and moves the pointer
 72   * through the stream by $length. If less bytes exist than are requested the
 73   * remaining bytes are given instead. If no bytes are remaining at all, boolean
 74   * false is returned.
 75   * @param int $length
 76   * @return string
 77   */
 78  public function read($length)
 79  {
 80    if ($this->_offset == $this->_arraySize)
 81    {
 82      return false;
 83    }
 84
 85    // Don't use array slice
 86    $end = $length + $this->_offset;
 87    $end = $this->_arraySize<$end
 88      ?$this->_arraySize
 89      :$end;
 90    $ret = '';
 91    for (; $this->_offset < $end; ++$this->_offset)
 92    {
 93      $ret .= $this->_array[$this->_offset];
 94    }
 95    return $ret;
 96  }
 97
 98  /**
 99   * Writes $bytes to the end of the stream.
100   * @param string $bytes
101   */
102  public function write($bytes)
103  {
104    $to_add = str_split($bytes);
105    foreach ($to_add as $value)
106    {
107      $this->_array[] = $value;
108    }
109    $this->_arraySize = count($this->_array);
110    
111    foreach ($this->_mirrors as $stream)
112    {
113      $stream->write($bytes);
114    }
115  }
116  
117  /**
118   * Not used.
119   */
120  public function commit()
121  {
122  }
123  
124  /**
125   * Attach $is to this stream.
126   * The stream acts as an observer, receiving all data that is written.
127   * All {@link write()} and {@link flushBuffers()} operations will be mirrored.
128   *
129   * @param Swift_InputByteStream $is
130   */
131  public function bind(Swift_InputByteStream $is)
132  {
133    $this->_mirrors[] = $is;
134  }
135  
136  /**
137   * Remove an already bound stream.
138   * If $is is not bound, no errors will be raised.
139   * If the stream currently has any buffered data it will be written to $is
140   * before unbinding occurs.
141   *
142   * @param Swift_InputByteStream $is
143   */
144  public function unbind(Swift_InputByteStream $is)
145  {
146    foreach ($this->_mirrors as $k => $stream)
147    {
148      if ($is === $stream)
149      {
150        unset($this->_mirrors[$k]);
151      }
152    }
153  }
154
155  /**
156   * Move the internal read pointer to $byteOffset in the stream.
157   * @param int $byteOffset
158   * @return boolean
159   */
160  public function setReadPointer($byteOffset)
161  {
162    if ($byteOffset > $this->_arraySize)
163    {
164      $byteOffset = $this->_arraySize;
165    }
166    elseif ($byteOffset < 0)
167    {
168      $byteOffset = 0;
169    }
170
171    $this->_offset = $byteOffset;
172  }
173
174  /**
175   * Flush the contents of the stream (empty it) and set the internal pointer
176   * to the beginning.
177   */
178  public function flushBuffers()
179  {
180    $this->_offset = 0;
181    $this->_array = array();
182    $this->_arraySize = 0;
183    
184    foreach ($this->_mirrors as $stream)
185    {
186      $stream->flushBuffers();
187    }
188  }
189
190}