ApiEvent::removeCallbackObject() - Code Metrics - Inspection of "Move language from map/autocomplete to the rendere..." - egeloen/ivory-google-map - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#135)

by Eric

created 2016-08-12 21:38 UTC

ApiEvent::removeCallbackObject() A

↳ Parent: ApiEvent

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

/*
 * 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\Helper\Event;

/**
 * @author GeLo <[email protected]>
 */
class ApiEvent extends AbstractEvent
{
    /**
     * @var object[]
     */
    private $objects;

    /**
     * @var string[]
     */
    private $sources = [];

    /**
     * @var string[]
     */
    private $libraries = [];

    /**
     * @var \SplObjectStorage
     */
    private $callbacks;

    /**
     * @var \SplObjectStorage
     */
    private $requirements;

    /**
     * @param object[] $objects
     */
    public function __construct(array $objects)
    {
        $this->objects = $objects;
        $this->callbacks = new \SplObjectStorage();
        $this->requirements = new \SplObjectStorage();
    }

    /**
     * @param string|null $class
     *
     * @return bool
     */
    public function hasObjects($class = null)
    {
        $objects = $this->getObjects($class);

        return !empty($objects);
    }

    /**
     * @param string|null $class
     *
     * @return object[]
     */
    public function getObjects($class = null)
    {
        if ($class === null) {
            return $this->objects;
        }

        $objects = [];

        foreach ($this->objects as $object) {
            if ($object instanceof $class) {
                $objects[] = $object;
            }
        }

        return $objects;
    }

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

    /**
     * @return string[]
     */
    public function getSources()
    {
        return $this->sources;
    }

    /**
     * @param string[] $sources
     */
    public function setSources(array $sources)
    {
        $this->sources = [];
        $this->addSources($sources);
    }

    /**
     * @param string[] $sources
     */
    public function addSources(array $sources)
    {
        foreach ($sources as $source) {
            $this->addSource($source);
        }
    }

    /**
     * @param string $source
     *
     * @return bool
     */
    public function hasSource($source)
    {
        return in_array($source, $this->sources, true);
    }

    /**
     * @param string $source
     */
    public function addSource($source)
    {
        if (!$this->hasSource($source)) {
            $this->sources[] = $source;
        }
    }

    /**
     * @param string $source
     */
    public function removeSource($source)
    {
        unset($this->sources[array_search($source, $this->sources, true)]);
        $this->sources = array_values($this->sources);
    }

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

    /**
     * @return string[]
     */
    public function getLibraries()
    {
        return $this->libraries;
    }

    /**
     * @param string[] $libraries
     */
    public function setLibraries(array $libraries)
    {
        $this->libraries = [];
        $this->addLibraries($libraries);
    }

    /**
     * @param string[] $libraries
     */
    public function addLibraries(array $libraries)
    {
        foreach ($libraries as $library) {
            $this->addLibrary($library);
        }
    }

    /**
     * @param string $library
     *
     * @return bool
     */
    public function hasLibrary($library)
    {
        return in_array($library, $this->libraries, true);
    }

    /**
     * @param string $library
     */
    public function addLibrary($library)
    {
        if (!$this->hasLibrary($library)) {
            $this->libraries[] = $library;
        }
    }

    /**
     * @param string $library
     */
    public function removeLibrary($library)
    {
        unset($this->libraries[array_search($library, $this->libraries, true)]);
        $this->libraries = array_values($this->libraries);
    }

    /**
     * @return bool
     */
    public function hasCallbacks()
    {
        return count($this->callbacks) > 0;
    }

    /**
     * @return \SplObjectStorage
     */
    public function getCallbacks()
    {
        return $this->callbacks;
    }

    /**
     * @param string      $callback
     * @param object|null $object
     *
     * @return bool
     */
    public function hasCallback($callback, $object = null)
    {
        foreach ($this->callbacks as $rawObject) {
            if ($this->callbacks[$rawObject] === $callback && ($object === null || $object === $rawObject)) {
                return true;
            }
        }

        return false;
    }

    /**
     * @param object      $object
     * @param string|null $callback
     *
     * @return bool
     */
    public function hasCallbackObject($object, $callback = null)
    {
        return isset($this->callbacks[$object]) && ($callback === null || $this->callbacks[$object] === $callback);
    }

