Code Duplication - egeloen/ivory-google-map - Measure and Improve Code Quality continuously with Scrutinizer


/**
 * @author GeLo <[email protected]>
 */
class BoundSubscriber extends AbstractSubscriber
{
    /**
     * @var BoundCollector
     */
    private $boundCollector;

    /**
     * @var BoundRenderer
     */
    private $boundRenderer;

    /**
     * @param Formatter      $formatter
     * @param BoundCollector $boundCollector
     * @param BoundRenderer  $boundRenderer
     */
    public function __construct(
        Formatter $formatter,
        BoundCollector $boundCollector,
        BoundRenderer $boundRenderer
    ) {
        parent::__construct($formatter);

        $this->setBoundCollector($boundCollector);
        $this->setBoundRenderer($boundRenderer);
    }

    /**
     * @return BoundCollector
     */
    public function getBoundCollector()
    {
        return $this->boundCollector;
    }

    /**
     * @param BoundCollector $boundCollector
     */
    public function setBoundCollector(BoundCollector $boundCollector)
    {
        $this->boundCollector = $boundCollector;
    }

    /**
     * @return BoundRenderer
     */
    public function getBoundRenderer()
    {
        return $this->boundRenderer;
    }

    /**
     * @param BoundRenderer $boundRenderer
     */
    public function setBoundRenderer(BoundRenderer $boundRenderer)
    {
        $this->boundRenderer = $boundRenderer;
    }

    /**
     * @param MapEvent $event
     */
    public function handleMap(MapEvent $event)
    {
        $formatter = $this->getFormatter();
        $map = $event->getMap();

        foreach ($this->boundCollector->collect($map) as $bound) {
            $event->addCode($formatter->renderContainerAssignment(
                $map,
                $this->boundRenderer->render($bound),
                'base.bounds',
                $bound
            ));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [MapEvents::JAVASCRIPT_BASE_BOUND => 'handleMap'];
    }
}



/**
 * @author GeLo <[email protected]>
 */
class CoordinateSubscriber extends AbstractSubscriber
{
    /**
     * @var CoordinateCollector
     */
    private $coordinateCollector;

    /**
     * @var CoordinateRenderer
     */
    private $coordinateRenderer;

    /**
     * @param Formatter           $formatter
     * @param CoordinateCollector $coordinateCollector
     * @param CoordinateRenderer  $coordinateRenderer
     */
    public function __construct(
        Formatter $formatter,
        CoordinateCollector $coordinateCollector,
        CoordinateRenderer $coordinateRenderer
    ) {
        parent::__construct($formatter);

        $this->setCoordinateCollector($coordinateCollector);
        $this->setCoordinateRenderer($coordinateRenderer);
    }

    /**
     * @return CoordinateCollector
     */
    public function getCoordinateCollector()
    {
        return $this->coordinateCollector;
    }

    /**
     * @param CoordinateCollector $coordinateCollector
     */
    public function setCoordinateCollector(CoordinateCollector $coordinateCollector)
    {
        $this->coordinateCollector = $coordinateCollector;
    }

    /**
     * @return CoordinateRenderer
     */
    public function getCoordinateRenderer()
    {
        return $this->coordinateRenderer;
    }

    /**
     * @param CoordinateRenderer $coordinateRenderer
     */
    public function setCoordinateRenderer(CoordinateRenderer $coordinateRenderer)
    {
        $this->coordinateRenderer = $coordinateRenderer;
    }

    /**
     * @param MapEvent $event
     */
    public function handleMap(MapEvent $event)
    {
        $formatter = $this->getFormatter();
        $map = $event->getMap();

        foreach ($this->coordinateCollector->collect($map) as $coordinate) {
            $event->addCode($formatter->renderContainerAssignment(
                $map,
                $this->coordinateRenderer->render($coordinate),
                'base.coordinates',
                $coordinate
            ));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [MapEvents::JAVASCRIPT_BASE_COORDINATE => 'handleMap'];
    }
}



/**
 * @author GeLo <[email protected]>
 */
class PointSubscriber extends AbstractSubscriber
{
    /**
     * @var PointCollector
     */
    private $pointCollector;

    /**
     * @var PointRenderer
     */
    private $pointRenderer;

    /**
     * @param Formatter      $formatter
     * @param PointCollector $pointCollector
     * @param PointRenderer  $pointRenderer
     */
    public function __construct(
        Formatter $formatter,
        PointCollector $pointCollector,
        PointRenderer $pointRenderer
    ) {
        parent::__construct($formatter);

        $this->setPointCollector($pointCollector);
        $this->setPointRenderer($pointRenderer);
    }

    /**
     * @return PointCollector
     */
    public function getPointCollector()
    {
        return $this->pointCollector;
    }

    /**
     * @param PointCollector $pointCollector
     */
    public function setPointCollector(PointCollector $pointCollector)
    {
        $this->pointCollector = $pointCollector;
    }

    /**
     * @return PointRenderer
     */
    public function getPointRenderer()
    {
        return $this->pointRenderer;
    }

    /**
     * @param PointRenderer $pointRenderer
     */
    public function setPointRenderer(PointRenderer $pointRenderer)
    {
        $this->pointRenderer = $pointRenderer;
    }

    /***
     * @param MapEvent $event
     */
    public function handleMap(MapEvent $event)
    {
        $formatter = $this->getFormatter();
        $map = $event->getMap();

        foreach ($this->pointCollector->collect($map) as $point) {
            $event->addCode($formatter->renderContainerAssignment(
                $map,
                $this->pointRenderer->render($point),
                'base.points',
                $point
            ));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [MapEvents::JAVASCRIPT_BASE_POINT => 'handleMap'];
    }
}



/**
 * @author GeLo <[email protected]>
 */
class SizeSubscriber extends AbstractSubscriber
{
    /**
     * @var SizeCollector
     */
    private $sizeCollector;

    /**
     * @var SizeRenderer
     */
    private $sizeRenderer;

    /**
     * @param Formatter     $formatter
     * @param SizeCollector $sizeCollector
     * @param SizeRenderer  $sizeRenderer
     */
    public function __construct(
        Formatter $formatter,
        SizeCollector $sizeCollector,
        SizeRenderer $sizeRenderer
    ) {
        parent::__construct($formatter);

        $this->setSizeCollector($sizeCollector);
        $this->setSizeRenderer($sizeRenderer);
    }

    /**
     * @return SizeCollector
     */
    public function getSizeCollector()
    {
        return $this->sizeCollector;
    }

    /**
     * @param SizeCollector $sizeCollector
     */
    public function setSizeCollector(SizeCollector $sizeCollector)
    {
        $this->sizeCollector = $sizeCollector;
    }

    /**
     * @return SizeRenderer
     */
    public function getSizeRenderer()
    {
        return $this->sizeRenderer;
    }

    /**
     * @param SizeRenderer $sizeRenderer
     */
    public function setSizeRenderer(SizeRenderer $sizeRenderer)
    {
        $this->sizeRenderer = $sizeRenderer;
    }

    /**
     * @param MapEvent $event
     */
    public function handleMap(MapEvent $event)
    {
        $formatter = $this->getFormatter();
        $map = $event->getMap();

        foreach ($this->sizeCollector->collect($map) as $size) {
            $event->addCode($formatter->renderContainerAssignment(
                $map,
                $this->sizeRenderer->render($size),
                'base.sizes',
                $size
            ));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [MapEvents::JAVASCRIPT_BASE_SIZE => 'handleMap'];
    }
}



/**
 * @author GeLo <[email protected]>
 */
class DomEventOnceSubscriber extends AbstractSubscriber
{
    /**
     * @var DomEventOnceCollector
     */
    private $domEventOnceCollector;

    /**
     * @var DomEventOnceRenderer
     */
    private $domEventOnceRenderer;

    /**
     * @param Formatter             $formatter
     * @param DomEventOnceCollector $domEventOnceCollector
     * @param DomEventOnceRenderer  $domEventOnceRenderer
     */
    public function __construct(
        Formatter $formatter,
        DomEventOnceCollector $domEventOnceCollector,
        DomEventOnceRenderer $domEventOnceRenderer
    ) {
        parent::__construct($formatter);

        $this->setDomEventOnceCollector($domEventOnceCollector);
        $this->setDomEventOnceRenderer($domEventOnceRenderer);
    }

    /**
     * @return DomEventOnceCollector
     */
    public function getDomEventOnceCollector()
    {
        return $this->domEventOnceCollector;
    }

    /**
     * @param DomEventOnceCollector $domEventOnceCollector
     */
    public function setDomEventOnceCollector(DomEventOnceCollector $domEventOnceCollector)
    {
        $this->domEventOnceCollector = $domEventOnceCollector;
    }

    /**
     * @return DomEventOnceRenderer
     */
    public function getDomEventOnceRenderer()
    {
        return $this->domEventOnceRenderer;
    }

    /**
     * @param DomEventOnceRenderer $domEventOnceRenderer
     */
    public function setDomEventOnceRenderer(DomEventOnceRenderer $domEventOnceRenderer)
    {
        $this->domEventOnceRenderer = $domEventOnceRenderer;
    }

    /**
     * @param MapEvent $event
     */
    public function handleMap(MapEvent $event)
    {
        $formatter = $this->getFormatter();
        $map = $event->getMap();

        foreach ($this->domEventOnceCollector->collect($map) as $domEventOnce) {
            $event->addCode($formatter->renderContainerAssignment(
                $map,
                $this->domEventOnceRenderer->render($domEventOnce),
                'events.dom_events_once',
                $domEventOnce
            ));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [MapEvents::JAVASCRIPT_EVENT_DOM_EVENT_ONCE => 'handleMap'];
    }
}



/**
 * @author GeLo <[email protected]>
 */
class DomEventSubscriber extends AbstractSubscriber
{
    /**
     * @var DomEventCollector
     */
    private $domEventCollector;

    /**
     * @var DomEventRenderer
     */
    private $domEventRenderer;

    /**
     * @param Formatter         $formatter
     * @param DomEventCollector $domEventCollector
     * @param DomEventRenderer  $domEventRenderer
     */
    public function __construct(
        Formatter $formatter,
        DomEventCollector $domEventCollector,
        DomEventRenderer $domEventRenderer
    ) {
        parent::__construct($formatter);

        $this->setDomEventCollector($domEventCollector);
        $this->setDomEventRenderer($domEventRenderer);
    }

    /**
     * @return DomEventCollector
     */
    public function getDomEventCollector()
    {
        return $this->domEventCollector;
    }

    /**
     * @param DomEventCollector $domEventCollector
     */
    public function setDomEventCollector(DomEventCollector $domEventCollector)
    {
        $this->domEventCollector = $domEventCollector;
    }

    /**
     * @return DomEventRenderer
     */
    public function getDomEventRenderer()
    {
        return $this->domEventRenderer;
    }

    /**
     * @param DomEventRenderer $domEventRenderer
     */
    public function setDomEventRenderer(DomEventRenderer $domEventRenderer)
    {
        $this->domEventRenderer = $domEventRenderer;
    }

