EventManager::hasEventOnce() - Code Metrics - bresam/ivory-google-map - Measure and Improve Code Quality continuously with Scrutinizer

EventManager::hasEventOnce() A
last analyzed 2021-06-14 14:39 UTC

↳ Parent: EventManager

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1
crap	1

<?php

/*
 * This file is part of the Ivory Google Map package.
 *
 * (c) Eric GELOEN <[email protected]>
 *
 * For the full copyright and license information, please read the LICENSE
 * file that was distributed with this source code.
 */

namespace Ivory\GoogleMap\Event;

/**
 * @see http://code.google.com/apis/maps/documentation/javascript/reference.html#MapsEventListener
 *
 * @author GeLo <[email protected]>
 */
class EventManager
{
    /**
     * @var Event[]
     */
    private $domEvents = [];

    /**
     * @var Event[]
     */
    private $domEventsOnce = [];

    /**
     * @var Event[]
     */
    private $events = [];

    /**
     * @var Event[]
     */
    private $eventsOnce = [];

    /**
     * @return bool
     */
    public function hasDomEvents()
    {
        return !empty($this->domEvents);
    }

    /**
     * @return Event[]
     */
    public function getDomEvents()
    {
        return $this->domEvents;
    }

    /**
     * @param Event[] $domEvents
     */
    public function setDomEvents(array $domEvents)
    {
        $this->domEvents = [];
        $this->addDomEvents($domEvents);
    }

    /**
     * @param Event[] $domEvents
     */
    public function addDomEvents(array $domEvents)
    {
        foreach ($domEvents as $domEvent) {
            $this->addDomEvent($domEvent);
        }
    }

    /**
     * @return bool
     */
    public function hasDomEvent(Event $domEvent)
    {
        return in_array($domEvent, $this->domEvents, true);
    }

    public function addDomEvent(Event $domEvent)
    {
        if (!$this->hasDomEvent($domEvent)) {
            $this->domEvents[] = $domEvent;
        }
    }

    public function removeDomEvent(Event $domEvent)
    {
        unset($this->domEvents[array_search($domEvent, $this->domEvents, true)]);
        $this->domEvents = empty($this->domEvents) ? [] : array_values($this->domEvents);
    }

    /**
     * @return bool
     */
    public function hasDomEventsOnce()
    {
        return !empty($this->domEventsOnce);
    }

    /**
     * @return Event[]
     */
    public function getDomEventsOnce()
    {
        return $this->domEventsOnce;
    }

    /**
     * @param Event[] $domEventsOnce
     */
    public function setDomEventsOnce(array $domEventsOnce)
    {
        $this->domEventsOnce = [];
        $this->addDomEventsOnce($domEventsOnce);
    }

    /**
     * @param Event[] $domEventsOnce
     */
    public function addDomEventsOnce(array $domEventsOnce)
    {
        foreach ($domEventsOnce as $domEventOnce) {
            $this->addDomEventOnce($domEventOnce);
        }
    }

    /**
     * @return bool
     */
    public function hasDomEventOnce(Event $domEventOnce)
    {
        return in_array($domEventOnce, $this->domEventsOnce, true);
    }

    public function addDomEventOnce(Event $domEventOnce)
    {
        if (!$this->hasDomEventOnce($domEventOnce)) {
            $this->domEventsOnce[] = $domEventOnce;
        }
    }

    public function removeDomEventOnce(Event $domEventOnce)
    {
        unset($this->domEventsOnce[array_search($domEventOnce, $this->domEventsOnce, true)]);
        $this->domEventsOnce = empty($this->domEventsOnce) ? [] : array_values($this->domEventsOnce);
    }

    /**
     * @return bool
     */
    public function hasEvents()
    {
        return !empty($this->events);
    }

    /**
     * @return Event[]
     */
    public function getEvents()
    {
        return $this->events;
    }

    /**
     * @param Event[] $events
     */
    public function setEvents(array $events)
    {
        $this->events = [];
        $this->addEvents($events);
    }

    /**
     * @param Event[] $events
     */
    public function addEvents(array $events)
    {
        foreach ($events as $event) {
            $this->addEvent($event);
        }
    }

    /**
     * @return bool
     */
    public function hasEvent(Event $event)
    {
        return in_array($event, $this->events, true);
    }

