Ivory\GoogleMap\Overlay\OverlayManager

Complexity

Total Complexity

98

Size/Duplication

Total Lines	600
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

65 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	hasMap()	0	4	1
A	getMap()	0	4	1
A	setMap()	0	8	2
A	getMarkerCluster()	0	4	1
A	setMarkerCluster()	0	8	2
A	hasMarkers()	0	4	1
A	getMarkers()	0	4	1
A	setMarkers()	0	4	1
A	addMarkers()	0	4	1
A	hasMarker()	0	4	1
A	addMarker()	0	4	1
A	removeMarker()	0	4	1
A	hasInfoWindows()	0	4	1
A	getInfoWindows()	0	4	1
A	setInfoWindows()	0	8	2
A	addInfoWindows()	0	6	2
A	hasInfoWindow()	0	4	1
A	addInfoWindow()	0	8	2
A	removeInfoWindow()	0	6	2
A	hasPolylines()	0	4	1
A	getPolylines()	0	4	1
A	setPolylines()	0	8	2
A	addPolylines()	0	6	2
A	hasPolyline()	0	4	1
A	addPolyline()	0	8	2
A	removePolyline()	0	6	2
A	hasEncodedPolylines()	0	4	1
A	getEncodedPolylines()	0	4	1
A	setEncodedPolylines()	0	8	2
A	addEncodedPolylines()	0	6	2
A	hasEncodedPolyline()	0	4	1
A	addEncodedPolyline()	0	8	2
A	removeEncodedPolyline()	0	6	2
A	hasPolygons()	0	4	1
A	getPolygons()	0	4	1
A	setPolygons()	0	8	2
A	addPolygons()	0	6	2
A	hasPolygon()	0	4	1
A	addPolygon()	0	8	2
A	removePolygon()	0	6	2
A	hasRectangles()	0	4	1
A	getRectangles()	0	4	1
A	setRectangles()	0	8	2
A	addRectangles()	0	6	2
A	hasRectangle()	0	4	1
A	addRectangle()	0	8	2
A	removeRectangle()	0	6	2
A	hasCircles()	0	4	1
A	getCircles()	0	4	1
A	setCircles()	0	8	2
A	addCircles()	0	6	2
A	hasCircle()	0	4	1
A	addCircle()	0	8	2
A	removeCircle()	0	6	2
A	hasGroundOverlays()	0	4	1
A	getGroundOverlays()	0	4	1
A	setGroundOverlays()	0	8	2
A	addGroundOverlays()	0	6	2
A	hasGroundOverlay()	0	4	1
A	addGroundOverlay()	0	8	2
A	removeGroundOverlay()	0	6	2
A	addExtendable()	0	6	2
A	removeExtendable()	0	6	2
A	isAutoZoom()	0	4	2

<?php

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

namespace Ivory\GoogleMap\Overlay;

use Ivory\GoogleMap\Map;

/**
 * @author GeLo <geloen.eric@gmail.com>
 */
class OverlayManager
{
    /**
     * @var Map|null
     */
    private $map;

    /**
     * @var MarkerCluster
     */
    private $markerCluster;

    /**
     * @var InfoWindow[]
     */
    private $infoWindows = [];

    /**
     * @var Polyline[]
     */
    private $polylines = [];

    /**
     * @var EncodedPolyline[]
     */
    private $encodedPolylines = [];

    /**
     * @var Polygon[]
     */
    private $polygons = [];

    /**
     * @var Rectangle[]
     */
    private $rectangles = [];

    /**
     * @var Circle[]
     */
    private $circles = [];

    /**
     * @var GroundOverlay[]
     */
    private $groundOverlays = [];

    public function __construct()
    {
        $this->setMarkerCluster(new MarkerCluster());
    }

    /**
     * @return bool
     */
    public function hasMap()
    {
        return null !== $this->map;
    }

    /**
     * @return Map|null
     */
    public function getMap()
    {
        return $this->map;
    }

    public function setMap(Map $map)
    {
        $this->map = $map;

        if ($map->getOverlayManager() !== $this) {
            $map->setOverlayManager($this);
        }
    }

    /**
     * @return MarkerCluster
     */
    public function getMarkerCluster()
    {
        return $this->markerCluster;
    }

    public function setMarkerCluster(MarkerCluster $markerCluster)
    {
        $this->markerCluster = $markerCluster;

        if ($markerCluster->getOverlayManager() !== $this) {
            $markerCluster->setOverlayManager($this);
        }
    }

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

    /**
     * @return Marker[]
     */
    public function getMarkers()
    {
        return $this->markerCluster->getMarkers();
    }

    /**
     * @param Marker[] $markers
     */
    public function setMarkers(array $markers)
    {
        $this->markerCluster->setMarkers($markers);
    }

    /**
     * @param Marker[] $markers
     */
    public function addMarkers(array $markers)
    {
        $this->markerCluster->addMarkers($markers);
    }

    /**
     * @return bool
     */
    public function hasMarker(Marker $marker)
    {
        return $this->markerCluster->hasMarker($marker);
    }