    /**
     * @param MapEvent $event
     */
    public function handleMap(MapEvent $event)
    {
        $formatter = $this->getFormatter();
        $map = $event->getMap();

        foreach ($this->domEventCollector->collect($map) as $domEvent) {
            $event->addCode($formatter->renderContainerAssignment(
                $map,
                $this->domEventRenderer->render($domEvent),
                'events.dom_events',
                $domEvent
            ));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [MapEvents::JAVASCRIPT_EVENT_DOM_EVENT => 'handleMap'];
    }
}



/**
 * @author GeLo <[email protected]>
 */
class EventOnceSubscriber extends AbstractSubscriber
{
    /**
     * @var EventOnceCollector
     */
    private $eventOnceCollector;

    /**
     * @var EventOnceRenderer
     */
    private $eventOnceRenderer;

    /**
     * @param Formatter          $formatter
     * @param EventOnceCollector $eventOnceCollector
     * @param EventOnceRenderer  $eventOnceRenderer
     */
    public function __construct(
        Formatter $formatter,
        EventOnceCollector $eventOnceCollector,
        EventOnceRenderer $eventOnceRenderer
    ) {
        parent::__construct($formatter);

        $this->setEventOnceCollector($eventOnceCollector);
        $this->setEventOnceRenderer($eventOnceRenderer);
    }

    /**
     * @return EventOnceCollector
     */
    public function getEventOnceCollector()
    {
        return $this->eventOnceCollector;
    }

    /**
     * @param EventOnceCollector $eventOnceCollector
     */
    public function setEventOnceCollector(EventOnceCollector $eventOnceCollector)
    {
        $this->eventOnceCollector = $eventOnceCollector;
    }

    /**
     * @return EventOnceRenderer
     */
    public function getEventOnceRenderer()
    {
        return $this->eventOnceRenderer;
    }

    /**
     * @param EventOnceRenderer $eventOnceRenderer
     */
    public function setEventOnceRenderer(EventOnceRenderer $eventOnceRenderer)
    {
        $this->eventOnceRenderer = $eventOnceRenderer;
    }

    /**
     * @param MapEvent $event
     */
    public function handleMap(MapEvent $event)
    {
        $formatter = $this->getFormatter();
        $map = $event->getMap();

        foreach ($this->eventOnceCollector->collect($map) as $eventOnce) {
            $event->addCode($formatter->renderContainerAssignment(
                $map,
                $this->eventOnceRenderer->render($eventOnce),
                'events.events_once',
                $eventOnce
            ));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [MapEvents::JAVASCRIPT_EVENT_EVENT_ONCE => 'handleMap'];
    }
}



/**
 * @author GeLo <[email protected]>
 */
class SimpleEventSubscriber extends AbstractSubscriber
{
    /**
     * @var EventCollector
     */
    private $eventCollector;

    /**
     * @var EventRenderer
     */
    private $eventRenderer;

    /**
     * @param Formatter      $formatter
     * @param EventCollector $eventCollector
     * @param EventRenderer  $eventRenderer
     */
    public function __construct(
        Formatter $formatter,
        EventCollector $eventCollector,
        EventRenderer $eventRenderer
    ) {
        parent::__construct($formatter);

        $this->setEventCollector($eventCollector);
        $this->setEventRenderer($eventRenderer);
    }

    /**
     * @return EventCollector
     */
    public function getEventCollector()
    {
        return $this->eventCollector;
    }

    /**
     * @param EventCollector $eventCollector
     */
    public function setEventCollector(EventCollector $eventCollector)
    {
        $this->eventCollector = $eventCollector;
    }

    /**
     * @return EventRenderer
     */
    public function getEventRenderer()
    {
        return $this->eventRenderer;
    }

    /**
     * @param EventRenderer $eventRenderer
     */
    public function setEventRenderer(EventRenderer $eventRenderer)
    {
        $this->eventRenderer = $eventRenderer;
    }

    /**
     * @param MapEvent $event
     */
    public function handleMap(MapEvent $event)
    {
        $formatter = $this->getFormatter();
        $map = $event->getMap();

        foreach ($this->eventCollector->collect($map) as $rawEvent) {
            $event->addCode($formatter->renderContainerAssignment(
                $map,
                $this->eventRenderer->render($rawEvent),
                'events.events',
                $rawEvent
            ));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [MapEvents::JAVASCRIPT_EVENT_EVENT => 'handleMap'];
    }
}



/**
 * @author GeLo <[email protected]>
 */
class KmlLayerSubscriber extends AbstractSubscriber
{
    /**
     * @var KmlLayerCollector
     */
    private $kmlLayerCollector;

    /**
     * @var KmlLayerRenderer
     */
    private $kmlLayerRenderer;

    /**
     * @param Formatter         $formatter
     * @param KmlLayerCollector $kmlLayerCollector
     * @param KmlLayerRenderer  $kmlLayerRenderer
     */
    public function __construct(
        Formatter $formatter,
        KmlLayerCollector $kmlLayerCollector,
        KmlLayerRenderer $kmlLayerRenderer
    ) {
        parent::__construct($formatter);

        $this->setKmlLayerCollector($kmlLayerCollector);
        $this->setKmlLayerRenderer($kmlLayerRenderer);
    }

    /**
     * @return KmlLayerCollector
     */
    public function getKmlLayerCollector()
    {
        return $this->kmlLayerCollector;
    }

    /**
     * @param KmlLayerCollector $kmlLayerCollector
     */
    public function setKmlLayerCollector(KmlLayerCollector $kmlLayerCollector)
    {
        $this->kmlLayerCollector = $kmlLayerCollector;
    }

    /**
     * @return KmlLayerRenderer
     */
    public function getKmlLayerRenderer()
    {
        return $this->kmlLayerRenderer;
    }

    /**
     * @param KmlLayerRenderer $kmlLayerRenderer
     */
    public function setKmlLayerRenderer(KmlLayerRenderer $kmlLayerRenderer)
    {
        $this->kmlLayerRenderer = $kmlLayerRenderer;
    }

    /**
     * @param MapEvent $event
     */
    public function handleMap(MapEvent $event)
    {
        $formatter = $this->getFormatter();
        $map = $event->getMap();

        foreach ($this->kmlLayerCollector->collect($map) as $kmlLayer) {
            $event->addCode($formatter->renderContainerAssignment(
                $map,
                $this->kmlLayerRenderer->render($kmlLayer, $map),
                'layers.kml_layers',
                $kmlLayer
            ));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [MapEvents::JAVASCRIPT_LAYER_KML_LAYER => 'handleMap'];
    }
}



/**
 * @author GeLo <[email protected]>
 */
class CircleSubscriber extends AbstractSubscriber
{
    /**
     * @var CircleCollector
     */
    private $circleCollector;

    /**
     * @var CircleRenderer
     */
    private $circleRenderer;

    /**
     * @param Formatter       $formatter
     * @param CircleCollector $circleCollector
     * @param CircleRenderer  $circleRenderer
     */
    public function __construct(
        Formatter $formatter,
        CircleCollector $circleCollector,
        CircleRenderer $circleRenderer
    ) {
        parent::__construct($formatter);

        $this->setCircleCollector($circleCollector);
        $this->setCircleRenderer($circleRenderer);
    }

    /**
     * @return CircleCollector
     */
    public function getCircleCollector()
    {
        return $this->circleCollector;
    }

    /**
     * @param CircleCollector $circleCollector
     */
    public function setCircleCollector(CircleCollector $circleCollector)
    {
        $this->circleCollector = $circleCollector;
    }

    /**
     * @return CircleRenderer
     */
    public function getCircleRenderer()
    {
        return $this->circleRenderer;
    }

    /**
     * @param CircleRenderer $circleRenderer
     */
    public function setCircleRenderer(CircleRenderer $circleRenderer)
    {
        $this->circleRenderer = $circleRenderer;
    }

    /**
     * @param MapEvent $event
     */
    public function handleMap(MapEvent $event)
    {
        $formatter = $this->getFormatter();
        $map = $event->getMap();

        foreach ($this->circleCollector->collect($map) as $circle) {
            $event->addCode($formatter->renderContainerAssignment(
                $map,
                $this->circleRenderer->render($circle, $map),
                'overlays.circles',
                $circle
            ));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [MapEvents::JAVASCRIPT_OVERLAY_CIRCLE => 'handleMap'];
    }
}



/**
 * @author GeLo <[email protected]>
 */
class ExtendableSubscriber extends AbstractSubscriber
{
    /**
     * @var ExtendableCollector
     */
    private $extendableCollector;

    /**
     * @var ExtendableRenderer
     */
    private $extendableRenderer;

    /**
     * @param Formatter           $formatter
     * @param ExtendableCollector $extendableCollector
     * @param ExtendableRenderer  $extendableRenderer
     */
    public function __construct(
        Formatter $formatter,
        ExtendableCollector $extendableCollector,
        ExtendableRenderer $extendableRenderer
    ) {
        parent::__construct($formatter);

        $this->setExtendableCollector($extendableCollector);
        $this->setExtendableRenderer($extendableRenderer);
    }

    /**
     * @return ExtendableCollector
     */
    public function getExtendableCollector()
    {
        return $this->extendableCollector;
    }

    /**
     * @param ExtendableCollector $extendableCollector
     */
    public function setExtendableCollector(ExtendableCollector $extendableCollector)
    {
        $this->extendableCollector = $extendableCollector;
    }

    /**
     * @return ExtendableRenderer
     */
    public function getExtendableRenderer()
    {
        return $this->extendableRenderer;
    }

    /**
     * @param ExtendableRenderer $extendableRenderer
     */
    public function setExtendableRenderer(ExtendableRenderer $extendableRenderer)
    {
        $this->extendableRenderer = $extendableRenderer;
    }

    /**
     * @param MapEvent $event
     */
    public function handleMap(MapEvent $event)
    {
        $formatter = $this->getFormatter();
        $map = $event->getMap();

        foreach ($this->extendableCollector->collect($map) as $extendable) {
            $event->addCode($formatter->renderCode($this->extendableRenderer->render($extendable, $map->getBound())));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [MapEvents::JAVASCRIPT_FINISH => 'handleMap'];
    }
}



/**
 * @author GeLo <[email protected]>
 */
class GroundOverlaySubscriber extends AbstractSubscriber
{
    /**
     * @var GroundOverlayCollector
     */
    private $groundOverlayCollector;

    /**
     * @var GroundOverlayRenderer
     */
    private $groundOverlayRenderer;

    /**
     * @param Formatter              $formatter
     * @param GroundOverlayCollector $groundOverlayCollector
     * @param GroundOverlayRenderer  $groundOverlayRenderer
     */
    public function __construct(
        Formatter $formatter,
        GroundOverlayCollector $groundOverlayCollector,
        GroundOverlayRenderer $groundOverlayRenderer
    ) {
        parent::__construct($formatter);

        $this->setGroundOverlayCollector($groundOverlayCollector);
        $this->setGroundOverlayRenderer($groundOverlayRenderer);
    }

    /**
     * @return GroundOverlayCollector
     */
    public function getGroundOverlayCollector()
    {
        return $this->groundOverlayCollector;
    }

    /**
     * @param GroundOverlayCollector $groundOverlayCollector
     */
    public function setGroundOverlayCollector(GroundOverlayCollector $groundOverlayCollector)
    {
        $this->groundOverlayCollector = $groundOverlayCollector;
    }

