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 CustomControlSubscriber extends AbstractSubscriber
{
    /**
     * @var CustomControlCollector
     */
    private $customControlCollector;

    /**
     * @var CustomControlRenderer
     */
    private $customControlRenderer;

    /**
     * @param Formatter              $formatter
     * @param CustomControlCollector $customControlCollector
     * @param CustomControlRenderer  $customControlRenderer
     */
    public function __construct(
        Formatter $formatter,
        CustomControlCollector $customControlCollector,
        CustomControlRenderer $customControlRenderer
    ) {
        parent::__construct($formatter);

        $this->setCustomControlCollector($customControlCollector);
        $this->setCustomControlRenderer($customControlRenderer);
    }

    /**
     * @return CustomControlCollector
     */
    public function getCustomControlCollector()
    {
        return $this->customControlCollector;
    }

    /**
     * @param CustomControlCollector $customControlCollector
     */
    public function setCustomControlCollector(CustomControlCollector $customControlCollector)
    {
        $this->customControlCollector = $customControlCollector;
    }

    /**
     * @return CustomControlRenderer
     */
    public function getCustomControlRenderer()
    {
        return $this->customControlRenderer;
    }

    /**
     * @param CustomControlRenderer $customControlRenderer
     */
    public function setCustomControlRenderer(CustomControlRenderer $customControlRenderer)
    {
        $this->customControlRenderer = $customControlRenderer;
    }

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

        foreach ($this->customControlCollector->collect($map) as $customControl) {
            $event->addCode($formatter->renderCode($this->customControlRenderer->render($customControl, $map)));
        }
    }

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



/**
 * @author GeLo <[email protected]>
 */
class IconSequenceSubscriber extends AbstractSubscriber
{
    /**
     * @var IconSequenceCollector
     */
    private $iconSequenceCollector;

    /**
     * @var IconSequenceRenderer
     */
    private $iconSequenceRenderer;

    /**
     * @param Formatter             $formatter
     * @param IconSequenceCollector $iconSequenceCollector
     * @param IconSequenceRenderer  $iconSequenceRenderer
     */
    public function __construct(
        Formatter $formatter,
        IconSequenceCollector $iconSequenceCollector,
        IconSequenceRenderer $iconSequenceRenderer
    ) {
        parent::__construct($formatter);

        $this->setIconSequenceCollector($iconSequenceCollector);
        $this->setIconSequenceRenderer($iconSequenceRenderer);
    }

    /**
     * @return IconSequenceCollector
     */
    public function getIconSequenceCollector()
    {
        return $this->iconSequenceCollector;
    }

    /**
     * @param IconSequenceCollector $iconSequenceCollector
     */
    public function setIconSequenceCollector(IconSequenceCollector $iconSequenceCollector)
    {
        $this->iconSequenceCollector = $iconSequenceCollector;
    }

    /**
     * @return IconSequenceRenderer
     */
    public function getIconSequenceRenderer()
    {
        return $this->iconSequenceRenderer;
    }

    /**
     * @param IconSequenceRenderer $iconSequenceRenderer
     */
    public function setIconSequenceRenderer(IconSequenceRenderer $iconSequenceRenderer)
    {
        $this->iconSequenceRenderer = $iconSequenceRenderer;
    }

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

        foreach ($this->getIconSequenceCollector()->collect($map) as $iconSequence) {
            $event->addCode($formatter->renderContainerAssignment(
                $map,
                $this->iconSequenceRenderer->render($iconSequence),
                'overlays.icon_sequences',
                $iconSequence
            ));
        }
    }

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



/**
 * @author GeLo <[email protected]>
 */
class IconSubscriber extends AbstractSubscriber
{
    /**
     * @var IconCollector
     */
    private $iconCollector;

    /**
     * @var IconRenderer
     */
    private $iconRenderer;

    /**
     * @param Formatter     $formatter
     * @param IconCollector $iconCollector
     * @param IconRenderer  $iconRenderer
     */
    public function __construct(
        Formatter $formatter,
        IconCollector $iconCollector,
        IconRenderer $iconRenderer
    ) {
        parent::__construct($formatter);

        $this->setIconCollector($iconCollector);
        $this->setIconRenderer($iconRenderer);
    }

    /**
     * @return IconCollector
     */
    public function getIconCollector()
    {
        return $this->iconCollector;
    }

    /**
     * @param IconCollector $iconCollector
     */
    public function setIconCollector(IconCollector $iconCollector)
    {
        $this->iconCollector = $iconCollector;
    }

