Buffer::__construct() - Code Metrics - ThrusterIO/stream - Measure and Improve Code Quality continuously with Scrutinizer

Buffer::__construct() A
last analyzed 2016-01-24 18:19 UTC

↳ Parent: Buffer

Complexity

Conditions	1
Paths	1

Size

Total Lines	17
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	9
CRAP Score	1

Metric	Value
dl	0
loc	17
ccs	9
cts	9
cp	1
rs	9.4285
cc	1
eloc	12
nc	1
nop	3
crap	1

<?php

namespace Thruster\Component\Stream;

use Thruster\Component\EventEmitter\EventEmitterInterface;
use Thruster\Component\EventEmitter\EventEmitterTrait;
use Thruster\Component\EventLoop\EventLoopInterface;

/**
 * Class Buffer
 *
 * @package Thruster\Component\Stream
 * @author  Aurimas Niekis <[email protected]>
 */
class Buffer implements WritableStreamInterface
{
    use EventEmitterTrait;

    /**
     * @var resource
     */
    protected $stream;

    /**
     * @var bool
     */
    protected $listening;

    /**
     * @var int
     */
    protected $softLimit;

    /**
     * @var bool
     */
    protected $writable;

    /**
     * @var EventLoopInterface
     */
    protected $loop;

    /**
     * @var string
     */
    protected $data;

    /**
     * @var array
     */
    protected $lastError;

    /**
     * Buffer constructor.
     *
     * @param resource           $stream
     * @param EventLoopInterface $loop
     * @param int                $softLimit
     */
    public function __construct($stream, EventLoopInterface $loop, int $softLimit = 2048)
    {
        $this->stream    = $stream;
        $this->loop      = $loop;
        $this->setSoftLimit($softLimit);

        $this->setListening(false);
        $this->writable  = true;
        $this->data      = '';

        $this->lastError = [
            'number'  => 0,
            'message' => '',
            'file'    => '',
            'line'    => 0,
        ];
    }

    /**
     * @return int
     */
    public function getSoftLimit() : int
    {
        return $this->softLimit;
    }

    /**
     * @param int $softLimit
     *
     * @return $this
     */
    public function setSoftLimit(int $softLimit) : self
    {
        $this->softLimit = $softLimit;

        return $this;
    }

    /**
     * @return bool
     */
    public function isListening() : bool
    {
        return $this->listening;
    }

    /**
     * @param bool $listening
     *
     * @return $this
     */
    public function setListening(bool $listening) : self
    {
        $this->listening = $listening;

        return $this;
    }

    /**
     * @inheritdoc
     */
    public function isWritable() : bool
    {
        return $this->writable;
    }

    /**
     * @inheritdoc
     */
    public function write($data)
    {
        if (!$this->writable) {
            return;
        }

        $this->data .= $data;

        if (false === $this->isListening()) {
            $this->setListening(true);

            $this->loop->addWriteStream($this->stream, [$this, 'handleWrite']);
        }

        $belowSoftLimit = strlen($this->data) < $this->getSoftLimit();

        return $belowSoftLimit;
    }

    /**
     * @inheritdoc
     */
    public function end($data = null)
    {
        if (null !== $data) {
            $this->write($data);
        }

        $this->writable = false;

        if ($this->isListening()) {
            $this->on('full-drain', [$this, 'close']);
        } else {
            $this->close();
        }
    }

    /**
     * @inheritdoc
     */
    public function close() : self
    {
        $this->writable  = false;
        $this->setListening(false);
        $this->data      = '';

        $this->emit('close', [$this]);

        return $this;
    }

    public function handleWrite()
    {
        if (!is_resource($this->stream)) {
            $this->emit('error', [new \RuntimeException('Tried to write to invalid stream.'), $this]);

            return;
        }

        set_error_handler([$this, 'errorHandler']);

        $sent = fwrite($this->stream, $this->data);

        restore_error_handler();

        if (false === $sent) {
            $this->emit('error', [
                new \ErrorException(
                    $this->lastError['message'],
                    0,
                    $this->lastError['number'],
                    $this->lastError['file'],
                    $this->lastError['line']
                ),
                $this
            ]);

            return;
        }

        if (0 === $sent && feof($this->stream)) {
            $this->emit('error', [new \RuntimeException('Tried to write to closed stream.'), $this]);

            return;
        }

        $len        = strlen($this->data);
        $this->data = (string)substr($this->data, $sent);

        if ($len >= $this->softLimit && $len - $sent < $this->getSoftLimit()) {
            $this->emit('drain', [$this]);
        }

        if (0 === strlen($this->data)) {
            $this->loop->removeWriteStream($this->stream);
            $this->setListening(false);

            $this->emit('full-drain', [$this]);
        }
    }

    protected function errorHandler($errno, $errstr, $errfile, $errline)
    {
        $this->lastError['number']  = $errno;
        $this->lastError['message'] = $errstr;
        $this->lastError['file']    = $errfile;
        $this->lastError['line']    = $errline;
    }
}