    /**
     * @return GroundOverlayRenderer
     */
    public function getGroundOverlayRenderer()
    {
        return $this->groundOverlayRenderer;
    }

    /**
     * @param GroundOverlayRenderer $groundOverlayRenderer
     */
    public function setGroundOverlayRenderer(GroundOverlayRenderer $groundOverlayRenderer)
    {
        $this->groundOverlayRenderer = $groundOverlayRenderer;
    }

    /**
     * @param MapEvent $event
     */
    public function handleMap(MapEvent $event)
    {
        $formatter = $this->getFormatter();
        $map = $event->getMap();

        foreach ($this->groundOverlayCollector->collect($map) as $groundOverlay) {
            $event->addCode($formatter->renderContainerAssignment(
                $map,
                $this->groundOverlayRenderer->render($groundOverlay, $map),
                'overlays.ground_overlays',
                $groundOverlay
            ));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [MapEvents::JAVASCRIPT_OVERLAY_GROUND_OVERLAY => 'handleMap'];
    }
}



/**
 * @author GeLo <[email protected]>
 */
class PolygonSubscriber extends AbstractSubscriber
{
    /**
     * @var PolygonCollector
     */
    private $polygonCollector;

    /**
     * @var PolygonRenderer
     */
    private $polygonRenderer;

    /**
     * @param Formatter        $formatter
     * @param PolygonCollector $polygonCollector
     * @param PolygonRenderer  $polygonRenderer
     */
    public function __construct(
        Formatter $formatter,
        PolygonCollector $polygonCollector,
        PolygonRenderer $polygonRenderer
    ) {
        parent::__construct($formatter);

        $this->setPolygonCollector($polygonCollector);
        $this->setPolygonRenderer($polygonRenderer);
    }

    /**
     * @return PolygonCollector
     */
    public function getPolygonCollector()
    {
        return $this->polygonCollector;
    }

    /**
     * @param PolygonCollector $polygonCollector
     */
    public function setPolygonCollector(PolygonCollector $polygonCollector)
    {
        $this->polygonCollector = $polygonCollector;
    }

    /**
     * @return PolygonRenderer
     */
    public function getPolygonRenderer()
    {
        return $this->polygonRenderer;
    }

    /**
     * @param PolygonRenderer $polygonRenderer
     */
    public function setPolygonRenderer(PolygonRenderer $polygonRenderer)
    {
        $this->polygonRenderer = $polygonRenderer;
    }

    /**
     * @param MapEvent $event
     */
    public function handleMap(MapEvent $event)
    {
        $formatter = $this->getFormatter();
        $map = $event->getMap();

        foreach ($this->polygonCollector->collect($map) as $polygon) {
            $event->addCode($formatter->renderContainerAssignment(
                $map,
                $this->polygonRenderer->render($polygon, $map),
                'overlays.polygons',
                $polygon
            ));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [MapEvents::JAVASCRIPT_OVERLAY_POLYGON => 'handleMap'];
    }
}



/**
 * @author GeLo <[email protected]>
 */
class PolylineSubscriber extends AbstractSubscriber
{
    /**
     * @var PolylineCollector
     */
    private $polylineCollector;

    /**
     * @var PolylineRenderer
     */
    private $polylineRenderer;

    /**
     * @param Formatter         $formatter
     * @param PolylineCollector $polylineCollector
     * @param PolylineRenderer  $polylineRenderer
     */
    public function __construct(
        Formatter $formatter,
        PolylineCollector $polylineCollector,
        PolylineRenderer $polylineRenderer
    ) {
        parent::__construct($formatter);

        $this->setPolylineCollector($polylineCollector);
        $this->setPolylineRenderer($polylineRenderer);
    }

    /**
     * @return PolylineCollector
     */
    public function getPolylineCollector()
    {
        return $this->polylineCollector;
    }

    /**
     * @param PolylineCollector $polylineCollector
     */
    public function setPolylineCollector(PolylineCollector $polylineCollector)
    {
        $this->polylineCollector = $polylineCollector;
    }

    /**
     * @return PolylineRenderer
     */
    public function getPolylineRenderer()
    {
        return $this->polylineRenderer;
    }

    /**
     * @param PolylineRenderer $polylineRenderer
     */
    public function setPolylineRenderer(PolylineRenderer $polylineRenderer)
    {
        $this->polylineRenderer = $polylineRenderer;
    }

    /**
     * @param MapEvent $event
     */
    public function handleMap(MapEvent $event)
    {
        $formatter = $this->getFormatter();
        $map = $event->getMap();

        foreach ($this->polylineCollector->collect($map) as $polyline) {
            $event->addCode($formatter->renderContainerAssignment(
                $map,
                $this->polylineRenderer->render($polyline, $map),
                'overlays.polylines',
                $polyline
            ));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [MapEvents::JAVASCRIPT_OVERLAY_POLYLINE => 'handleMap'];
    }
}



/**
 * @author GeLo <[email protected]>
 */
class RectangleSubscriber extends AbstractSubscriber
{
    /**
     * @var RectangleCollector
     */
    private $rectangleCollector;

    /**
     * @var RectangleRenderer
     */
    private $rectangleRenderer;

    /**
     * @param Formatter          $formatter
     * @param RectangleCollector $rectangleCollector
     * @param RectangleRenderer  $rectangleRenderer
     */
    public function __construct(
        Formatter $formatter,
        RectangleCollector $rectangleCollector,
        RectangleRenderer $rectangleRenderer
    ) {
        parent::__construct($formatter);

        $this->setRectangleCollector($rectangleCollector);
        $this->setRectangleRenderer($rectangleRenderer);
    }

    /**
     * @return RectangleCollector
     */
    public function getRectangleCollector()
    {
        return $this->rectangleCollector;
    }

    /**
     * @param RectangleCollector $rectangleCollector
     */
    public function setRectangleCollector(RectangleCollector $rectangleCollector)
    {
        $this->rectangleCollector = $rectangleCollector;
    }

    /**
     * @return RectangleRenderer
     */
    public function getRectangleRenderer()
    {
        return $this->rectangleRenderer;
    }

    /**
     * @param RectangleRenderer $rectangleRenderer
     */
    public function setRectangleRenderer(RectangleRenderer $rectangleRenderer)
    {
        $this->rectangleRenderer = $rectangleRenderer;
    }

    /**
     * @param MapEvent $event
     */
    public function handleMap(MapEvent $event)
    {
        $formatter = $this->getFormatter();
        $map = $event->getMap();

        foreach ($this->rectangleCollector->collect($map) as $rectangle) {
            $event->addCode($formatter->renderContainerAssignment(
                $map,
                $this->rectangleRenderer->render($rectangle, $map),
                'overlays.rectangles',
                $rectangle
            ));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [MapEvents::JAVASCRIPT_OVERLAY_RECTANGLE => 'handleMap'];
    }
}



/**
 * @author GeLo <[email protected]>
 */
class AutocompleteBoundSubscriber extends AbstractSubscriber
{
    /**
     * @var AutocompleteBoundCollector
     */
    private $boundCollector;

    /**
     * @var BoundRenderer
     */
    private $boundRenderer;

    /**
     * @param Formatter                  $formatter
     * @param AutocompleteBoundCollector $boundCollector
     * @param BoundRenderer              $boundRenderer
     */
    public function __construct(
        Formatter $formatter,
        AutocompleteBoundCollector $boundCollector,
        BoundRenderer $boundRenderer
    ) {
        parent::__construct($formatter);

        $this->setBoundCollector($boundCollector);
        $this->setBoundRenderer($boundRenderer);
    }

    /**
     * @return AutocompleteBoundCollector
     */
    public function getBoundCollector()
    {
        return $this->boundCollector;
    }

    /**
     * @param AutocompleteBoundCollector $boundCollector
     */
    public function setBoundCollector(AutocompleteBoundCollector $boundCollector)
    {
        $this->boundCollector = $boundCollector;
    }

    /**
     * @return BoundRenderer
     */
    public function getBoundRenderer()
    {
        return $this->boundRenderer;
    }

    /**
     * @param BoundRenderer $boundRenderer
     */
    public function setBoundRenderer(BoundRenderer $boundRenderer)
    {
        $this->boundRenderer = $boundRenderer;
    }

    /**
     * @param PlaceAutocompleteEvent $event
     */
    public function handleAutocomplete(PlaceAutocompleteEvent $event)
    {
        $formatter = $this->getFormatter();
        $autocomplete = $event->getAutocomplete();

        foreach ($this->boundCollector->collect($autocomplete) as $bound) {
            $event->addCode($formatter->renderContainerAssignment(
                $autocomplete,
                $this->boundRenderer->render($bound),
                'base.bounds',
                $bound
            ));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [PlaceAutocompleteEvents::JAVASCRIPT_BASE_BOUND => 'handleAutocomplete'];
    }
}



/**
 * @author GeLo <[email protected]>
 */
class AutocompleteCoordinateSubscriber extends AbstractSubscriber
{
    /**
     * @var AutocompleteCoordinateCollector
     */
    private $coordinateCollector;

    /**
     * @var CoordinateRenderer
     */
    private $coordinateRenderer;

    /**
     * @param Formatter                       $formatter
     * @param AutocompleteCoordinateCollector $coordinateCollector
     * @param CoordinateRenderer              $coordinateRenderer
     */
    public function __construct(
        Formatter $formatter,
        AutocompleteCoordinateCollector $coordinateCollector,
        CoordinateRenderer $coordinateRenderer
    ) {
        parent::__construct($formatter);

        $this->setCoordinateCollector($coordinateCollector);
        $this->setCoordinateRenderer($coordinateRenderer);
    }

    /**
     * @return AutocompleteCoordinateCollector
     */
    public function getCoordinateCollector()
    {
        return $this->coordinateCollector;
    }

    /**
     * @param AutocompleteCoordinateCollector $coordinateCollector
     */
    public function setCoordinateCollector(AutocompleteCoordinateCollector $coordinateCollector)
    {
        $this->coordinateCollector = $coordinateCollector;
    }

    /**
     * @return CoordinateRenderer
     */
    public function getCoordinateRenderer()
    {
        return $this->coordinateRenderer;
    }

    /**
     * @param CoordinateRenderer $coordinateRenderer
     */
    public function setCoordinateRenderer(CoordinateRenderer $coordinateRenderer)
    {
        $this->coordinateRenderer = $coordinateRenderer;
    }

    /**
     * @param PlaceAutocompleteEvent $event
     */
    public function handleAutocomplete(PlaceAutocompleteEvent $event)
    {
        $formatter = $this->getFormatter();
        $autocomplete = $event->getAutocomplete();

        foreach ($this->coordinateCollector->collect($autocomplete) as $coordinate) {
            $event->addCode($formatter->renderContainerAssignment(
                $autocomplete,
                $this->coordinateRenderer->render($coordinate),
                'base.coordinates',
                $coordinate
            ));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [PlaceAutocompleteEvents::JAVASCRIPT_BASE_COORDINATE => 'handleAutocomplete'];
    }
}



/**
 * @author GeLo <[email protected]>
 */
class AutocompleteDomEventOnceSubscriber extends AbstractSubscriber
{
    /**
     * @var AutocompleteDomEventOnceCollector
     */
    private $domEventOnceCollector;