    /**
     * @param $object
     *
     * @return string|null
     */
    public function getCallback($object)
    {
        return $this->hasCallbackObject($object) ? $this->callbacks[$object] : null;
    }

    /**
     * @param string $callback
     *
     * @return object
     */
    public function getCallbackObject($callback)
    {
        foreach ($this->callbacks as $object) {
            if ($this->callbacks[$object] === $callback) {
                return $object;
            }
        }
    }

    /**
     * @param object $object
     * @param string $callback
     */
    public function addCallback($object, $callback)
    {
        if (!$this->hasCallback($callback, $object)) {
            $this->callbacks[$object] = $callback;
        }
    }

    /**
     * @param object $object
     */
    public function removeCallbackObject($object)
    {
        unset($this->callbacks[$object]);
    }

    /**
     * @param string $callback
     */
    public function removeCallback($callback)
    {
        if ($this->hasCallback($callback)) {
            $this->removeCallbackObject($this->getCallbackObject($callback));

        }
    }

    /**
     * @param object|null $object
     *
     * @return bool
     */
    public function hasRequirements($object = null)
    {
        if ($object === null) {
            return count($this->requirements) > 0;
        }

        $requirements = $this->getRequirementsObject($object);

        return !empty($requirements);
    }

    /**
     * @return \SplObjectStorage
     */
    public function getRequirements()
    {
        return $this->requirements;
    }

    /**
     * @param object $object
     *
     * @return string[]
     */
    public function getRequirementsObject($object)
    {
        return $this->hasRequirement($object) ? $this->requirements[$object] : [];
    }

    /**
     * @param object   $object
     * @param string[] $requirements
     */
    public function setRequirements($object, array $requirements)
    {
        $this->requirements = new \SplObjectStorage();
        $this->addRequirements($object, $requirements);
    }

    /**
     * @param object   $object
     * @param string[] $requirements
     */
    public function addRequirements($object, array $requirements)
    {
        foreach ($requirements as $requirement) {
            $this->addRequirement($object, $requirement);
        }
    }

    /**
     * @param object      $object
     * @param string|null $requirement
     *
     * @return bool
     */
    public function hasRequirement($object, $requirement = null)
    {
        return isset($this->requirements[$object])
            && ($requirement === null || in_array($requirement, $this->requirements[$object], true));
    }

    /**
     * @param object $object
     * @param string $requirement
     */
    public function addRequirement($object, $requirement)
    {
        if (!$this->hasRequirement($object)) {
            $this->requirements[$object] = [];
        }

        if (!$this->hasRequirement($object, $requirement)) {
            $this->requirements[$object] = array_merge(
                $this->requirements[$object],
                [$requirement]
            );
        }
    }