1		<?php
2
3		namespace Thruster\Component\Stream;
4
5		use Thruster\Component\EventEmitter\EventEmitterInterface;
6		use Thruster\Component\EventEmitter\EventEmitterTrait;
7		use Thruster\Component\EventLoop\EventLoopInterface;
8
9		/**
10		* Class Buffer
11		*
12		* @package Thruster\Component\Stream
13		* @author Aurimas Niekis <[email protected]>
14		*/
15		class Buffer implements WritableStreamInterface
16		{
17		use EventEmitterTrait;
18
19		/**
20		* @var resource
21		*/
22		protected $stream;
23
24		/**
25		* @var bool
26		*/
27		protected $listening;
28
29		/**
30		* @var int
31		*/
32		protected $softLimit;
33
34		/**
35		* @var bool
36		*/
37		protected $writable;
38
39		/**
40		* @var EventLoopInterface
41		*/
42		protected $loop;
43
44		/**
45		* @var string
46		*/
47		protected $data;
48
49		/**
50		* @var array
51		*/
52		protected $lastError;
53
54		/**
55		* Buffer constructor.
56		*
57		* @param resource $stream
58		* @param EventLoopInterface $loop
59		* @param int $softLimit
60		*/
61	18	public function __construct($stream, EventLoopInterface $loop, int $softLimit = 2048)
62		{
63	18	$this->stream = $stream;
64	18	$this->loop = $loop;
65	18	$this->setSoftLimit($softLimit);
66
67	18	$this->setListening(false);
68	18	$this->writable = true;
69	18	$this->data = '';
70
71	18	$this->lastError = [
72		'number' => 0,
73		'message' => '',
74		'file' => '',
75		'line' => 0,
76		];
77	18	}
78
79		/**
80		* @return int
81		*/
82	9	public function getSoftLimit() : int
83		{
84	9	return $this->softLimit;
85		}
86
87		/**
88		* @param int $softLimit
89		*
90		* @return $this
91		*/
92	18	public function setSoftLimit(int $softLimit) : self
93		{
94	18	$this->softLimit = $softLimit;
95
96	18	return $this;
97		}
98
99		/**
100		* @return bool
101		*/
102	11	public function isListening() : bool
103		{
104	11	return $this->listening;
105		}
106
107		/**
108		* @param bool $listening
109		*
110		* @return $this
111		*/
112	18	public function setListening(bool $listening) : self
113		{
114	18	$this->listening = $listening;
115
116	18	return $this;
117		}
118
119		/**
120		* @inheritdoc
121		*/
122	2	public function isWritable() : bool
123		{
124	2	return $this->writable;
125		}
126
127		/**
128		* @inheritdoc
129		*/
130	10	public function write($data)
131		{
132	10	if (!$this->writable) {
133	1	return;
134		}
135
136	9	$this->data .= $data;
137
138	9	if (false === $this->isListening()) {
139	9	$this->setListening(true);
140
141	9	$this->loop->addWriteStream($this->stream, [$this, 'handleWrite']);
142		}
143
144	9	$belowSoftLimit = strlen($this->data) < $this->getSoftLimit();
145
146	9	return $belowSoftLimit;
147		}
148
149		/**
150		* @inheritdoc
151		*/
152	3	public function end($data = null)
153		{
154	3	if (null !== $data) {
155	1	$this->write($data);
156		}
157
158	3	$this->writable = false;
159
160	3	if ($this->isListening()) {
161		$this->on('full-drain', [$this, 'close']);
162		} else {
163	3	$this->close();
164		}
165	3	}
166
167		/**
168		* @inheritdoc
169		*/
170	5	public function close() : self
171		{
172	5	$this->writable = false;
173	5	$this->setListening(false);
174	5	$this->data = '';
175
176	5	$this->emit('close', [$this]);
177
178	5	return $this;
179		}
180
181	8	public function handleWrite()
182		{
183	8	if (!is_resource($this->stream)) {
184	1	$this->emit('error', [new \RuntimeException('Tried to write to invalid stream.'), $this]);
185
186	1	return;
187		}
188
189	7	set_error_handler([$this, 'errorHandler']);
190
191	7	$sent = fwrite($this->stream, $this->data);
192
193	7	restore_error_handler();
194
195	7	if (false === $sent) {
196		$this->emit('error', [
197		new \ErrorException(
198		$this->lastError['message'],
199		0,
200		$this->lastError['number'],
201		$this->lastError['file'],
202		$this->lastError['line']
203		),
204		$this
205		]);
206
207		return;
208		}
209
210	7	if (0 === $sent && feof($this->stream)) {
211	2	$this->emit('error', [new \RuntimeException('Tried to write to closed stream.'), $this]);
212
213	2	return;
214		}
215
216	6	$len = strlen($this->data);
217	6	$this->data = (string)substr($this->data, $sent);
218
219	6	if ($len >= $this->softLimit && $len - $sent < $this->getSoftLimit()) {
220	2	$this->emit('drain', [$this]);
221		}
222
223	6	if (0 === strlen($this->data)) {
224	6	$this->loop->removeWriteStream($this->stream);
225	6	$this->setListening(false);
226
227	6	$this->emit('full-drain', [$this]);
228		}
229	6	}
230
231	2	protected function errorHandler($errno, $errstr, $errfile, $errline)
232		{
233	2	$this->lastError['number'] = $errno;
234	2	$this->lastError['message'] = $errstr;
235	2	$this->lastError['file'] = $errfile;
236	2	$this->lastError['line'] = $errline;
237	2	}
238		}
239

ThrusterIO / stream

Buffer::__construct() A last analyzed 2016-01-24 18:19 UTC

Complexity

Size

Duplication

Code Coverage

Duplication Side-by-Side

Filter issues like

Buffer::__construct() A
last analyzed 2016-01-24 18:19 UTC