    /**
     * @var DomEventOnceRenderer
     */
    private $domEventOnceRenderer;

    /**
     * @param Formatter                         $formatter
     * @param AutocompleteDomEventOnceCollector $domEventOnceCollector
     * @param DomEventOnceRenderer              $domEventOnceRenderer
     */
    public function __construct(
        Formatter $formatter,
        AutocompleteDomEventOnceCollector $domEventOnceCollector,
        DomEventOnceRenderer $domEventOnceRenderer
    ) {
        parent::__construct($formatter);

        $this->setDomEventOnceCollector($domEventOnceCollector);
        $this->setDomEventOnceRenderer($domEventOnceRenderer);
    }

    /**
     * @return AutocompleteDomEventOnceCollector
     */
    public function getDomEventOnceCollector()
    {
        return $this->domEventOnceCollector;
    }

    /**
     * @param AutocompleteDomEventOnceCollector $domEventOnceCollector
     */
    public function setDomEventOnceCollector(AutocompleteDomEventOnceCollector $domEventOnceCollector)
    {
        $this->domEventOnceCollector = $domEventOnceCollector;
    }

    /**
     * @return DomEventOnceRenderer
     */
    public function getDomEventOnceRenderer()
    {
        return $this->domEventOnceRenderer;
    }

    /**
     * @param DomEventOnceRenderer $domEventOnceRenderer
     */
    public function setDomEventOnceRenderer(DomEventOnceRenderer $domEventOnceRenderer)
    {
        $this->domEventOnceRenderer = $domEventOnceRenderer;
    }

    /**
     * @param PlaceAutocompleteEvent $event
     */
    public function handleAutocomplete(PlaceAutocompleteEvent $event)
    {
        $formatter = $this->getFormatter();
        $autocomplete = $event->getAutocomplete();

        foreach ($this->domEventOnceCollector->collect($autocomplete) as $domEventOnce) {
            $event->addCode($formatter->renderContainerAssignment(
                $autocomplete,
                $this->domEventOnceRenderer->render($domEventOnce),
                'events.dom_events_once',
                $domEventOnce
            ));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [PlaceAutocompleteEvents::JAVASCRIPT_EVENT_DOM_EVENT_ONCE => 'handleAutocomplete'];
    }
}



/**
 * @author GeLo <[email protected]>
 */
class AutocompleteDomEventSubscriber extends AbstractSubscriber
{
    /**
     * @var AutocompleteDomEventCollector
     */
    private $domEventCollector;

    /**
     * @var DomEventRenderer
     */
    private $domEventRenderer;

    /**
     * @param Formatter                     $formatter
     * @param AutocompleteDomEventCollector $domEventCollector
     * @param DomEventRenderer              $domEventRenderer
     */
    public function __construct(
        Formatter $formatter,
        AutocompleteDomEventCollector $domEventCollector,
        DomEventRenderer $domEventRenderer
    ) {
        parent::__construct($formatter);

        $this->setDomEventCollector($domEventCollector);
        $this->setDomEventRenderer($domEventRenderer);
    }

    /**
     * @return AutocompleteDomEventCollector
     */
    public function getDomEventCollector()
    {
        return $this->domEventCollector;
    }

    /**
     * @param AutocompleteDomEventCollector $domEventCollector
     */
    public function setDomEventCollector(AutocompleteDomEventCollector $domEventCollector)
    {
        $this->domEventCollector = $domEventCollector;
    }

    /**
     * @return DomEventRenderer
     */
    public function getDomEventRenderer()
    {
        return $this->domEventRenderer;
    }

    /**
     * @param DomEventRenderer $domEventRenderer
     */
    public function setDomEventRenderer(DomEventRenderer $domEventRenderer)
    {
        $this->domEventRenderer = $domEventRenderer;
    }

    /**
     * @param PlaceAutocompleteEvent $event
     */
    public function handleAutocomplete(PlaceAutocompleteEvent $event)
    {
        $formatter = $this->getFormatter();
        $autocomplete = $event->getAutocomplete();

        foreach ($this->domEventCollector->collect($autocomplete) as $domEvent) {
            $event->addCode($formatter->renderContainerAssignment(
                $autocomplete,
                $this->domEventRenderer->render($domEvent),
                'events.dom_events',
                $domEvent
            ));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [PlaceAutocompleteEvents::JAVASCRIPT_EVENT_DOM_EVENT => 'handleAutocomplete'];
    }
}



/**
 * @author GeLo <[email protected]>
 */
class AutocompleteEventOnceSubscriber extends AbstractSubscriber
{
    /**
     * @var AutocompleteEventOnceCollector
     */
    private $eventOnceCollector;

    /**
     * @var EventOnceRenderer
     */
    private $eventOnceRenderer;

    /**
     * @param Formatter                      $formatter
     * @param AutocompleteEventOnceCollector $eventOnceCollector
     * @param EventOnceRenderer              $eventOnceRenderer
     */
    public function __construct(
        Formatter $formatter,
        AutocompleteEventOnceCollector $eventOnceCollector,
        EventOnceRenderer $eventOnceRenderer
    ) {
        parent::__construct($formatter);

        $this->setEventOnceCollector($eventOnceCollector);
        $this->setEventOnceRenderer($eventOnceRenderer);
    }

    /**
     * @return AutocompleteEventOnceCollector
     */
    public function getEventOnceCollector()
    {
        return $this->eventOnceCollector;
    }

    /**
     * @param AutocompleteEventOnceCollector $eventOnceCollector
     */
    public function setEventOnceCollector(AutocompleteEventOnceCollector $eventOnceCollector)
    {
        $this->eventOnceCollector = $eventOnceCollector;
    }

    /**
     * @return EventOnceRenderer
     */
    public function getEventOnceRenderer()
    {
        return $this->eventOnceRenderer;
    }

    /**
     * @param EventOnceRenderer $eventOnceRenderer
     */
    public function setEventOnceRenderer(EventOnceRenderer $eventOnceRenderer)
    {
        $this->eventOnceRenderer = $eventOnceRenderer;
    }

    /**
     * @param PlaceAutocompleteEvent $event
     */
    public function handleAutocomplete(PlaceAutocompleteEvent $event)
    {
        $formatter = $this->getFormatter();
        $autocomplete = $event->getAutocomplete();

        foreach ($this->eventOnceCollector->collect($autocomplete) as $eventOnce) {
            $event->addCode($formatter->renderContainerAssignment(
                $autocomplete,
                $this->eventOnceRenderer->render($eventOnce),
                'events.events_once',
                $eventOnce
            ));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [PlaceAutocompleteEvents::JAVASCRIPT_EVENT_EVENT_ONCE => 'handleAutocomplete'];
    }
}



/**
 * @author GeLo <[email protected]>
 */
class AutocompleteSimpleEventSubscriber extends AbstractSubscriber
{
    /**
     * @var AutocompleteEventCollector
     */
    private $eventCollector;

    /**
     * @var EventRenderer
     */
    private $eventRenderer;

    /**
     * @param Formatter                  $formatter
     * @param AutocompleteEventCollector $eventCollector
     * @param EventRenderer              $eventRenderer
     */
    public function __construct(
        Formatter $formatter,
        AutocompleteEventCollector $eventCollector,
        EventRenderer $eventRenderer
    ) {
        parent::__construct($formatter);

        $this->setEventCollector($eventCollector);
        $this->setEventRenderer($eventRenderer);
    }

    /**
     * @return AutocompleteEventCollector
     */
    public function getEventCollector()
    {
        return $this->eventCollector;
    }

    /**
     * @param AutocompleteEventCollector $eventCollector
     */
    public function setEventCollector(AutocompleteEventCollector $eventCollector)
    {
        $this->eventCollector = $eventCollector;
    }

    /**
     * @return EventRenderer
     */
    public function getEventRenderer()
    {
        return $this->eventRenderer;
    }

    /**
     * @param EventRenderer $eventRenderer
     */
    public function setEventRenderer(EventRenderer $eventRenderer)
    {
        $this->eventRenderer = $eventRenderer;
    }

    /**
     * @param PlaceAutocompleteEvent $event
     */
    public function handleAutocomplete(PlaceAutocompleteEvent $event)
    {
        $formatter = $this->getFormatter();
        $autocomplete = $event->getAutocomplete();

        foreach ($this->eventCollector->collect($autocomplete) as $rawEvent) {
            $event->addCode($formatter->renderContainerAssignment(
                $autocomplete,
                $this->eventRenderer->render($rawEvent),
                'events.events',
                $rawEvent
            ));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [PlaceAutocompleteEvents::JAVASCRIPT_EVENT_EVENT => 'handleAutocomplete'];
    }
}



/**
 * @author GeLo <[email protected]>
 */
class GeoJsonLayerSubscriber extends AbstractSubscriber
{
    /**
     * @var GeoJsonLayerCollector
     */
    private $geoJsonLayerCollector;

    /**
     * @var GeoJsonLayerRenderer
     */
    private $geoJsonLayerRenderer;

    /**
     * @param Formatter             $formatter
     * @param GeoJsonLayerCollector $geoJsonLayerCollector
     * @param GeoJsonLayerRenderer  $geoJsonLayerRenderer
     */
    public function __construct(
        Formatter $formatter,
        GeoJsonLayerCollector $geoJsonLayerCollector,
        GeoJsonLayerRenderer $geoJsonLayerRenderer
    ) {
        parent::__construct($formatter);

        $this->setGeoJsonLayerCollector($geoJsonLayerCollector);
        $this->setGeoJsonLayerRenderer($geoJsonLayerRenderer);
    }

    /**
     * @return GeoJsonLayerCollector
     */
    public function getGeoJsonLayerCollector()
    {
        return $this->geoJsonLayerCollector;
    }

    /**
     * @param GeoJsonLayerCollector $geoJsonLayerCollector
     */
    public function setGeoJsonLayerCollector(GeoJsonLayerCollector $geoJsonLayerCollector)
    {
        $this->geoJsonLayerCollector = $geoJsonLayerCollector;
    }

    /**
     * @return GeoJsonLayerRenderer
     */
    public function getGeoJsonLayerRenderer()
    {
        return $this->geoJsonLayerRenderer;
    }

    /**
     * @param GeoJsonLayerRenderer $geoJsonLayerRenderer
     */
    public function setGeoJsonLayerRenderer(GeoJsonLayerRenderer $geoJsonLayerRenderer)
    {
        $this->geoJsonLayerRenderer = $geoJsonLayerRenderer;
    }