    /**
     * @return IconRenderer
     */
    public function getIconRenderer()
    {
        return $this->iconRenderer;
    }

    /**
     * @param IconRenderer $iconRenderer
     */
    public function setIconRenderer(IconRenderer $iconRenderer)
    {
        $this->iconRenderer = $iconRenderer;
    }

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

        foreach ($this->getIconCollector()->collect($map) as $icon) {
            $event->addCode($formatter->renderContainerAssignment(
                $map,
                $this->iconRenderer->render($icon),
                'overlays.icons',
                $icon
            ));
        }
    }

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



/**
 * @author GeLo <[email protected]>
 */
class MarkerShapeSubscriber extends AbstractSubscriber
{
    /**
     * @var MarkerShapeCollector
     */
    private $markerShapeCollector;

    /**
     * @var MarkerShapeRenderer
     */
    private $markerShapeRenderer;

    /**
     * @param Formatter            $formatter
     * @param MarkerShapeCollector $markerShapeCollector
     * @param MarkerShapeRenderer  $markerShapeRenderer
     */
    public function __construct(
        Formatter $formatter,
        MarkerShapeCollector $markerShapeCollector,
        MarkerShapeRenderer $markerShapeRenderer
    ) {
        parent::__construct($formatter);

        $this->setMarkerShapeCollector($markerShapeCollector);
        $this->setMarkerShapeRenderer($markerShapeRenderer);
    }

    /**
     * @return MarkerShapeCollector
     */
    public function getMarkerShapeCollector()
    {
        return $this->markerShapeCollector;
    }

    /**
     * @param MarkerShapeCollector $markerShapeCollector
     */
    public function setMarkerShapeCollector(MarkerShapeCollector $markerShapeCollector)
    {
        $this->markerShapeCollector = $markerShapeCollector;
    }

    /**
     * @return MarkerShapeRenderer
     */
    public function getMarkerShapeRenderer()
    {
        return $this->markerShapeRenderer;
    }

    /**
     * @param MarkerShapeRenderer $markerShapeRenderer
     */
    public function setMarkerShapeRenderer(MarkerShapeRenderer $markerShapeRenderer)
    {
        $this->markerShapeRenderer = $markerShapeRenderer;
    }

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

        foreach ($this->getMarkerShapeCollector()->collect($map) as $markerShape) {
            $event->addCode($formatter->renderContainerAssignment(
                $map,
                $this->markerShapeRenderer->render($markerShape),
                'overlays.marker_shapes',
                $markerShape
            ));
        }
    }

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



/**
 * @author GeLo <[email protected]>
 */
class SymbolSubscriber extends AbstractSubscriber
{
    /**
     * @var SymbolCollector
     */
    private $symbolCollector;

    /**
     * @var SymbolRenderer
     */
    private $symbolRenderer;

    /**
     * @param Formatter       $formatter
     * @param SymbolCollector $symbolCollector
     * @param SymbolRenderer  $symbolRenderer
     */
    public function __construct(
        Formatter $formatter,
        SymbolCollector $symbolCollector,
        SymbolRenderer $symbolRenderer
    ) {
        parent::__construct($formatter);

        $this->setSymbolCollector($symbolCollector);
        $this->setSymbolRenderer($symbolRenderer);
    }

    /**
     * @return SymbolCollector
     */
    public function getSymbolCollector()
    {
        return $this->symbolCollector;
    }

    /**
     * @param SymbolCollector $symbolCollector
     */
    public function setSymbolCollector(SymbolCollector $symbolCollector)
    {
        $this->symbolCollector = $symbolCollector;
    }

    /**
     * @return SymbolRenderer
     */
    public function getSymbolRenderer()
    {
        return $this->symbolRenderer;
    }

    /**
     * @param SymbolRenderer $symbolRenderer
     */
    public function setSymbolRenderer(SymbolRenderer $symbolRenderer)
    {
        $this->symbolRenderer = $symbolRenderer;
    }

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

