Swift_ByteStream_ArrayByteStream::setReadPointer() - Code Metrics - Inspection of "Applied fixes from StyleCI" - voku/swiftmailer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 5.x (#24)

by Lars

created 2016-05-23 21:43 UTC

Swift_ByteStream_ArrayByteStream::setReadPointer() A

↳ Parent: Swift_ByteStream_ArrayByteStream

Complexity

Conditions	3
Paths	3

Size

Total Lines	10
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	3.0175

Metric	Value
dl	0
loc	10
ccs	7
cts	8
cp	0.875
rs	9.4285
cc	3
eloc	6
nc	3
nop	1
crap	3.0175

<?php

/*
 * This file is part of SwiftMailer.
 * (c) 2004-2009 Chris Corbyn
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

/**
 * Allows reading and writing of bytes to and from an array.
 *
 * @author Chris Corbyn
 */
class Swift_ByteStream_ArrayByteStream implements Swift_InputByteStream, Swift_OutputByteStream
namespace YourVendor;

class YourClass { }
{
    /**
     * The internal stack of bytes.
     *
     * @var string[]
     */
    private $_array = array();

    /**
     * The size of the stack.
     *
     * @var int
     */
    private $_arraySize = 0;

    /**
     * The internal pointer offset.
     *
     * @var int
     */
    private $_offset = 0;

    /**
     * Bound streams.
     *
     * @var Swift_InputByteStream[]
     */
    private $_mirrors = array();

    /**
     * Create a new ArrayByteStream.
     *
     * If $stack is given the stream will be populated with the bytes it contains.
     *
     * @param mixed $stack of bytes in string or array form, optional
     */
    public function __construct($stack = null)
    {
        if (is_array($stack)) {
            $this->_array = $stack;
            $this->_arraySize = count($stack);
        } elseif (is_string($stack)) {
            $this->write($stack);
        } else {
            $this->_array = array();
        }
    }

    /**
     * Reads $length bytes from the stream into a string and moves the pointer
     * through the stream by $length.
     *
     * If less bytes exist than are requested the
     * remaining bytes are given instead. If no bytes are remaining at all, boolean
     * false is returned.
     *
     * @param int $length
     *
     * @return string
     */
    public function read($length)
    {
        if ($this->_offset === $this->_arraySize) {
            return false;
        }

        // Don't use array slice
        $end = $length + $this->_offset;
        $end = $this->_arraySize < $end ? $this->_arraySize : $end;
        $ret = '';
        for (; $this->_offset < $end; ++$this->_offset) {
            $ret .= $this->_array[$this->_offset];
        }

        return $ret;
    }

    /**
     * Writes $bytes to the end of the stream.
     *
     * @param string $bytes
     */
    public function write($bytes)
    {
        $to_add = str_split($bytes);
        foreach ($to_add as $value) {
            $this->_array[] = $value;
        }

        $this->_arraySize = count($this->_array);

        foreach ($this->_mirrors as $stream) {
            $stream->write($bytes);
        }
    }

    /**
     * Not used.
     */
    public function commit()
    {
    }

    /**
     * Attach $is to this stream.
     *
     * The stream acts as an observer, receiving all data that is written.
     * All {@link write()} and {@link flushBuffers()} operations will be mirrored.
     *
     * @param Swift_InputByteStream $is
     */
    public function bind(Swift_InputByteStream $is)
    {
        $this->_mirrors[] = $is;
    }

    /**
     * Remove an already bound stream.
     *
     * If $is is not bound, no errors will be raised.
     * If the stream currently has any buffered data it will be written to $is
     * before unbinding occurs.
     *
     * @param Swift_InputByteStream $is
     */
    public function unbind(Swift_InputByteStream $is)
    {
        foreach ($this->_mirrors as $k => $stream) {
            if ($is === $stream) {
                unset($this->_mirrors[$k]);
            }
        }
    }

    /**
     * Move the internal read pointer to $byteOffset in the stream.
     *
     * @param int $byteOffset
     *
     * @return bool
     */
    public function setReadPointer($byteOffset)
    {
        if ($byteOffset > $this->_arraySize) {
            $byteOffset = $this->_arraySize;
        } elseif ($byteOffset < 0) {
            $byteOffset = 0;
        }

        $this->_offset = $byteOffset;
    }

    /**
     * Flush the contents of the stream (empty it) and set the internal pointer
     * to the beginning.
     */
    public function flushBuffers()
    {
        $this->_offset = 0;
        $this->_array = array();
        $this->_arraySize = 0;

        foreach ($this->_mirrors as $stream) {
            $stream->flushBuffers();
        }
    }
}


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

voku / swiftmailer

Pull Request — 5.x (#24)

Swift_ByteStream_ArrayByteStream::setReadPointer() A

Complexity

Size

Duplication

Code Coverage

Duplication Side-by-Side

Filter issues like