    public function addEvent(Event $event)
    {
        if (!$this->hasEvent($event)) {
            $this->events[] = $event;
        }
    }

    public function removeEvent(Event $event)
    {
        unset($this->events[array_search($event, $this->events, true)]);
        $this->events = empty($this->events) ? [] : array_values($this->events);
    }

    /**
     * @return bool
     */
    public function hasEventsOnce()
    {
        return !empty($this->eventsOnce);
    }

    /**
     * @return Event[]
     */
    public function getEventsOnce()
    {
        return $this->eventsOnce;
    }

    /**
     * @param Event[] $eventsOnce
     */
    public function setEventsOnce(array $eventsOnce)
    {
        $this->eventsOnce = [];
        $this->addEventsOnce($eventsOnce);
    }

    /**
     * @param Event[] $eventsOnce
     */
    public function addEventsOnce(array $eventsOnce)
    {
        foreach ($eventsOnce as $eventOnce) {
            $this->addEventOnce($eventOnce);
        }
    }

    /**
     * @return bool
     */
    public function hasEventOnce(Event $eventOnce)
    {
        return in_array($eventOnce, $this->eventsOnce, true);
    }

    public function addEventOnce(Event $eventOnce)
    {
        $this->eventsOnce[] = $eventOnce;
    }

    public function removeEventOnce(Event $eventOnce)
    {
        unset($this->eventsOnce[array_search($eventOnce, $this->eventsOnce, true)]);
        $this->eventsOnce = empty($this->eventsOnce) ? [] : array_values($this->eventsOnce);
    }
}