        foreach ($this->getSymbolCollector()->collect($map) as $symbol) {
            $event->addCode($formatter->renderContainerAssignment(
                $map,
                $this->symbolRenderer->render($symbol),
                'overlays.symbols',
                $symbol
            ));
        }
    }

    /**
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [MapEvents::JAVASCRIPT_OVERLAY_SYMBOL => '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 26 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/Control/CustomControlSubscriber.php 1 location

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

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

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

src/Helper/Subscriber/Overlay/SymbolSubscriber.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-104 (lines=81) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class CustomControlSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var CustomControlCollector
28		*/
29		private $customControlCollector;
30
31		/**
32		* @var CustomControlRenderer
33		*/
34		private $customControlRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param CustomControlCollector $customControlCollector
39		* @param CustomControlRenderer $customControlRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		CustomControlCollector $customControlCollector,
44		CustomControlRenderer $customControlRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setCustomControlCollector($customControlCollector);
49		$this->setCustomControlRenderer($customControlRenderer);
50		}
51
52		/**
53		* @return CustomControlCollector
54		*/
55		public function getCustomControlCollector()
56		{
57		return $this->customControlCollector;
58		}
59
60		/**
61		* @param CustomControlCollector $customControlCollector
62		*/
63		public function setCustomControlCollector(CustomControlCollector $customControlCollector)
64		{
65		$this->customControlCollector = $customControlCollector;
66		}
67
68		/**
69		* @return CustomControlRenderer
70		*/
71		public function getCustomControlRenderer()
72		{
73		return $this->customControlRenderer;
74		}
75
76		/**
77		* @param CustomControlRenderer $customControlRenderer
78		*/
79		public function setCustomControlRenderer(CustomControlRenderer $customControlRenderer)
80		{
81		$this->customControlRenderer = $customControlRenderer;
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->customControlCollector->collect($map) as $customControl) {
93		$event->addCode($formatter->renderCode($this->customControlRenderer->render($customControl, $map)));
94		}
95		}
96
97		/**
98		* {@inheritdoc}
99		*/
100		public static function getSubscribedEvents()
101		{
102		return [MapEvents::JAVASCRIPT_CONTROL_CUSTOM => 'handleMap'];
103		}
104		}
105

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class IconSequenceSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var IconSequenceCollector
28		*/
29		private $iconSequenceCollector;
30
31		/**
32		* @var IconSequenceRenderer
33		*/
34		private $iconSequenceRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param IconSequenceCollector $iconSequenceCollector
39		* @param IconSequenceRenderer $iconSequenceRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		IconSequenceCollector $iconSequenceCollector,
44		IconSequenceRenderer $iconSequenceRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setIconSequenceCollector($iconSequenceCollector);
49		$this->setIconSequenceRenderer($iconSequenceRenderer);
50		}
51
52		/**
53		* @return IconSequenceCollector
54		*/
55		public function getIconSequenceCollector()
56		{
57		return $this->iconSequenceCollector;
58		}
59
60		/**
61		* @param IconSequenceCollector $iconSequenceCollector
62		*/
63		public function setIconSequenceCollector(IconSequenceCollector $iconSequenceCollector)
64		{
65		$this->iconSequenceCollector = $iconSequenceCollector;
66		}
67
68		/**
69		* @return IconSequenceRenderer
70		*/
71		public function getIconSequenceRenderer()
72		{
73		return $this->iconSequenceRenderer;
74		}
75
76		/**
77		* @param IconSequenceRenderer $iconSequenceRenderer
78		*/
79		public function setIconSequenceRenderer(IconSequenceRenderer $iconSequenceRenderer)
80		{
81		$this->iconSequenceRenderer = $iconSequenceRenderer;
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->getIconSequenceCollector()->collect($map) as $iconSequence) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$map,
95		$this->iconSequenceRenderer->render($iconSequence),
96		'overlays.icon_sequences',
97		$iconSequence
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [MapEvents::JAVASCRIPT_OVERLAY_ICON_SEQUENCE => 'handleMap'];
108		}
109		}
110

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class IconSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var IconCollector
28		*/
29		private $iconCollector;
30
31		/**
32		* @var IconRenderer
33		*/
34		private $iconRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param IconCollector $iconCollector
39		* @param IconRenderer $iconRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		IconCollector $iconCollector,
44		IconRenderer $iconRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setIconCollector($iconCollector);
49		$this->setIconRenderer($iconRenderer);
50		}
51
52		/**
53		* @return IconCollector
54		*/
55		public function getIconCollector()
56		{
57		return $this->iconCollector;
58		}
59
60		/**
61		* @param IconCollector $iconCollector
62		*/
63		public function setIconCollector(IconCollector $iconCollector)
64		{
65		$this->iconCollector = $iconCollector;
66		}
67
68		/**
69		* @return IconRenderer
70		*/
71		public function getIconRenderer()
72		{
73		return $this->iconRenderer;
74		}
75
76		/**
77		* @param IconRenderer $iconRenderer
78		*/
79		public function setIconRenderer(IconRenderer $iconRenderer)
80		{
81		$this->iconRenderer = $iconRenderer;
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->getIconCollector()->collect($map) as $icon) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$map,
95		$this->iconRenderer->render($icon),
96		'overlays.icons',
97		$icon
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [MapEvents::JAVASCRIPT_OVERLAY_ICON => 'handleMap'];
108		}
109		}
110

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class MarkerShapeSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var MarkerShapeCollector
28		*/
29		private $markerShapeCollector;
30
31		/**
32		* @var MarkerShapeRenderer
33		*/
34		private $markerShapeRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param MarkerShapeCollector $markerShapeCollector
39		* @param MarkerShapeRenderer $markerShapeRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		MarkerShapeCollector $markerShapeCollector,
44		MarkerShapeRenderer $markerShapeRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setMarkerShapeCollector($markerShapeCollector);
49		$this->setMarkerShapeRenderer($markerShapeRenderer);
50		}
51
52		/**
53		* @return MarkerShapeCollector
54		*/
55		public function getMarkerShapeCollector()
56		{
57		return $this->markerShapeCollector;
58		}
59
60		/**
61		* @param MarkerShapeCollector $markerShapeCollector
62		*/
63		public function setMarkerShapeCollector(MarkerShapeCollector $markerShapeCollector)
64		{
65		$this->markerShapeCollector = $markerShapeCollector;
66		}
67
68		/**
69		* @return MarkerShapeRenderer
70		*/
71		public function getMarkerShapeRenderer()
72		{
73		return $this->markerShapeRenderer;
74		}
75
76		/**
77		* @param MarkerShapeRenderer $markerShapeRenderer
78		*/
79		public function setMarkerShapeRenderer(MarkerShapeRenderer $markerShapeRenderer)
80		{
81		$this->markerShapeRenderer = $markerShapeRenderer;
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->getMarkerShapeCollector()->collect($map) as $markerShape) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$map,
95		$this->markerShapeRenderer->render($markerShape),
96		'overlays.marker_shapes',
97		$markerShape
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [MapEvents::JAVASCRIPT_OVERLAY_MARKER_SHAPE => 'handleMap'];
108		}
109		}
110