    /**
     * @param MapEvent $event
     */
    public function handleMap(MapEvent $event)
    {
        $formatter = $this->getFormatter();
        $map = $event->getMap();

        foreach ($this->geoJsonLayerCollector->collect($map) as $geoJsonLayer) {
            $event->addCode($formatter->renderContainerAssignment(
                $map,
                $this->geoJsonLayerRenderer->render($geoJsonLayer, $map),
                'layers.geo_json_layers',
                $geoJsonLayer
            ));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [MapEvents::JAVASCRIPT_LAYER_GEO_JSON_LAYER => 'handleMap'];
    }
}


		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class BoundSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var BoundCollector
28		*/
29		private $boundCollector;
30
31		/**
32		* @var BoundRenderer
33		*/
34		private $boundRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param BoundCollector $boundCollector
39		* @param BoundRenderer $boundRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		BoundCollector $boundCollector,
44		BoundRenderer $boundRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setBoundCollector($boundCollector);
49		$this->setBoundRenderer($boundRenderer);
50		}
51
52		/**
53		* @return BoundCollector
54		*/
55		public function getBoundCollector()
56		{
57		return $this->boundCollector;
58		}
59
60		/**
61		* @param BoundCollector $boundCollector
62		*/
63		public function setBoundCollector(BoundCollector $boundCollector)
64		{
65		$this->boundCollector = $boundCollector;
66		}
67
68		/**
69		* @return BoundRenderer
70		*/
71		public function getBoundRenderer()
72		{
73		return $this->boundRenderer;
74		}
75
76		/**
77		* @param BoundRenderer $boundRenderer
78		*/
79		public function setBoundRenderer(BoundRenderer $boundRenderer)
80		{
81		$this->boundRenderer = $boundRenderer;
82		}
83
84		/**
85		* @param MapEvent $event
86		*/
87		public function handleMap(MapEvent $event)
88		{
89		$formatter = $this->getFormatter();
90		$map = $event->getMap();
91
92		foreach ($this->boundCollector->collect($map) as $bound) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$map,
95		$this->boundRenderer->render($bound),
96		'base.bounds',
97		$bound
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [MapEvents::JAVASCRIPT_BASE_BOUND => 'handleMap'];
108		}
109		}
110

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class CoordinateSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var CoordinateCollector
28		*/
29		private $coordinateCollector;
30
31		/**
32		* @var CoordinateRenderer
33		*/
34		private $coordinateRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param CoordinateCollector $coordinateCollector
39		* @param CoordinateRenderer $coordinateRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		CoordinateCollector $coordinateCollector,
44		CoordinateRenderer $coordinateRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setCoordinateCollector($coordinateCollector);
49		$this->setCoordinateRenderer($coordinateRenderer);
50		}
51
52		/**
53		* @return CoordinateCollector
54		*/
55		public function getCoordinateCollector()
56		{
57		return $this->coordinateCollector;
58		}
59
60		/**
61		* @param CoordinateCollector $coordinateCollector
62		*/
63		public function setCoordinateCollector(CoordinateCollector $coordinateCollector)
64		{
65		$this->coordinateCollector = $coordinateCollector;
66		}
67
68		/**
69		* @return CoordinateRenderer
70		*/
71		public function getCoordinateRenderer()
72		{
73		return $this->coordinateRenderer;
74		}
75
76		/**
77		* @param CoordinateRenderer $coordinateRenderer
78		*/
79		public function setCoordinateRenderer(CoordinateRenderer $coordinateRenderer)
80		{
81		$this->coordinateRenderer = $coordinateRenderer;
82		}
83
84		/**
85		* @param MapEvent $event
86		*/
87		public function handleMap(MapEvent $event)
88		{
89		$formatter = $this->getFormatter();
90		$map = $event->getMap();
91
92		foreach ($this->coordinateCollector->collect($map) as $coordinate) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$map,
95		$this->coordinateRenderer->render($coordinate),
96		'base.coordinates',
97		$coordinate
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [MapEvents::JAVASCRIPT_BASE_COORDINATE => 'handleMap'];
108		}
109		}
110

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class PointSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var PointCollector
28		*/
29		private $pointCollector;
30
31		/**
32		* @var PointRenderer
33		*/
34		private $pointRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param PointCollector $pointCollector
39		* @param PointRenderer $pointRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		PointCollector $pointCollector,
44		PointRenderer $pointRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setPointCollector($pointCollector);
49		$this->setPointRenderer($pointRenderer);
50		}
51
52		/**
53		* @return PointCollector
54		*/
55		public function getPointCollector()
56		{
57		return $this->pointCollector;
58		}
59
60		/**
61		* @param PointCollector $pointCollector
62		*/
63		public function setPointCollector(PointCollector $pointCollector)
64		{
65		$this->pointCollector = $pointCollector;
66		}
67
68		/**
69		* @return PointRenderer
70		*/
71		public function getPointRenderer()
72		{
73		return $this->pointRenderer;
74		}
75
76		/**
77		* @param PointRenderer $pointRenderer
78		*/
79		public function setPointRenderer(PointRenderer $pointRenderer)
80		{
81		$this->pointRenderer = $pointRenderer;
82		}
83
84		/***
85		* @param MapEvent $event
86		*/
87		public function handleMap(MapEvent $event)
88		{
89		$formatter = $this->getFormatter();
90		$map = $event->getMap();
91
92		foreach ($this->pointCollector->collect($map) as $point) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$map,
95		$this->pointRenderer->render($point),
96		'base.points',
97		$point
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [MapEvents::JAVASCRIPT_BASE_POINT => 'handleMap'];
108		}
109		}
110

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class SizeSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var SizeCollector
28		*/
29		private $sizeCollector;
30
31		/**
32		* @var SizeRenderer
33		*/
34		private $sizeRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param SizeCollector $sizeCollector
39		* @param SizeRenderer $sizeRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		SizeCollector $sizeCollector,
44		SizeRenderer $sizeRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setSizeCollector($sizeCollector);
49		$this->setSizeRenderer($sizeRenderer);
50		}
51
52		/**
53		* @return SizeCollector
54		*/
55		public function getSizeCollector()
56		{
57		return $this->sizeCollector;
58		}
59
60		/**
61		* @param SizeCollector $sizeCollector
62		*/
63		public function setSizeCollector(SizeCollector $sizeCollector)
64		{
65		$this->sizeCollector = $sizeCollector;
66		}
67
68		/**
69		* @return SizeRenderer
70		*/
71		public function getSizeRenderer()
72		{
73		return $this->sizeRenderer;
74		}
75
76		/**
77		* @param SizeRenderer $sizeRenderer
78		*/
79		public function setSizeRenderer(SizeRenderer $sizeRenderer)
80		{
81		$this->sizeRenderer = $sizeRenderer;
82		}
83
84		/**
85		* @param MapEvent $event
86		*/
87		public function handleMap(MapEvent $event)
88		{
89		$formatter = $this->getFormatter();
90		$map = $event->getMap();
91
92		foreach ($this->sizeCollector->collect($map) as $size) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$map,
95		$this->sizeRenderer->render($size),
96		'base.sizes',
97		$size
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [MapEvents::JAVASCRIPT_BASE_SIZE => 'handleMap'];
108		}
109		}
110

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class DomEventOnceSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var DomEventOnceCollector
28		*/
29		private $domEventOnceCollector;
30
31		/**
32		* @var DomEventOnceRenderer
33		*/
34		private $domEventOnceRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param DomEventOnceCollector $domEventOnceCollector
39		* @param DomEventOnceRenderer $domEventOnceRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		DomEventOnceCollector $domEventOnceCollector,
44		DomEventOnceRenderer $domEventOnceRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setDomEventOnceCollector($domEventOnceCollector);
49		$this->setDomEventOnceRenderer($domEventOnceRenderer);
50		}
51
52		/**
53		* @return DomEventOnceCollector
54		*/
55		public function getDomEventOnceCollector()
56		{
57		return $this->domEventOnceCollector;
58		}
59
60		/**
61		* @param DomEventOnceCollector $domEventOnceCollector
62		*/
63		public function setDomEventOnceCollector(DomEventOnceCollector $domEventOnceCollector)
64		{
65		$this->domEventOnceCollector = $domEventOnceCollector;
66		}
67
68		/**
69		* @return DomEventOnceRenderer
70		*/
71		public function getDomEventOnceRenderer()
72		{
73		return $this->domEventOnceRenderer;
74		}
75
76		/**
77		* @param DomEventOnceRenderer $domEventOnceRenderer
78		*/
79		public function setDomEventOnceRenderer(DomEventOnceRenderer $domEventOnceRenderer)
80		{
81		$this->domEventOnceRenderer = $domEventOnceRenderer;
82		}
83
84		/**
85		* @param MapEvent $event
86		*/
87		public function handleMap(MapEvent $event)
88		{
89		$formatter = $this->getFormatter();
90		$map = $event->getMap();
91
92		foreach ($this->domEventOnceCollector->collect($map) as $domEventOnce) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$map,
95		$this->domEventOnceRenderer->render($domEventOnce),
96		'events.dom_events_once',
97		$domEventOnce
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [MapEvents::JAVASCRIPT_EVENT_DOM_EVENT_ONCE => 'handleMap'];
108		}
109		}
110

GitHub Access Token became invalid

Code Duplication Length = 81-86 lines in 22 locations

src/Helper/Subscriber/Base/BoundSubscriber.php 1 location

src/Helper/Subscriber/Base/CoordinateSubscriber.php 1 location

src/Helper/Subscriber/Base/PointSubscriber.php 1 location

src/Helper/Subscriber/Base/SizeSubscriber.php 1 location

src/Helper/Subscriber/Event/DomEventOnceSubscriber.php 1 location

src/Helper/Subscriber/Event/DomEventSubscriber.php 1 location

src/Helper/Subscriber/Event/EventOnceSubscriber.php 1 location

src/Helper/Subscriber/Event/SimpleEventSubscriber.php 1 location

src/Helper/Subscriber/Layer/KmlLayerSubscriber.php 1 location

src/Helper/Subscriber/Overlay/CircleSubscriber.php 1 location

src/Helper/Subscriber/Overlay/ExtendableSubscriber.php 1 location

src/Helper/Subscriber/Overlay/GroundOverlaySubscriber.php 1 location

src/Helper/Subscriber/Overlay/PolygonSubscriber.php 1 location

src/Helper/Subscriber/Overlay/PolylineSubscriber.php 1 location

src/Helper/Subscriber/Overlay/RectangleSubscriber.php 1 location

src/Helper/Subscriber/Place/Base/AutocompleteBoundSubscriber.php 1 location

src/Helper/Subscriber/Place/Base/AutocompleteCoordinateSubscriber.php 1 location

src/Helper/Subscriber/Place/Event/AutocompleteDomEventOnceSubscriber.php 1 location

src/Helper/Subscriber/Place/Event/AutocompleteDomEventSubscriber.php 1 location

src/Helper/Subscriber/Place/Event/AutocompleteEventOnceSubscriber.php 1 location

src/Helper/Subscriber/Place/Event/AutocompleteSimpleEventSubscriber.php 1 location

src/Helper/Subscriber/Layer/GeoJsonLayerSubscriber.php 1 location

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class DomEventSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var DomEventCollector
28		*/
29		private $domEventCollector;
30
31		/**
32		* @var DomEventRenderer
33		*/
34		private $domEventRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param DomEventCollector $domEventCollector
39		* @param DomEventRenderer $domEventRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		DomEventCollector $domEventCollector,
44		DomEventRenderer $domEventRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setDomEventCollector($domEventCollector);
49		$this->setDomEventRenderer($domEventRenderer);
50		}
51
52		/**
53		* @return DomEventCollector
54		*/
55		public function getDomEventCollector()
56		{
57		return $this->domEventCollector;
58		}
59
60		/**
61		* @param DomEventCollector $domEventCollector
62		*/
63		public function setDomEventCollector(DomEventCollector $domEventCollector)
64		{
65		$this->domEventCollector = $domEventCollector;
66		}
67
68		/**
69		* @return DomEventRenderer
70		*/
71		public function getDomEventRenderer()
72		{
73		return $this->domEventRenderer;
74		}
75
76		/**
77		* @param DomEventRenderer $domEventRenderer
78		*/
79		public function setDomEventRenderer(DomEventRenderer $domEventRenderer)
80		{
81		$this->domEventRenderer = $domEventRenderer;
82		}
83
84		/**
85		* @param MapEvent $event
86		*/
87		public function handleMap(MapEvent $event)
88		{
89		$formatter = $this->getFormatter();
90		$map = $event->getMap();
91
92		foreach ($this->domEventCollector->collect($map) as $domEvent) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$map,
95		$this->domEventRenderer->render($domEvent),
96		'events.dom_events',
97		$domEvent
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [MapEvents::JAVASCRIPT_EVENT_DOM_EVENT => 'handleMap'];
108		}
109		}
110

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class EventOnceSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var EventOnceCollector
28		*/
29		private $eventOnceCollector;
30
31		/**
32		* @var EventOnceRenderer
33		*/
34		private $eventOnceRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param EventOnceCollector $eventOnceCollector
39		* @param EventOnceRenderer $eventOnceRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		EventOnceCollector $eventOnceCollector,
44		EventOnceRenderer $eventOnceRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setEventOnceCollector($eventOnceCollector);
49		$this->setEventOnceRenderer($eventOnceRenderer);
50		}
51
52		/**
53		* @return EventOnceCollector
54		*/
55		public function getEventOnceCollector()
56		{
57		return $this->eventOnceCollector;
58		}
59
60		/**
61		* @param EventOnceCollector $eventOnceCollector
62		*/
63		public function setEventOnceCollector(EventOnceCollector $eventOnceCollector)
64		{
65		$this->eventOnceCollector = $eventOnceCollector;
66		}
67
68		/**
69		* @return EventOnceRenderer
70		*/
71		public function getEventOnceRenderer()
72		{
73		return $this->eventOnceRenderer;
74		}
75
76		/**
77		* @param EventOnceRenderer $eventOnceRenderer
78		*/
79		public function setEventOnceRenderer(EventOnceRenderer $eventOnceRenderer)
80		{
81		$this->eventOnceRenderer = $eventOnceRenderer;
82		}
83
84		/**
85		* @param MapEvent $event
86		*/
87		public function handleMap(MapEvent $event)
88		{
89		$formatter = $this->getFormatter();
90		$map = $event->getMap();
91
92		foreach ($this->eventOnceCollector->collect($map) as $eventOnce) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$map,
95		$this->eventOnceRenderer->render($eventOnce),
96		'events.events_once',
97		$eventOnce
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [MapEvents::JAVASCRIPT_EVENT_EVENT_ONCE => 'handleMap'];
108		}
109		}
110

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class SimpleEventSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var EventCollector
28		*/
29		private $eventCollector;
30
31		/**
32		* @var EventRenderer
33		*/
34		private $eventRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param EventCollector $eventCollector
39		* @param EventRenderer $eventRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		EventCollector $eventCollector,
44		EventRenderer $eventRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setEventCollector($eventCollector);
49		$this->setEventRenderer($eventRenderer);
50		}
51
52		/**
53		* @return EventCollector
54		*/
55		public function getEventCollector()
56		{
57		return $this->eventCollector;
58		}
59
60		/**
61		* @param EventCollector $eventCollector
62		*/
63		public function setEventCollector(EventCollector $eventCollector)
64		{
65		$this->eventCollector = $eventCollector;
66		}
67
68		/**
69		* @return EventRenderer
70		*/
71		public function getEventRenderer()
72		{
73		return $this->eventRenderer;
74		}
75
76		/**
77		* @param EventRenderer $eventRenderer
78		*/
79		public function setEventRenderer(EventRenderer $eventRenderer)
80		{
81		$this->eventRenderer = $eventRenderer;
82		}
83
84		/**
85		* @param MapEvent $event
86		*/
87		public function handleMap(MapEvent $event)
88		{
89		$formatter = $this->getFormatter();
90		$map = $event->getMap();
91
92		foreach ($this->eventCollector->collect($map) as $rawEvent) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$map,
95		$this->eventRenderer->render($rawEvent),
96		'events.events',
97		$rawEvent
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [MapEvents::JAVASCRIPT_EVENT_EVENT => 'handleMap'];
108		}
109		}
110

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class KmlLayerSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var KmlLayerCollector
28		*/
29		private $kmlLayerCollector;
30
31		/**
32		* @var KmlLayerRenderer
33		*/
34		private $kmlLayerRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param KmlLayerCollector $kmlLayerCollector
39		* @param KmlLayerRenderer $kmlLayerRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		KmlLayerCollector $kmlLayerCollector,
44		KmlLayerRenderer $kmlLayerRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setKmlLayerCollector($kmlLayerCollector);
49		$this->setKmlLayerRenderer($kmlLayerRenderer);
50		}
51
52		/**
53		* @return KmlLayerCollector
54		*/
55		public function getKmlLayerCollector()
56		{
57		return $this->kmlLayerCollector;
58		}
59
60		/**
61		* @param KmlLayerCollector $kmlLayerCollector
62		*/
63		public function setKmlLayerCollector(KmlLayerCollector $kmlLayerCollector)
64		{
65		$this->kmlLayerCollector = $kmlLayerCollector;
66		}
67
68		/**
69		* @return KmlLayerRenderer
70		*/
71		public function getKmlLayerRenderer()
72		{
73		return $this->kmlLayerRenderer;
74		}
75
76		/**
77		* @param KmlLayerRenderer $kmlLayerRenderer
78		*/
79		public function setKmlLayerRenderer(KmlLayerRenderer $kmlLayerRenderer)
80		{
81		$this->kmlLayerRenderer = $kmlLayerRenderer;
82		}
83
84		/**
85		* @param MapEvent $event
86		*/
87		public function handleMap(MapEvent $event)
88		{
89		$formatter = $this->getFormatter();
90		$map = $event->getMap();
91
92		foreach ($this->kmlLayerCollector->collect($map) as $kmlLayer) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$map,
95		$this->kmlLayerRenderer->render($kmlLayer, $map),
96		'layers.kml_layers',
97		$kmlLayer
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [MapEvents::JAVASCRIPT_LAYER_KML_LAYER => 'handleMap'];
108		}
109		}
110

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class CircleSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var CircleCollector
28		*/
29		private $circleCollector;
30
31		/**
32		* @var CircleRenderer
33		*/
34		private $circleRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param CircleCollector $circleCollector
39		* @param CircleRenderer $circleRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		CircleCollector $circleCollector,
44		CircleRenderer $circleRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setCircleCollector($circleCollector);
49		$this->setCircleRenderer($circleRenderer);
50		}
51
52		/**
53		* @return CircleCollector
54		*/
55		public function getCircleCollector()
56		{
57		return $this->circleCollector;
58		}
59
60		/**
61		* @param CircleCollector $circleCollector
62		*/
63		public function setCircleCollector(CircleCollector $circleCollector)
64		{
65		$this->circleCollector = $circleCollector;
66		}
67
68		/**
69		* @return CircleRenderer
70		*/
71		public function getCircleRenderer()
72		{
73		return $this->circleRenderer;
74		}
75
76		/**
77		* @param CircleRenderer $circleRenderer
78		*/
79		public function setCircleRenderer(CircleRenderer $circleRenderer)
80		{
81		$this->circleRenderer = $circleRenderer;
82		}
83
84		/**
85		* @param MapEvent $event
86		*/
87		public function handleMap(MapEvent $event)
88		{
89		$formatter = $this->getFormatter();
90		$map = $event->getMap();
91
92		foreach ($this->circleCollector->collect($map) as $circle) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$map,
95		$this->circleRenderer->render($circle, $map),
96		'overlays.circles',
97		$circle
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [MapEvents::JAVASCRIPT_OVERLAY_CIRCLE => 'handleMap'];
108		}
109		}
110