    /**
     * @param object      $object
     * @param string|null $requirement
     */
    public function removeRequirement($object, $requirement = null)
    {
        if ($requirement === null) {
            unset($this->requirements[$object]);

            return;
        }

        if ($this->hasRequirement($object, $requirement)) {
            $requirements = $this->requirements[$object];
            unset($requirements[array_search($requirement, $requirements, true)]);

            if (!empty($requirements)) {
                $this->requirements[$object] = array_values($requirements);
            } else {
                $this->removeRequirement($object);
            }
        }
    }
}


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\Helper\Event;
13
14			/**
15			* @author GeLo <[email protected]>
16			*/
17			class ApiEvent extends AbstractEvent
18			{
19			/**
20			* @var object[]
21			*/
22			private $objects;
23
24			/**
25			* @var string[]
26			*/
27			private $sources = [];
28
29			/**
30			* @var string[]
31			*/
32			private $libraries = [];
33
34			/**
35			* @var \SplObjectStorage
36			*/
37			private $callbacks;
38
39			/**
40			* @var \SplObjectStorage
41			*/
42			private $requirements;
43
44			/**
45			* @param object[] $objects
46			*/
47			public function __construct(array $objects)
48			{
49			$this->objects = $objects;
50			$this->callbacks = new \SplObjectStorage();
51			$this->requirements = new \SplObjectStorage();
52			}
53
54			/**
55			* @param string\|null $class
56			*
57			* @return bool
58			*/
59			public function hasObjects($class = null)
60			{
61			$objects = $this->getObjects($class);
62
63			return !empty($objects);
64			}
65
66			/**
67			* @param string\|null $class
68			*
69			* @return object[]
70			*/
71			public function getObjects($class = null)
72			{
73			if ($class === null) {
74			return $this->objects;
75			}
76
77			$objects = [];
78
79			foreach ($this->objects as $object) {
80			if ($object instanceof $class) {
81			$objects[] = $object;
82			}
83			}
84
85			return $objects;
86			}
87
88			/**
89			* @return bool
90			*/
91			public function hasSources()
92			{
93			return !empty($this->sources);
94			}
95
96			/**
97			* @return string[]
98			*/
99			public function getSources()
100			{
101			return $this->sources;
102			}
103
104			/**
105			* @param string[] $sources
106			*/
107			public function setSources(array $sources)
108			{
109			$this->sources = [];
110			$this->addSources($sources);
111			}
112
113			/**
114			* @param string[] $sources
115			*/
116			public function addSources(array $sources)
117			{
118			foreach ($sources as $source) {
119			$this->addSource($source);
120			}
121			}
122
123			/**
124			* @param string $source
125			*
126			* @return bool
127			*/
128			public function hasSource($source)
129			{
130			return in_array($source, $this->sources, true);
131			}
132
133			/**
134			* @param string $source
135			*/
136			public function addSource($source)
137			{
138			if (!$this->hasSource($source)) {
139			$this->sources[] = $source;
140			}
141			}
142
143			/**
144			* @param string $source
145			*/
146			public function removeSource($source)
147			{
148			unset($this->sources[array_search($source, $this->sources, true)]);
149			$this->sources = array_values($this->sources);
150			}
151
152			/**
153			* @return bool
154			*/
155			public function hasLibraries()
156			{
157			return !empty($this->libraries);
158			}
159
160			/**
161			* @return string[]
162			*/
163			public function getLibraries()
164			{
165			return $this->libraries;
166			}
167
168			/**
169			* @param string[] $libraries
170			*/
171			public function setLibraries(array $libraries)
172			{
173			$this->libraries = [];
174			$this->addLibraries($libraries);
175			}
176
177			/**
178			* @param string[] $libraries
179			*/
180			public function addLibraries(array $libraries)
181			{
182			foreach ($libraries as $library) {
183			$this->addLibrary($library);
184			}
185			}
186
187			/**
188			* @param string $library
189			*
190			* @return bool
191			*/
192			public function hasLibrary($library)
193			{
194			return in_array($library, $this->libraries, true);
195			}
196
197			/**
198			* @param string $library
199			*/
200			public function addLibrary($library)
201			{
202			if (!$this->hasLibrary($library)) {
203			$this->libraries[] = $library;
204			}
205			}
206
207			/**
208			* @param string $library
209			*/
210			public function removeLibrary($library)
211			{
212			unset($this->libraries[array_search($library, $this->libraries, true)]);
213			$this->libraries = array_values($this->libraries);
214			}
215
216			/**
217			* @return bool
218			*/
219			public function hasCallbacks()
220			{
221			return count($this->callbacks) > 0;
222			}
223
224			/**
225			* @return \SplObjectStorage
226			*/
227			public function getCallbacks()
228			{
229			return $this->callbacks;
230			}
231
232			/**
233			* @param string $callback
234			* @param object\|null $object
235			*
236			* @return bool
237			*/
238			public function hasCallback($callback, $object = null)
239			{
240			foreach ($this->callbacks as $rawObject) {
241			if ($this->callbacks[$rawObject] === $callback && ($object === null \|\| $object === $rawObject)) {
242			return true;
243			}
244			}
245
246			return false;
247			}
248
249			/**
250			* @param object $object
251			* @param string\|null $callback
252			*
253			* @return bool
254			*/
255			public function hasCallbackObject($object, $callback = null)
256			{
257			return isset($this->callbacks[$object]) && ($callback === null \|\| $this->callbacks[$object] === $callback);
258			}
259
260			/**
261			* @param $object
262			*
263			* @return string\|null
264			*/
265			public function getCallback($object)
266			{
267			return $this->hasCallbackObject($object) ? $this->callbacks[$object] : null;
268			}
269
270			/**
271			* @param string $callback
272			*
273			* @return object
274			*/
275			public function getCallbackObject($callback)
276			{
277			foreach ($this->callbacks as $object) {
278			if ($this->callbacks[$object] === $callback) {
279			return $object;
280			}
281			}
282			}
283
284			/**
285			* @param object $object
286			* @param string $callback
287			*/
288			public function addCallback($object, $callback)
289			{
290			if (!$this->hasCallback($callback, $object)) {
291			$this->callbacks[$object] = $callback;
292			}
293			}
294
295			/**
296			* @param object $object
297			*/
298			public function removeCallbackObject($object)
299			{
300			unset($this->callbacks[$object]);
301			}
302
303			/**
304			* @param string $callback
305			*/
306			public function removeCallback($callback)
307			{
308			if ($this->hasCallback($callback)) {
309			$this->removeCallbackObject($this->getCallbackObject($callback));
			0 ignored issues – show Bug introduced 2016-08-12 19:23 UTC by Report Bug Copy Issue Report It seems like `$this->getCallbackObject($callback)` targeting `Ivory\GoogleMap\Helper\E...nt::getCallbackObject()` can also be of type `null`; however, `Ivory\GoogleMap\Helper\E...:removeCallbackObject()` does only seem to accept `object`, maybe add an additional type check? This check looks at variables that are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
310			}
311			}
312
313			/**
314			* @param object\|null $object
315			*
316			* @return bool
317			*/
318			public function hasRequirements($object = null)
319			{
320			if ($object === null) {
321			return count($this->requirements) > 0;
322			}
323
324			$requirements = $this->getRequirementsObject($object);
325
326			return !empty($requirements);
327			}
328
329			/**
330			* @return \SplObjectStorage
331			*/
332			public function getRequirements()
333			{
334			return $this->requirements;
335			}
336
337			/**
338			* @param object $object
339			*
340			* @return string[]
341			*/
342			public function getRequirementsObject($object)
343			{
344			return $this->hasRequirement($object) ? $this->requirements[$object] : [];
345			}
346
347			/**
348			* @param object $object
349			* @param string[] $requirements
350			*/
351			public function setRequirements($object, array $requirements)
352			{
353			$this->requirements = new \SplObjectStorage();
354			$this->addRequirements($object, $requirements);
355			}
356
357			/**
358			* @param object $object
359			* @param string[] $requirements
360			*/
361			public function addRequirements($object, array $requirements)
362			{
363			foreach ($requirements as $requirement) {
364			$this->addRequirement($object, $requirement);
365			}
366			}
367
368			/**
369			* @param object $object
370			* @param string\|null $requirement
371			*
372			* @return bool
373			*/
374			public function hasRequirement($object, $requirement = null)
375			{
376			return isset($this->requirements[$object])
377			&& ($requirement === null \|\| in_array($requirement, $this->requirements[$object], true));
378			}
379
380			/**
381			* @param object $object
382			* @param string $requirement
383			*/
384			public function addRequirement($object, $requirement)
385			{
386			if (!$this->hasRequirement($object)) {
387			$this->requirements[$object] = [];
388			}
389
390			if (!$this->hasRequirement($object, $requirement)) {
391			$this->requirements[$object] = array_merge(
392			$this->requirements[$object],
393			[$requirement]
394			);
395			}
396			}
397
398			/**
399			* @param object $object
400			* @param string\|null $requirement
401			*/
402			public function removeRequirement($object, $requirement = null)
403			{
404			if ($requirement === null) {
405			unset($this->requirements[$object]);
406
407			return;
408			}
409
410			if ($this->hasRequirement($object, $requirement)) {
411			$requirements = $this->requirements[$object];
412			unset($requirements[array_search($requirement, $requirements, true)]);
413
414			if (!empty($requirements)) {
415			$this->requirements[$object] = array_values($requirements);
416			} else {
417			$this->removeRequirement($object);
418			}
419			}
420			}
421			}
422

egeloen / ivory-google-map

GitHub Access Token became invalid

Pull Request — master (#135)

ApiEvent::removeCallbackObject() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like