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

Completed

Pull Request — 5.x (#16)

by Lars

created 2015-12-03 02:18 UTC

Swift_ByteStream_ArrayByteStream::commit() A

↳ Parent: Swift_ByteStream_ArrayByteStream

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Metric	Value
dl	0
loc	3
ccs	2
cts	2
cp	1
rs	10
cc	1
eloc	1
nc	1
nop	0
crap	1

<?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		} elseif (is_string($stack)) {
59	4	$this->write($stack);
60		} 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		}
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		}
105	24	$this->_arraySize = count($this->_array);
106
107	24	foreach ($this->_mirrors as $stream) {
108	6	$stream->write($bytes);
109		}
110	24	}
111
112		/**
113		* Not used.
114		*/
115	4	public function commit()
116		{
117	4	}
118
119		/**
120		* Attach $is to this stream.
121		*
122		* The stream acts as an observer, receiving all data that is written.
123		* All {@link write()} and {@link flushBuffers()} operations will be mirrored.
124		*
125		* @param Swift_InputByteStream $is
126		*/
127	7	public function bind(Swift_InputByteStream $is)
128		{
129	7	$this->_mirrors[] = $is;
130	7	}
131
132		/**
133		* Remove an already bound stream.
134		*
135		* If $is is not bound, no errors will be raised.
136		* If the stream currently has any buffered data it will be written to $is
137		* before unbinding occurs.
138		*
139		* @param Swift_InputByteStream $is
140		*/
141	5	public function unbind(Swift_InputByteStream $is)
142		{
143	5	foreach ($this->_mirrors as $k => $stream) {
144	5	if ($is === $stream) {
145	5	unset($this->_mirrors[$k]);
146		}
147		}
148	5	}
149
150		/**
151		* Move the internal read pointer to $byteOffset in the stream.
152		*
153		* @param int $byteOffset
154		*
155		* @return bool
156		*/
157	8	public function setReadPointer($byteOffset)
158		{
159	8	if ($byteOffset > $this->_arraySize) {
160		$byteOffset = $this->_arraySize;
161	8	} elseif ($byteOffset < 0) {
162	1	$byteOffset = 0;
163		}
164
165	8	$this->_offset = $byteOffset;
166	8	}
167
168		/**
169		* Flush the contents of the stream (empty it) and set the internal pointer
170		* to the beginning.
171		*/
172	2	public function flushBuffers()
173		{
174	2	$this->_offset = 0;
175	2	$this->_array = array();
176	2	$this->_arraySize = 0;
177
178	2	foreach ($this->_mirrors as $stream) {
179	1	$stream->flushBuffers();
180		}
181	2	}
182		}
183

voku / swiftmailer

Pull Request — 5.x (#16)

Swift_ByteStream_ArrayByteStream::commit() A

Complexity

Size

Duplication

Code Coverage

Duplication Side-by-Side

Filter issues like