    public function addMarker(Marker $marker)
    {
        $this->markerCluster->addMarker($marker);
    }

    public function removeMarker(Marker $marker)
    {
        $this->markerCluster->removeMarker($marker);
    }

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

    /**
     * @return InfoWindow[]
     */
    public function getInfoWindows()
    {
        return $this->infoWindows;
    }

    /**
     * @param InfoWindow[] $infoWindows
     */
    public function setInfoWindows(array $infoWindows)
    {
        foreach ($this->infoWindows as $infoWindow) {
            $this->removeInfoWindow($infoWindow);
        }

        $this->addInfoWindows($infoWindows);
    }

    /**
     * @param InfoWindow[] $infoWindows
     */
    public function addInfoWindows(array $infoWindows)
    {
        foreach ($infoWindows as $infoWindow) {
            $this->addInfoWindow($infoWindow);
        }
    }

    /**
     * @return bool
     */
    public function hasInfoWindow(InfoWindow $infoWindow)
    {
        return in_array($infoWindow, $this->infoWindows, true);
    }

    public function addInfoWindow(InfoWindow $infoWindow)
    {
        if (!$this->hasInfoWindow($infoWindow)) {
            $this->infoWindows[] = $infoWindow;
        }

        $this->addExtendable($infoWindow);
    }

    public function removeInfoWindow(InfoWindow $infoWindow)
    {
        unset($this->infoWindows[array_search($infoWindow, $this->infoWindows, true)]);
        $this->infoWindows = empty($this->infoWindows) ? [] : array_values($this->infoWindows);
        $this->removeExtendable($infoWindow);
    }

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

    /**
     * @return Polyline[]
     */
    public function getPolylines()
    {
        return $this->polylines;
    }

    /**
     * @param Polyline[] $polylines
     */
    public function setPolylines(array $polylines)
    {
        foreach ($this->polylines as $polyline) {
            $this->removePolyline($polyline);
        }

        $this->addPolylines($polylines);
    }

    /**
     * @param Polyline[] $polylines
     */
    public function addPolylines(array $polylines)
    {
        foreach ($polylines as $polyline) {
            $this->addPolyline($polyline);
        }
    }

    /**
     * @return bool
     */
    public function hasPolyline(Polyline $polyline)
    {
        return in_array($polyline, $this->polylines, true);
    }

    public function addPolyline(Polyline $polyline)
    {
        if (!$this->hasPolyline($polyline)) {
            $this->polylines[] = $polyline;
        }

        $this->addExtendable($polyline);
    }

    public function removePolyline(Polyline $polyline)
    {
        unset($this->polylines[array_search($polyline, $this->polylines, true)]);
        $this->polylines = empty($this->polylines) ? [] : array_values($this->polylines);
        $this->removeExtendable($polyline);
    }

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

    /**
     * @return EncodedPolyline[]
     */
    public function getEncodedPolylines()
    {
        return $this->encodedPolylines;
    }

    /**
     * @param EncodedPolyline[] $encodedPolylines
     */
    public function setEncodedPolylines(array $encodedPolylines)
    {
        foreach ($this->encodedPolylines as $encodedPolyline) {
            $this->removeEncodedPolyline($encodedPolyline);
        }

        $this->addEncodedPolylines($encodedPolylines);
    }

    /**
     * @param EncodedPolyline[] $encodedPolylines
     */
    public function addEncodedPolylines(array $encodedPolylines)
    {
        foreach ($encodedPolylines as $encodedPolyline) {
            $this->addEncodedPolyline($encodedPolyline);
        }
    }

    /**
     * @return bool
     */
    public function hasEncodedPolyline(EncodedPolyline $encodedPolyline)
    {
        return in_array($encodedPolyline, $this->encodedPolylines, true);
    }

    public function addEncodedPolyline(EncodedPolyline $encodedPolyline)
    {
        if (!$this->hasEncodedPolyline($encodedPolyline)) {
            $this->encodedPolylines[] = $encodedPolyline;
        }

        $this->addExtendable($encodedPolyline);
    }

    public function removeEncodedPolyline(EncodedPolyline $encodedPolyline)
    {
        unset($this->encodedPolylines[array_search($encodedPolyline, $this->encodedPolylines, true)]);
        $this->encodedPolylines = empty($this->encodedPolylines) ? [] : array_values($this->encodedPolylines);
        $this->removeExtendable($encodedPolyline);
    }

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

    /**
     * @return Polygon[]
     */
    public function getPolygons()
    {
        return $this->polygons;
    }

    /**
     * @param Polygon[] $polygons
     */
    public function setPolygons(array $polygons)
    {
        foreach ($this->polygons as $polygon) {
            $this->removePolygon($polygon);
        }

        $this->addPolygons($polygons);
    }

    /**
     * @param Polygon[] $polygons
     */
    public function addPolygons(array $polygons)
    {
        foreach ($polygons as $polygon) {
            $this->addPolygon($polygon);
        }
    }

