PHPDaemon\Core\EventLoop

Complexity

Total Complexity

19

Size/Duplication

Total Lines	150
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	1

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
A	init()	0	8	2
A	free()	0	4	1
A	getBase()	0	4	1
A	getDnsBase()	0	4	1
A	reinit()	0	4	1
A	signal()	0	4	1
A	timer()	0	4	1
A	listener()	0	4	1
A	bufferEvent()	0	4	1
A	bufferEventSsl()	0	4	1
A	stop()	0	5	1
A	interrupt()	0	7	2
A	event()	0	4	1
A	run()	0	10	3

<?php
namespace PHPDaemon\Core;

use PHPDaemon\Structures\StackCallbacks;

class EventLoop
{
    public static $instance;
    protected $base;
    protected $dnsBase;
    protected $callbacks;
    protected $stopped = true;

    /**
     * EventLoop constructor.
     */
    public function __construct()
    {
        $this->base = new \EventBase;
        $this->callbacks = new StackCallbacks;
        $this->dnsBase = new \EventDnsBase($this->base, false); // @TODO: test with true

Comments for TODO tasks are often forgotten in the code; it might be better to use a dedicated issue tracker.

    }

    /**
     * Init
     */
    public static function init()
    {
        if (self::$instance !== null) {
            self::$instance->reinit();
        } else {
            self::$instance = new static;
        }
    }

    /**
     * Free
     */
    public function free() {
        $this->base->free();
        $this->dnsBase->free();
    }

    /**
     * @return \EventBase
     */
    public function getBase()
    {
        return $this->base;
    }

    /**
     * @return \EventDnsBase
     */
    public function getDnsBase()
    {
        return $this->dnsBase;
    }

    /**
     * Reinit
     */
    public function reinit()
    {
        $this->base->reinit();
    }

    /**
     * @param array ...$args
     * @return mixed
     */
    public function signal(...$args)
    {
        return \Event::signal($this->base, ...$args);
    }

    /**
     * @param array ...$args
     * @return mixed
     */
    public function timer(...$args)
    {
        return \Event::timer($this->base, ...$args);
    }

    /**
     * @param array ...$args
     * @return \EventListener
     */
    public function listener(...$args)
    {
        return new \EventListener($this->base, ...$args);
    }

    /**
     * @param array ...$args
     * @return \EventBufferEvent
     */
    public function bufferEvent(...$args)
    {
        return new \EventBufferEvent($this->base, ...$args);
    }

    /**
     * @param array ...$args
     * @return mixed
     */
    public function bufferEventSsl(...$args)
    {
        return \EventBufferEvent::sslSocket($this->base, ...$args);
    }

    /**
     * Stop
     */
    public function stop()
    {
        $this->stopped = true;
        $this->interrupt();
    }

    /**
     * @param null $cb
     */
    public function interrupt($cb = null)
    {
        if ($cb !== null) {
            $this->callbacks->push($cb);

$cb is of type null, but the function expects a callable.

        }
        $this->base->exit();
    }

    /**
     * @param array ...$args
     * @return \Event
     */
    public function event(...$args)
    {
        return new \Event($this->base, ...$args);
    }

    /**
     * Run
     */
    public function run()
    {
        $this->stopped = false;
        while (!$this->stopped) {
            $this->callbacks->executeAll($this);
            if (!$this->base->dispatch()) {
                break;
            }
        }
    }
}