egeloen / ivory-google-map

GitHub Access Token became invalid

Code Duplication Length = 81-86 lines in 26 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/Control/CustomControlSubscriber.php 1 location

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

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

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

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

		@@ 24-109 (lines=86) @@
21		/**
22		* @author GeLo <[email protected]>
23		*/
24		class SymbolSubscriber extends AbstractSubscriber
25		{
26		/**
27		* @var SymbolCollector
28		*/
29		private $symbolCollector;
30
31		/**
32		* @var SymbolRenderer
33		*/
34		private $symbolRenderer;
35
36		/**
37		* @param Formatter $formatter
38		* @param SymbolCollector $symbolCollector
39		* @param SymbolRenderer $symbolRenderer
40		*/
41		public function __construct(
42		Formatter $formatter,
43		SymbolCollector $symbolCollector,
44		SymbolRenderer $symbolRenderer
45		) {
46		parent::__construct($formatter);
47
48		$this->setSymbolCollector($symbolCollector);
49		$this->setSymbolRenderer($symbolRenderer);
50		}
51
52		/**
53		* @return SymbolCollector
54		*/
55		public function getSymbolCollector()
56		{
57		return $this->symbolCollector;
58		}
59
60		/**
61		* @param SymbolCollector $symbolCollector
62		*/
63		public function setSymbolCollector(SymbolCollector $symbolCollector)
64		{
65		$this->symbolCollector = $symbolCollector;
66		}
67
68		/**
69		* @return SymbolRenderer
70		*/
71		public function getSymbolRenderer()
72		{
73		return $this->symbolRenderer;
74		}
75
76		/**
77		* @param SymbolRenderer $symbolRenderer
78		*/
79		public function setSymbolRenderer(SymbolRenderer $symbolRenderer)
80		{
81		$this->symbolRenderer = $symbolRenderer;
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->getSymbolCollector()->collect($map) as $symbol) {
93		$event->addCode($formatter->renderContainerAssignment(
94		$map,
95		$this->symbolRenderer->render($symbol),
96		'overlays.symbols',
97		$symbol
98		));
99		}
100		}
101
102		/**
103		* {@inheritdoc}
104		*/
105		public static function getSubscribedEvents()
106		{
107		return [MapEvents::JAVASCRIPT_OVERLAY_SYMBOL => 'handleMap'];
108		}
109		}
110