    /**
     * @return bool
     */
    public function hasPolygon(Polygon $polygon)
    {
        return in_array($polygon, $this->polygons, true);
    }

    public function addPolygon(Polygon $polygon)
    {
        if (!$this->hasPolygon($polygon)) {
            $this->polygons[] = $polygon;
        }

        $this->addExtendable($polygon);
    }

    public function removePolygon(Polygon $polygon)
    {
        unset($this->polygons[array_search($polygon, $this->polygons, true)]);
        $this->polygons = empty($this->polygons) ? [] : array_values($this->polygons);
        $this->removeExtendable($polygon);
    }

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

    /**
     * @return Rectangle[]
     */
    public function getRectangles()
    {
        return $this->rectangles;
    }

    /**
     * @param Rectangle[] $rectangles
     */
    public function setRectangles(array $rectangles)
    {
        foreach ($this->rectangles as $rectangle) {
            $this->removeRectangle($rectangle);
        }

        $this->addRectangles($rectangles);
    }

    /**
     * @param Rectangle[] $rectangles
     */
    public function addRectangles(array $rectangles)
    {
        foreach ($rectangles as $rectangle) {
            $this->addRectangle($rectangle);
        }
    }

    /**
     * @return bool
     */
    public function hasRectangle(Rectangle $rectangle)
    {
        return in_array($rectangle, $this->rectangles, true);
    }

    public function addRectangle(Rectangle $rectangle)
    {
        if (!$this->hasRectangle($rectangle)) {
            $this->rectangles[] = $rectangle;
        }

        $this->addExtendable($rectangle);
    }

    public function removeRectangle(Rectangle $rectangle)
    {
        unset($this->rectangles[array_search($rectangle, $this->rectangles, true)]);
        $this->rectangles = empty($this->rectangles) ? [] : array_values($this->rectangles);
        $this->removeExtendable($rectangle);
    }

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

    /**
     * @return Circle[]
     */
    public function getCircles()
    {
        return $this->circles;
    }

    /**
     * @param Circle[] $circles
     */
    public function setCircles(array $circles)
    {
        foreach ($this->circles as $circle) {
            $this->removeCircle($circle);
        }

        $this->addCircles($circles);
    }

    /**
     * @param Circle[] $circles
     */
    public function addCircles(array $circles)
    {
        foreach ($circles as $circle) {
            $this->addCircle($circle);
        }
    }

    /**
     * @return bool
     */
    public function hasCircle(Circle $circle)
    {
        return in_array($circle, $this->circles, true);
    }

    public function addCircle(Circle $circle)
    {
        if (!$this->hasCircle($circle)) {
            $this->circles[] = $circle;
        }

        $this->addExtendable($circle);
    }

    public function removeCircle(Circle $circle)
    {
        unset($this->circles[array_search($circle, $this->circles, true)]);
        $this->circles = empty($this->circles) ? [] : array_values($this->circles);
        $this->removeExtendable($circle);
    }

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

    /**
     * @return GroundOverlay[]
     */
    public function getGroundOverlays()
    {
        return $this->groundOverlays;
    }

    /**
     * @param GroundOverlay[] $groundOverlays
     */
    public function setGroundOverlays(array $groundOverlays)
    {
        foreach ($this->groundOverlays as $groundOverlay) {
            $this->removeGroundOverlay($groundOverlay);
        }

        $this->addGroundOverlays($groundOverlays);
    }

    /**
     * @param GroundOverlay[] $groundOverlays
     */
    public function addGroundOverlays(array $groundOverlays)
    {
        foreach ($groundOverlays as $groundOverlay) {
            $this->addGroundOverlay($groundOverlay);
        }
    }

    /**
     * @return bool
     */
    public function hasGroundOverlay(GroundOverlay $groundOverlay)
    {
        return in_array($groundOverlay, $this->groundOverlays, true);
    }

    public function addGroundOverlay(GroundOverlay $groundOverlay)
    {
        if (!$this->hasGroundOverlay($groundOverlay)) {
            $this->groundOverlays[] = $groundOverlay;
        }

        $this->addExtendable($groundOverlay);
    }

    public function removeGroundOverlay(GroundOverlay $groundOverlay)
    {
        unset($this->groundOverlays[array_search($groundOverlay, $this->groundOverlays, true)]);
        $this->groundOverlays = empty($this->groundOverlays) ? [] : array_values($this->groundOverlays);
        $this->removeExtendable($groundOverlay);
    }

    private function addExtendable(ExtendableInterface $extendable)
    {
        if ($this->isAutoZoom()) {
            $this->getMap()->getBound()->addExtendable($extendable);
        }
    }

    private function removeExtendable(ExtendableInterface $extendable)
    {
        if ($this->isAutoZoom()) {
            $this->getMap()->getBound()->removeExtendable($extendable);
        }
    }

    /**
     * @return bool
     */
    private function isAutoZoom()
    {
        return $this->hasMap() && $this->getMap()->isAutoZoom();
    }
}