1		<?php
2
3		/*
4		* This file is part of the Ivory Google Map package.
5		*
6		* (c) Eric GELOEN <[email protected]>
7		*
8		* For the full copyright and license information, please read the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		namespace Ivory\GoogleMap\Event;
13
14		/**
15		* @see http://code.google.com/apis/maps/documentation/javascript/reference.html#MapsEventListener
16		*
17		* @author GeLo <[email protected]>
18		*/
19		class EventManager
20		{
21		/**
22		* @var Event[]
23		*/
24		private $domEvents = [];
25
26		/**
27		* @var Event[]
28		*/
29		private $domEventsOnce = [];
30
31		/**
32		* @var Event[]
33		*/
34		private $events = [];
35
36		/**
37		* @var Event[]
38		*/
39		private $eventsOnce = [];
40
41		/**
42		* @return bool
43		*/
44	20	public function hasDomEvents()
45		{
46	20	return !empty($this->domEvents);
47		}
48
49		/**
50		* @return Event[]
51		*/
52	28	public function getDomEvents()
53		{
54	28	return $this->domEvents;
55		}
56
57		/**
58		* @param Event[] $domEvents
59		*/
60	8	public function setDomEvents(array $domEvents)
61		{
62	8	$this->domEvents = [];
63	8	$this->addDomEvents($domEvents);
64	8	}
65
66		/**
67		* @param Event[] $domEvents
68		*/
69	8	public function addDomEvents(array $domEvents)
70		{
71	8	foreach ($domEvents as $domEvent) {
72	8	$this->addDomEvent($domEvent);
73		}
74	8	}
75
76		/**
77		* @return bool
78		*/
79	24	public function hasDomEvent(Event $domEvent)
80		{
81	24	return in_array($domEvent, $this->domEvents, true);
82		}
83
84	24	public function addDomEvent(Event $domEvent)
85		{
86	24	if (!$this->hasDomEvent($domEvent)) {
87	24	$this->domEvents[] = $domEvent;
88		}
89	24	}
90
91	4	public function removeDomEvent(Event $domEvent)
92		{
93	4	unset($this->domEvents[array_search($domEvent, $this->domEvents, true)]);
94	4	$this->domEvents = empty($this->domEvents) ? [] : array_values($this->domEvents);
95	4	}
96
97		/**
98		* @return bool
99		*/
100	20	public function hasDomEventsOnce()
101		{
102	20	return !empty($this->domEventsOnce);
103		}
104
105		/**
106		* @return Event[]
107		*/
108	28	public function getDomEventsOnce()
109		{
110	28	return $this->domEventsOnce;
111		}
112
113		/**
114		* @param Event[] $domEventsOnce
115		*/
116	8	public function setDomEventsOnce(array $domEventsOnce)
117		{
118	8	$this->domEventsOnce = [];
119	8	$this->addDomEventsOnce($domEventsOnce);
120	8	}
121
122		/**
123		* @param Event[] $domEventsOnce
124		*/
125	8	public function addDomEventsOnce(array $domEventsOnce)
126		{
127	8	foreach ($domEventsOnce as $domEventOnce) {
128	8	$this->addDomEventOnce($domEventOnce);
129		}
130	8	}
131
132		/**
133		* @return bool
134		*/
135	24	public function hasDomEventOnce(Event $domEventOnce)
136		{
137	24	return in_array($domEventOnce, $this->domEventsOnce, true);
138		}
139
140	24	public function addDomEventOnce(Event $domEventOnce)
141		{
142	24	if (!$this->hasDomEventOnce($domEventOnce)) {
143	24	$this->domEventsOnce[] = $domEventOnce;
144		}
145	24	}
146
147	4	public function removeDomEventOnce(Event $domEventOnce)
148		{
149	4	unset($this->domEventsOnce[array_search($domEventOnce, $this->domEventsOnce, true)]);
150	4	$this->domEventsOnce = empty($this->domEventsOnce) ? [] : array_values($this->domEventsOnce);
151	4	}
152
153		/**
154		* @return bool
155		*/
156	20	public function hasEvents()
157		{
158	20	return !empty($this->events);
159		}
160
161		/**
162		* @return Event[]
163		*/
164	28	public function getEvents()
165		{
166	28	return $this->events;
167		}
168
169		/**
170		* @param Event[] $events
171		*/
172	8	public function setEvents(array $events)
173		{
174	8	$this->events = [];
175	8	$this->addEvents($events);
176	8	}
177
178		/**
179		* @param Event[] $events
180		*/
181	8	public function addEvents(array $events)
182		{
183	8	foreach ($events as $event) {
184	8	$this->addEvent($event);
185		}
186	8	}
187
188		/**
189		* @return bool
190		*/
191	24	public function hasEvent(Event $event)
192		{
193	24	return in_array($event, $this->events, true);
194		}
195
196	24	public function addEvent(Event $event)
197		{
198	24	if (!$this->hasEvent($event)) {
199	24	$this->events[] = $event;
200		}
201	24	}
202
203	4	public function removeEvent(Event $event)
204		{
205	4	unset($this->events[array_search($event, $this->events, true)]);
206	4	$this->events = empty($this->events) ? [] : array_values($this->events);
207	4	}
208
209		/**
210		* @return bool
211		*/
212	20	public function hasEventsOnce()
213		{
214	20	return !empty($this->eventsOnce);
215		}
216
217		/**
218		* @return Event[]
219		*/
220	28	public function getEventsOnce()
221		{
222	28	return $this->eventsOnce;
223		}
224
225		/**
226		* @param Event[] $eventsOnce
227		*/
228	8	public function setEventsOnce(array $eventsOnce)
229		{
230	8	$this->eventsOnce = [];
231	8	$this->addEventsOnce($eventsOnce);
232	8	}
233
234		/**
235		* @param Event[] $eventsOnce
236		*/
237	8	public function addEventsOnce(array $eventsOnce)
238		{
239	8	foreach ($eventsOnce as $eventOnce) {
240	8	$this->addEventOnce($eventOnce);
241		}
242	8	}
243
244		/**
245		* @return bool
246		*/
247	12	public function hasEventOnce(Event $eventOnce)
248		{
249	12	return in_array($eventOnce, $this->eventsOnce, true);
250		}
251
252	24	public function addEventOnce(Event $eventOnce)
253		{
254	24	$this->eventsOnce[] = $eventOnce;
255	24	}
256
257	4	public function removeEventOnce(Event $eventOnce)
258		{
259	4	unset($this->eventsOnce[array_search($eventOnce, $this->eventsOnce, true)]);
260	4	$this->eventsOnce = empty($this->eventsOnce) ? [] : array_values($this->eventsOnce);
261	4	}
262		}
263

bresam / ivory-google-map

EventManager::hasEventOnce() A last analyzed 2021-06-14 14:39 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

EventManager::hasEventOnce() A
last analyzed 2021-06-14 14:39 UTC