PhpDDD\DomainDrivenDesign\Event\EventListener

Complexity

Total Complexity

14

Size/Duplication

Total Lines	95
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	1
Bugs	0	Features	1

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	validateAsynchronous()	0	6	2
A	validateEventClassName()	0	6	3
A	validateMethod()	0	6	3
A	isAsynchronous()	0	4	1
A	setSubscriber()	0	6	2
A	getEventClassName()	0	4	1
A	getMethod()	0	4	1

<?php

namespace PhpDDD\DomainDrivenDesign\Event;

use PhpDDD\DomainDrivenDesign\Exception\InvalidArgumentException;

final class EventListener
{
    /**
     * @var bool
     */
    private $asynchronous;
    /**
     * @var string
     */
    private $eventClassName;

    /**
     * @var callable|string
     */
    private $method;

    /**
     * @param callable|string $method
     * @param string|null     $eventClassName
     * @param bool            $asynchronous
     */
    public function __construct($method, $eventClassName = null, $asynchronous = false)
    {
        static::validateMethod($method);
        static::validateEventClassName($eventClassName);
        static::validateAsynchronous($asynchronous);
        $this->eventClassName = $eventClassName;
        $this->method         = $method;
        $this->asynchronous   = (bool) $asynchronous;
    }

    /**
     * @param bool $asynchronous
     */
    public static function validateAsynchronous($asynchronous)
    {
        if (!is_bool($asynchronous)) {
            throw InvalidArgumentException::wrongType('asynchronous', $asynchronous, 'boolean');
        }
    }

    /**
     * @param string|null $eventClassName
     */
    public static function validateEventClassName($eventClassName)
    {
        if (null !== $eventClassName && !is_string($eventClassName)) {
            throw InvalidArgumentException::wrongType('eventClassName', $eventClassName, 'null or sting');
        }
    }

    /**
     * @param string|callable $method
     */
    public static function validateMethod($method)
    {
        if (!is_string($method) && !is_callable($method)) {
            throw InvalidArgumentException::wrongType('method', $method, 'callable or sting');
        }
    }

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

    /**
     * @param EventSubscriberInterface $subscriber
     */
    public function setSubscriber(EventSubscriberInterface $subscriber)
    {
        if (!is_callable($this->method)) {
            $this->method = [$subscriber, $this->method];
        }
    }

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

    /**
     * @return callable|string
     */
    public function getMethod()
    {
        return $this->method;
    }
}