		@@ 24-104 (lines=81) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class ExtendableSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var ExtendableCollector
28		*/
29		private $extendableCollector;
30
31		/**
32		* @var ExtendableRenderer
33		*/
34		private $extendableRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param ExtendableCollector $extendableCollector
39		* @param ExtendableRenderer $extendableRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		ExtendableCollector $extendableCollector,
44		ExtendableRenderer $extendableRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setExtendableCollector($extendableCollector);
49		$this->setExtendableRenderer($extendableRenderer);
50		}
51
52		/**
53		* @return ExtendableCollector
54		*/
55		public function getExtendableCollector()
56		{
57		return $this->extendableCollector;
58		}
59
60		/**
61		* @param ExtendableCollector $extendableCollector
62		*/
63		public function setExtendableCollector(ExtendableCollector $extendableCollector)
64		{
65		$this->extendableCollector = $extendableCollector;
66		}
67
68		/**
69		* @return ExtendableRenderer
70		*/
71		public function getExtendableRenderer()
72		{
73		return $this->extendableRenderer;
74		}
75
76		/**
77		* @param ExtendableRenderer $extendableRenderer
78		*/
79		public function setExtendableRenderer(ExtendableRenderer $extendableRenderer)
80		{
81		$this->extendableRenderer = $extendableRenderer;
82		}
83
84		/**
85		* @param MapEvent $event
86		*/
87		public function handleMap(MapEvent $event)
88		{
89		$formatter = $this->getFormatter();
90		$map = $event->getMap();
91
92		foreach ($this->extendableCollector->collect($map) as $extendable) {
93		$event->addCode($formatter->renderCode($this->extendableRenderer->render($extendable, $map->getBound())));
94		}
95		}
96
97		/**
98		* {@inheritdoc}
99		*/
100		public static function getSubscribedEvents()
101		{
102		return [MapEvents::JAVASCRIPT_FINISH => 'handleMap'];
103		}
104		}
105

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class GroundOverlaySubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var GroundOverlayCollector
28		*/
29		private $groundOverlayCollector;
30
31		/**
32		* @var GroundOverlayRenderer
33		*/
34		private $groundOverlayRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param GroundOverlayCollector $groundOverlayCollector
39		* @param GroundOverlayRenderer $groundOverlayRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		GroundOverlayCollector $groundOverlayCollector,
44		GroundOverlayRenderer $groundOverlayRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setGroundOverlayCollector($groundOverlayCollector);
49		$this->setGroundOverlayRenderer($groundOverlayRenderer);
50		}
51
52		/**
53		* @return GroundOverlayCollector
54		*/
55		public function getGroundOverlayCollector()
56		{
57		return $this->groundOverlayCollector;
58		}
59
60		/**
61		* @param GroundOverlayCollector $groundOverlayCollector
62		*/
63		public function setGroundOverlayCollector(GroundOverlayCollector $groundOverlayCollector)
64		{
65		$this->groundOverlayCollector = $groundOverlayCollector;
66		}
67
68		/**
69		* @return GroundOverlayRenderer
70		*/
71		public function getGroundOverlayRenderer()
72		{
73		return $this->groundOverlayRenderer;
74		}
75
76		/**
77		* @param GroundOverlayRenderer $groundOverlayRenderer
78		*/
79		public function setGroundOverlayRenderer(GroundOverlayRenderer $groundOverlayRenderer)
80		{
81		$this->groundOverlayRenderer = $groundOverlayRenderer;
82		}
83
84		/**
85		* @param MapEvent $event
86		*/
87		public function handleMap(MapEvent $event)
88		{
89		$formatter = $this->getFormatter();
90		$map = $event->getMap();
91
92		foreach ($this->groundOverlayCollector->collect($map) as $groundOverlay) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$map,
95		$this->groundOverlayRenderer->render($groundOverlay, $map),
96		'overlays.ground_overlays',
97		$groundOverlay
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [MapEvents::JAVASCRIPT_OVERLAY_GROUND_OVERLAY => 'handleMap'];
108		}
109		}
110

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class PolygonSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var PolygonCollector
28		*/
29		private $polygonCollector;
30
31		/**
32		* @var PolygonRenderer
33		*/
34		private $polygonRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param PolygonCollector $polygonCollector
39		* @param PolygonRenderer $polygonRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		PolygonCollector $polygonCollector,
44		PolygonRenderer $polygonRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setPolygonCollector($polygonCollector);
49		$this->setPolygonRenderer($polygonRenderer);
50		}
51
52		/**
53		* @return PolygonCollector
54		*/
55		public function getPolygonCollector()
56		{
57		return $this->polygonCollector;
58		}
59
60		/**
61		* @param PolygonCollector $polygonCollector
62		*/
63		public function setPolygonCollector(PolygonCollector $polygonCollector)
64		{
65		$this->polygonCollector = $polygonCollector;
66		}
67
68		/**
69		* @return PolygonRenderer
70		*/
71		public function getPolygonRenderer()
72		{
73		return $this->polygonRenderer;
74		}
75
76		/**
77		* @param PolygonRenderer $polygonRenderer
78		*/
79		public function setPolygonRenderer(PolygonRenderer $polygonRenderer)
80		{
81		$this->polygonRenderer = $polygonRenderer;
82		}
83
84		/**
85		* @param MapEvent $event
86		*/
87		public function handleMap(MapEvent $event)
88		{
89		$formatter = $this->getFormatter();
90		$map = $event->getMap();
91
92		foreach ($this->polygonCollector->collect($map) as $polygon) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$map,
95		$this->polygonRenderer->render($polygon, $map),
96		'overlays.polygons',
97		$polygon
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [MapEvents::JAVASCRIPT_OVERLAY_POLYGON => 'handleMap'];
108		}
109		}
110

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class PolylineSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var PolylineCollector
28		*/
29		private $polylineCollector;
30
31		/**
32		* @var PolylineRenderer
33		*/
34		private $polylineRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param PolylineCollector $polylineCollector
39		* @param PolylineRenderer $polylineRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		PolylineCollector $polylineCollector,
44		PolylineRenderer $polylineRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setPolylineCollector($polylineCollector);
49		$this->setPolylineRenderer($polylineRenderer);
50		}
51
52		/**
53		* @return PolylineCollector
54		*/
55		public function getPolylineCollector()
56		{
57		return $this->polylineCollector;
58		}
59
60		/**
61		* @param PolylineCollector $polylineCollector
62		*/
63		public function setPolylineCollector(PolylineCollector $polylineCollector)
64		{
65		$this->polylineCollector = $polylineCollector;
66		}
67
68		/**
69		* @return PolylineRenderer
70		*/
71		public function getPolylineRenderer()
72		{
73		return $this->polylineRenderer;
74		}
75
76		/**
77		* @param PolylineRenderer $polylineRenderer
78		*/
79		public function setPolylineRenderer(PolylineRenderer $polylineRenderer)
80		{
81		$this->polylineRenderer = $polylineRenderer;
82		}
83
84		/**
85		* @param MapEvent $event
86		*/
87		public function handleMap(MapEvent $event)
88		{
89		$formatter = $this->getFormatter();
90		$map = $event->getMap();
91
92		foreach ($this->polylineCollector->collect($map) as $polyline) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$map,
95		$this->polylineRenderer->render($polyline, $map),
96		'overlays.polylines',
97		$polyline
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [MapEvents::JAVASCRIPT_OVERLAY_POLYLINE => 'handleMap'];
108		}
109		}
110

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class RectangleSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var RectangleCollector
28		*/
29		private $rectangleCollector;
30
31		/**
32		* @var RectangleRenderer
33		*/
34		private $rectangleRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param RectangleCollector $rectangleCollector
39		* @param RectangleRenderer $rectangleRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		RectangleCollector $rectangleCollector,
44		RectangleRenderer $rectangleRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setRectangleCollector($rectangleCollector);
49		$this->setRectangleRenderer($rectangleRenderer);
50		}
51
52		/**
53		* @return RectangleCollector
54		*/
55		public function getRectangleCollector()
56		{
57		return $this->rectangleCollector;
58		}
59
60		/**
61		* @param RectangleCollector $rectangleCollector
62		*/
63		public function setRectangleCollector(RectangleCollector $rectangleCollector)
64		{
65		$this->rectangleCollector = $rectangleCollector;
66		}
67
68		/**
69		* @return RectangleRenderer
70		*/
71		public function getRectangleRenderer()
72		{
73		return $this->rectangleRenderer;
74		}
75
76		/**
77		* @param RectangleRenderer $rectangleRenderer
78		*/
79		public function setRectangleRenderer(RectangleRenderer $rectangleRenderer)
80		{
81		$this->rectangleRenderer = $rectangleRenderer;
82		}
83
84		/**
85		* @param MapEvent $event
86		*/
87		public function handleMap(MapEvent $event)
88		{
89		$formatter = $this->getFormatter();
90		$map = $event->getMap();
91
92		foreach ($this->rectangleCollector->collect($map) as $rectangle) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$map,
95		$this->rectangleRenderer->render($rectangle, $map),
96		'overlays.rectangles',
97		$rectangle
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [MapEvents::JAVASCRIPT_OVERLAY_RECTANGLE => 'handleMap'];
108		}
109		}
110

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class AutocompleteBoundSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var AutocompleteBoundCollector
28		*/
29		private $boundCollector;
30
31		/**
32		* @var BoundRenderer
33		*/
34		private $boundRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param AutocompleteBoundCollector $boundCollector
39		* @param BoundRenderer $boundRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		AutocompleteBoundCollector $boundCollector,
44		BoundRenderer $boundRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setBoundCollector($boundCollector);
49		$this->setBoundRenderer($boundRenderer);
50		}
51
52		/**
53		* @return AutocompleteBoundCollector
54		*/
55		public function getBoundCollector()
56		{
57		return $this->boundCollector;
58		}
59
60		/**
61		* @param AutocompleteBoundCollector $boundCollector
62		*/
63		public function setBoundCollector(AutocompleteBoundCollector $boundCollector)
64		{
65		$this->boundCollector = $boundCollector;
66		}
67
68		/**
69		* @return BoundRenderer
70		*/
71		public function getBoundRenderer()
72		{
73		return $this->boundRenderer;
74		}
75
76		/**
77		* @param BoundRenderer $boundRenderer
78		*/
79		public function setBoundRenderer(BoundRenderer $boundRenderer)
80		{
81		$this->boundRenderer = $boundRenderer;
82		}
83
84		/**
85		* @param PlaceAutocompleteEvent $event
86		*/
87		public function handleAutocomplete(PlaceAutocompleteEvent $event)
88		{
89		$formatter = $this->getFormatter();
90		$autocomplete = $event->getAutocomplete();
91
92		foreach ($this->boundCollector->collect($autocomplete) as $bound) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$autocomplete,
95		$this->boundRenderer->render($bound),
96		'base.bounds',
97		$bound
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [PlaceAutocompleteEvents::JAVASCRIPT_BASE_BOUND => 'handleAutocomplete'];
108		}
109		}
110

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class AutocompleteCoordinateSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var AutocompleteCoordinateCollector
28		*/
29		private $coordinateCollector;
30
31		/**
32		* @var CoordinateRenderer
33		*/
34		private $coordinateRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param AutocompleteCoordinateCollector $coordinateCollector
39		* @param CoordinateRenderer $coordinateRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		AutocompleteCoordinateCollector $coordinateCollector,
44		CoordinateRenderer $coordinateRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setCoordinateCollector($coordinateCollector);
49		$this->setCoordinateRenderer($coordinateRenderer);
50		}
51
52		/**
53		* @return AutocompleteCoordinateCollector
54		*/
55		public function getCoordinateCollector()
56		{
57		return $this->coordinateCollector;
58		}
59
60		/**
61		* @param AutocompleteCoordinateCollector $coordinateCollector
62		*/
63		public function setCoordinateCollector(AutocompleteCoordinateCollector $coordinateCollector)
64		{
65		$this->coordinateCollector = $coordinateCollector;
66		}
67
68		/**
69		* @return CoordinateRenderer
70		*/
71		public function getCoordinateRenderer()
72		{
73		return $this->coordinateRenderer;
74		}
75
76		/**
77		* @param CoordinateRenderer $coordinateRenderer
78		*/
79		public function setCoordinateRenderer(CoordinateRenderer $coordinateRenderer)
80		{
81		$this->coordinateRenderer = $coordinateRenderer;
82		}
83
84		/**
85		* @param PlaceAutocompleteEvent $event
86		*/
87		public function handleAutocomplete(PlaceAutocompleteEvent $event)
88		{
89		$formatter = $this->getFormatter();
90		$autocomplete = $event->getAutocomplete();
91
92		foreach ($this->coordinateCollector->collect($autocomplete) as $coordinate) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$autocomplete,
95		$this->coordinateRenderer->render($coordinate),
96		'base.coordinates',
97		$coordinate
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [PlaceAutocompleteEvents::JAVASCRIPT_BASE_COORDINATE => 'handleAutocomplete'];
108		}
109		}
110

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class AutocompleteDomEventOnceSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var AutocompleteDomEventOnceCollector
28		*/
29		private $domEventOnceCollector;
30
31		/**
32		* @var DomEventOnceRenderer
33		*/
34		private $domEventOnceRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param AutocompleteDomEventOnceCollector $domEventOnceCollector
39		* @param DomEventOnceRenderer $domEventOnceRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		AutocompleteDomEventOnceCollector $domEventOnceCollector,
44		DomEventOnceRenderer $domEventOnceRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setDomEventOnceCollector($domEventOnceCollector);
49		$this->setDomEventOnceRenderer($domEventOnceRenderer);
50		}
51
52		/**
53		* @return AutocompleteDomEventOnceCollector
54		*/
55		public function getDomEventOnceCollector()
56		{
57		return $this->domEventOnceCollector;
58		}
59
60		/**
61		* @param AutocompleteDomEventOnceCollector $domEventOnceCollector
62		*/
63		public function setDomEventOnceCollector(AutocompleteDomEventOnceCollector $domEventOnceCollector)
64		{
65		$this->domEventOnceCollector = $domEventOnceCollector;
66		}
67
68		/**
69		* @return DomEventOnceRenderer
70		*/
71		public function getDomEventOnceRenderer()
72		{
73		return $this->domEventOnceRenderer;
74		}
75
76		/**
77		* @param DomEventOnceRenderer $domEventOnceRenderer
78		*/
79		public function setDomEventOnceRenderer(DomEventOnceRenderer $domEventOnceRenderer)
80		{
81		$this->domEventOnceRenderer = $domEventOnceRenderer;
82		}
83
84		/**
85		* @param PlaceAutocompleteEvent $event
86		*/
87		public function handleAutocomplete(PlaceAutocompleteEvent $event)
88		{
89		$formatter = $this->getFormatter();
90		$autocomplete = $event->getAutocomplete();
91
92		foreach ($this->domEventOnceCollector->collect($autocomplete) as $domEventOnce) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$autocomplete,
95		$this->domEventOnceRenderer->render($domEventOnce),
96		'events.dom_events_once',
97		$domEventOnce
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [PlaceAutocompleteEvents::JAVASCRIPT_EVENT_DOM_EVENT_ONCE => 'handleAutocomplete'];
108		}
109		}
110

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class AutocompleteDomEventSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var AutocompleteDomEventCollector
28		*/
29		private $domEventCollector;
30
31		/**
32		* @var DomEventRenderer
33		*/
34		private $domEventRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param AutocompleteDomEventCollector $domEventCollector
39		* @param DomEventRenderer $domEventRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		AutocompleteDomEventCollector $domEventCollector,
44		DomEventRenderer $domEventRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setDomEventCollector($domEventCollector);
49		$this->setDomEventRenderer($domEventRenderer);
50		}
51
52		/**
53		* @return AutocompleteDomEventCollector
54		*/
55		public function getDomEventCollector()
56		{
57		return $this->domEventCollector;
58		}
59
60		/**
61		* @param AutocompleteDomEventCollector $domEventCollector
62		*/
63		public function setDomEventCollector(AutocompleteDomEventCollector $domEventCollector)
64		{
65		$this->domEventCollector = $domEventCollector;
66		}
67
68		/**
69		* @return DomEventRenderer
70		*/
71		public function getDomEventRenderer()
72		{
73		return $this->domEventRenderer;
74		}
75
76		/**
77		* @param DomEventRenderer $domEventRenderer
78		*/
79		public function setDomEventRenderer(DomEventRenderer $domEventRenderer)
80		{
81		$this->domEventRenderer = $domEventRenderer;
82		}
83
84		/**
85		* @param PlaceAutocompleteEvent $event
86		*/
87		public function handleAutocomplete(PlaceAutocompleteEvent $event)
88		{
89		$formatter = $this->getFormatter();
90		$autocomplete = $event->getAutocomplete();
91
92		foreach ($this->domEventCollector->collect($autocomplete) as $domEvent) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$autocomplete,
95		$this->domEventRenderer->render($domEvent),
96		'events.dom_events',
97		$domEvent
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [PlaceAutocompleteEvents::JAVASCRIPT_EVENT_DOM_EVENT => 'handleAutocomplete'];
108		}
109		}
110

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class AutocompleteEventOnceSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var AutocompleteEventOnceCollector
28		*/
29		private $eventOnceCollector;
30
31		/**
32		* @var EventOnceRenderer
33		*/
34		private $eventOnceRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param AutocompleteEventOnceCollector $eventOnceCollector
39		* @param EventOnceRenderer $eventOnceRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		AutocompleteEventOnceCollector $eventOnceCollector,
44		EventOnceRenderer $eventOnceRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setEventOnceCollector($eventOnceCollector);
49		$this->setEventOnceRenderer($eventOnceRenderer);
50		}
51
52		/**
53		* @return AutocompleteEventOnceCollector
54		*/
55		public function getEventOnceCollector()
56		{
57		return $this->eventOnceCollector;
58		}
59
60		/**
61		* @param AutocompleteEventOnceCollector $eventOnceCollector
62		*/
63		public function setEventOnceCollector(AutocompleteEventOnceCollector $eventOnceCollector)
64		{
65		$this->eventOnceCollector = $eventOnceCollector;
66		}
67
68		/**
69		* @return EventOnceRenderer
70		*/
71		public function getEventOnceRenderer()
72		{
73		return $this->eventOnceRenderer;
74		}
75
76		/**
77		* @param EventOnceRenderer $eventOnceRenderer
78		*/
79		public function setEventOnceRenderer(EventOnceRenderer $eventOnceRenderer)
80		{
81		$this->eventOnceRenderer = $eventOnceRenderer;
82		}
83
84		/**
85		* @param PlaceAutocompleteEvent $event
86		*/
87		public function handleAutocomplete(PlaceAutocompleteEvent $event)
88		{
89		$formatter = $this->getFormatter();
90		$autocomplete = $event->getAutocomplete();
91
92		foreach ($this->eventOnceCollector->collect($autocomplete) as $eventOnce) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$autocomplete,
95		$this->eventOnceRenderer->render($eventOnce),
96		'events.events_once',
97		$eventOnce
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [PlaceAutocompleteEvents::JAVASCRIPT_EVENT_EVENT_ONCE => 'handleAutocomplete'];
108		}
109		}
110

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class AutocompleteSimpleEventSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var AutocompleteEventCollector
28		*/
29		private $eventCollector;
30
31		/**
32		* @var EventRenderer
33		*/
34		private $eventRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param AutocompleteEventCollector $eventCollector
39		* @param EventRenderer $eventRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		AutocompleteEventCollector $eventCollector,
44		EventRenderer $eventRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setEventCollector($eventCollector);
49		$this->setEventRenderer($eventRenderer);
50		}
51
52		/**
53		* @return AutocompleteEventCollector
54		*/
55		public function getEventCollector()
56		{
57		return $this->eventCollector;
58		}
59
60		/**
61		* @param AutocompleteEventCollector $eventCollector
62		*/
63		public function setEventCollector(AutocompleteEventCollector $eventCollector)
64		{
65		$this->eventCollector = $eventCollector;
66		}
67
68		/**
69		* @return EventRenderer
70		*/
71		public function getEventRenderer()
72		{
73		return $this->eventRenderer;
74		}
75
76		/**
77		* @param EventRenderer $eventRenderer
78		*/
79		public function setEventRenderer(EventRenderer $eventRenderer)
80		{
81		$this->eventRenderer = $eventRenderer;
82		}
83
84		/**
85		* @param PlaceAutocompleteEvent $event
86		*/
87		public function handleAutocomplete(PlaceAutocompleteEvent $event)
88		{
89		$formatter = $this->getFormatter();
90		$autocomplete = $event->getAutocomplete();
91
92		foreach ($this->eventCollector->collect($autocomplete) as $rawEvent) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$autocomplete,
95		$this->eventRenderer->render($rawEvent),
96		'events.events',
97		$rawEvent
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [PlaceAutocompleteEvents::JAVASCRIPT_EVENT_EVENT => 'handleAutocomplete'];
108		}
109		}
110

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class GeoJsonLayerSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var GeoJsonLayerCollector
28		*/
29		private $geoJsonLayerCollector;
30
31		/**
32		* @var GeoJsonLayerRenderer
33		*/
34		private $geoJsonLayerRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param GeoJsonLayerCollector $geoJsonLayerCollector
39		* @param GeoJsonLayerRenderer $geoJsonLayerRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		GeoJsonLayerCollector $geoJsonLayerCollector,
44		GeoJsonLayerRenderer $geoJsonLayerRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setGeoJsonLayerCollector($geoJsonLayerCollector);
49		$this->setGeoJsonLayerRenderer($geoJsonLayerRenderer);
50		}
51
52		/**
53		* @return GeoJsonLayerCollector
54		*/
55		public function getGeoJsonLayerCollector()
56		{
57		return $this->geoJsonLayerCollector;
58		}
59
60		/**
61		* @param GeoJsonLayerCollector $geoJsonLayerCollector
62		*/
63		public function setGeoJsonLayerCollector(GeoJsonLayerCollector $geoJsonLayerCollector)
64		{
65		$this->geoJsonLayerCollector = $geoJsonLayerCollector;
66		}
67
68		/**
69		* @return GeoJsonLayerRenderer
70		*/
71		public function getGeoJsonLayerRenderer()
72		{
73		return $this->geoJsonLayerRenderer;
74		}
75
76		/**
77		* @param GeoJsonLayerRenderer $geoJsonLayerRenderer
78		*/
79		public function setGeoJsonLayerRenderer(GeoJsonLayerRenderer $geoJsonLayerRenderer)
80		{
81		$this->geoJsonLayerRenderer = $geoJsonLayerRenderer;
82		}
83
84		/**
85		* @param MapEvent $event
86		*/
87		public function handleMap(MapEvent $event)
88		{
89		$formatter = $this->getFormatter();
90		$map = $event->getMap();
91
92		foreach ($this->geoJsonLayerCollector->collect($map) as $geoJsonLayer) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$map,
95		$this->geoJsonLayerRenderer->render($geoJsonLayer, $map),
96		'layers.geo_json_layers',
97		$geoJsonLayer
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [MapEvents::JAVASCRIPT_LAYER_GEO_JSON_LAYER => 'handleMap'];
108		}
109		}
110

