Fork::setTask() - Code Metrics - Inspection of "Delete Fork::setTask" - ackintosh/snidel - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 15d2ac...024d05 )

by Akihito

created 2016-04-29 13:34 UTC

Fork::setTask() A

↳ Parent: Fork

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	4
rs	10
cc	1
eloc	2
nc	1
nop	1

<?php
namespace Ackintosh\Snidel;

use Ackintosh\Snidel\Pcntl;
use Ackintosh\Snidel\Result;
use Ackintosh\Snidel\Task;

class Fork
{
    /** @var int */
    private $pid;

    /** @var \Ackintosh\Snidel\Pcntl */
    private $pcntl;

    /** @var int */
    private $status;

    /** @var callable */
    private $callable;

    /** @var array */
    private $args;

    /** @var \Ackintosh\Snidel\Result */
    private $result;

    /** @var string */
    private $tag;

    /** @var \Ackintosh\Snidel\Task */
    private $task;

    /** @var string */
    private $serializedTask;

    /** @var bool */
    private $queued = false;

    /**
     * @param   int     $pid
     */
    public function __construct($pid, $task)
    {
        $this->pid      = $pid;
        $this->task     = $task;
        $this->pcntl    = new Pcntl();
    }

    /**
     * set exit status
     *
     * @param   int     $status
     * @return  void
     */
    public function setStatus($status)
    {
        $this->status = $status;
    }

    /**
     * return pid
     *
     * @return  int
     */
    public function getPid()
    {
        return $this->pid;
    }

    /**
     * return exit status
     *
     * @return int
     */
    public function getStatus()
    {
        return $this->status;
    }

    /**
     * set callable
     *
     * @param   callable    $callable
     * @return  void
     */
    public function setCallable($callable)
    {
        $this->callable = $callable instanceof \Closure ? '*Closure*' : $callable;
    }

    public function getCallable()
    {
        return $this->callable;
    }

    /**
     * set arguments
     *
     * @param   array   $args
     * @return  void
     */
    public function setArgs($args)
    {
        $this->args = $args;
    }

    public function getArgs()
    {
        return $this->args;
    }

    /**
     * @return bool
     */
    public function hasFinishedSuccessfully()
    {
        return $this->pcntl->wifexited($this->status) && $this->pcntl->wexitstatus($this->status) === 0;
    }

    /**
     * @return bool
     */
    public function hasNotFinishedSuccessfully()
    {
        return !$this->hasFinishedSuccessfully();
    }

    /**
     *
     * @param   \Ackintosh\Snidel\Result
     * @return  void
     */
    public function setResult($result)
    {
        $this->result = $result;
    }

    /**
     * return result
     *
     * @return \Ackintosh\Snidel\Result
     */
    public function getResult()
    {
        return $this->result;
    }

    public function hasNoResult()
    {
        return $this->result === null;
    }

    /**
     * @param   string  $tag
     * @return  void
     */
    public function setTag($tag)
    {
        $this->tag = $tag;
    }

    /**
     * @return  string
     */
    public function getTag()
    {
        return $this->task->getTag();
    }

    /**
     * @return  void
     */
    public function setQueued()
    {
        $this->queued = true;
    }

    /**
     * @return  bool
     */
    public function isQueued()
    {
        return $this->queued;
    }

    public function executeTask()
    {
        ob_start();
        $result = new Result();
        $result->setReturn(call_user_func_array($this->task->getCallable(), $this->task->getArgs()));
        $result->setOutput(ob_get_clean());
        $this->result = $result;
    }

    /**
     * @param   \Ackintosh\Snidel\Fork  $fork
     * @return  string
     */
    public static function serialize($fork)
    {
        $fork->serializeTask();

        return serialize($fork);
    }

    /**
     * @return  void
     */
    private function serializeTask()
    {
        $this->serializedTask = Task::serialize($this->task);
        unset($this->task);
    }

    /**
     * @param   string  $serializedFork
     * @return  \Ackintosh\Snidel\Fork
     */
    public static function unserialize($serializedFork)
    {
        $fork = unserialize($serializedFork);
        $fork->unserializeTask();

        return $fork;
    }

    /**
     * @return  void
     */
    private function unserializeTask()
    {
        $this->task = Task::unserialize($this->serializedTask);
        $this->serializedTask = null;
    }
}