egeloen / ivory-google-map

GitHub Access Token became invalid

Code Duplication Length = 81-86 lines in 22 locations

src/Helper/Subscriber/Base/BoundSubscriber.php 1 location

src/Helper/Subscriber/Base/CoordinateSubscriber.php 1 location

src/Helper/Subscriber/Base/PointSubscriber.php 1 location

src/Helper/Subscriber/Base/SizeSubscriber.php 1 location

src/Helper/Subscriber/Event/DomEventOnceSubscriber.php 1 location

src/Helper/Subscriber/Event/DomEventSubscriber.php 1 location

src/Helper/Subscriber/Event/EventOnceSubscriber.php 1 location

src/Helper/Subscriber/Event/SimpleEventSubscriber.php 1 location

src/Helper/Subscriber/Layer/KmlLayerSubscriber.php 1 location

src/Helper/Subscriber/Overlay/CircleSubscriber.php 1 location

src/Helper/Subscriber/Overlay/ExtendableSubscriber.php 1 location

src/Helper/Subscriber/Overlay/GroundOverlaySubscriber.php 1 location

src/Helper/Subscriber/Overlay/PolygonSubscriber.php 1 location

src/Helper/Subscriber/Overlay/PolylineSubscriber.php 1 location

src/Helper/Subscriber/Overlay/RectangleSubscriber.php 1 location

src/Helper/Subscriber/Place/Base/AutocompleteBoundSubscriber.php 1 location

src/Helper/Subscriber/Place/Base/AutocompleteCoordinateSubscriber.php 1 location

src/Helper/Subscriber/Place/Event/AutocompleteDomEventOnceSubscriber.php 1 location

src/Helper/Subscriber/Place/Event/AutocompleteDomEventSubscriber.php 1 location

src/Helper/Subscriber/Place/Event/AutocompleteEventOnceSubscriber.php 1 location

src/Helper/Subscriber/Place/Event/AutocompleteSimpleEventSubscriber.php 1 location

src/Helper/Subscriber/Layer/GeoJsonLayerSubscriber.php 1 location