1			<?php
2			namespace Ackintosh\Snidel;
3
4			use Ackintosh\Snidel\Pcntl;
5			use Ackintosh\Snidel\Result;
6			use Ackintosh\Snidel\Task;
7
8			class Fork
9			{
10			/** @var int */
11			private $pid;
12
13			/** @var \Ackintosh\Snidel\Pcntl */
14			private $pcntl;
15
16			/** @var int */
17			private $status;
18
19			/** @var callable */
20			private $callable;
21
22			/** @var array */
23			private $args;
24
25			/** @var \Ackintosh\Snidel\Result */
26			private $result;
27
28			/** @var string */
29			private $tag;
30
31			/** @var \Ackintosh\Snidel\Task */
32			private $task;
33
34			/** @var string */
35			private $serializedTask;
36
37			/** @var bool */
38			private $queued = false;
39
40			/**
41			* @param int $pid
42			*/
43			public function __construct($pid, $task)
44			{
45			$this->pid = $pid;
46			$this->task = $task;
47			$this->pcntl = new Pcntl();
48			}
49
50			/**
51			* set exit status
52			*
53			* @param int $status
54			* @return void
55			*/
56			public function setStatus($status)
57			{
58			$this->status = $status;
59			}
60
61			/**
62			* return pid
63			*
64			* @return int
65			*/
66			public function getPid()
67			{
68			return $this->pid;
69			}
70
71			/**
72			* return exit status
73			*
74			* @return int
75			*/
76			public function getStatus()
77			{
78			return $this->status;
79			}
80
81			/**
82			* set callable
83			*
84			* @param callable $callable
85			* @return void
86			*/
87			public function setCallable($callable)
88			{
89			$this->callable = $callable instanceof \Closure ? 'Closure' : $callable;
90			}
91
92			public function getCallable()
93			{
94			return $this->callable;
95			}
96
97			/**
98			* set arguments
99			*
100			* @param array $args
101			* @return void
102			*/
103			public function setArgs($args)
104			{
105			$this->args = $args;
106			}
107
108			public function getArgs()
109			{
110			return $this->args;
111			}
112
113			/**
114			* @return bool
115			*/
116			public function hasFinishedSuccessfully()
117			{
118			return $this->pcntl->wifexited($this->status) && $this->pcntl->wexitstatus($this->status) === 0;
119			}
120
121			/**
122			* @return bool
123			*/
124			public function hasNotFinishedSuccessfully()
125			{
126			return !$this->hasFinishedSuccessfully();
127			}
128
129			/**
130			*
131			* @param \Ackintosh\Snidel\Result
132			* @return void
133			*/
134			public function setResult($result)
135			{
136			$this->result = $result;
137			}
138
139			/**
140			* return result
141			*
142			* @return \Ackintosh\Snidel\Result
143			*/
144			public function getResult()
145			{
146			return $this->result;
147			}
148
149			public function hasNoResult()
150			{
151			return $this->result === null;
152			}
153
154			/**
155			* @param string $tag
156			* @return void
157			*/
158			public function setTag($tag)
159			{
160			$this->tag = $tag;
161			}
162
163			/**
164			* @return string
165			*/
166			public function getTag()
167			{
168			return $this->task->getTag();
169			}
170
171			/**
172			* @return void
173			*/
174			public function setQueued()
175			{
176			$this->queued = true;
177			}
178
179			/**
180			* @return bool
181			*/
182			public function isQueued()
183			{
184			return $this->queued;
185			}
186
187			public function executeTask()
188			{
189			ob_start();
190			$result = new Result();
191			$result->setReturn(call_user_func_array($this->task->getCallable(), $this->task->getArgs()));
192			$result->setOutput(ob_get_clean());
193			$this->result = $result;
194			}
195
196			/**
197			* @param \Ackintosh\Snidel\Fork $fork
198			* @return string
199			*/
200			public static function serialize($fork)
201			{
202			$fork->serializeTask();
203
204			return serialize($fork);
205			}
206
207			/**
208			* @return void
209			*/
210			private function serializeTask()
211			{
212			$this->serializedTask = Task::serialize($this->task);
213			unset($this->task);
214			}
215
216			/**
217			* @param string $serializedFork
218			* @return \Ackintosh\Snidel\Fork
219			*/
220			public static function unserialize($serializedFork)
221			{
222			$fork = unserialize($serializedFork);
223			$fork->unserializeTask();
224
225			return $fork;
226			}
227
228			/**
229			* @return void
230			*/
231			private function unserializeTask()
232			{
233			$this->task = Task::unserialize($this->serializedTask);
234			$this->serializedTask = null;
235			}
236			}
237

ackintosh / snidel

Push — master ( 15d2ac...024d05 )

Fork::setTask() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like