getEventMapper

@return EventMapperInterface
337000
public function getEventMapper()
    {
        if (null === $this->eventMapper) {
            $this->eventMapper = $this->serviceLocator->get('playgroundflow_event_mapper');
        }

        return $this->eventMapper;
    }
1230282
public function getMapper()
    {
        if (!$this->mapper instanceof CategoryMapper) {
            $this->mapper = $this->getServiceLocator()->get('dlccategory_category_mapper');
        }
        return $this->mapper;
    }
1374938
public static Map<EventType, Method> getEventMap(Class<?> serviceInterface) {
    if (!serviceInterface.isInterface()) {
      Class type = serviceInterface;
      Map<EventType, Method> events = new HashMap<>();
      while (type != Object.class) {
        for (Class<?> iface : type.getInterfaces()) {
          events.putAll(findEvents(iface));
        }
        type = type.getSuperclass();
      }
      return events;
    }
    return findEvents(serviceInterface);
  }
902792
public function getEventName()
	{
		if($this->eventName !== NULL)
		{
			return $this->eventName;
		}
		
		if($this->reflection === NULL)
		{
			$this->reflection = new \ReflectionMethod($this->object, $this->methodName);
		}
		
		$params = $this->reflection->getParameters();
			
		if(empty($params))
		{
			throw new \InvalidArgumentException(sprintf('Method listener %s->%s() must accept an event argument', $this->reflection->getDeclaringClass()->name, $this->reflection->name));
		}
			
		if(NULL !== ($paramTypeName = $this->getParamType($params[0])))
		{
			$this->eventName = $paramTypeName;
		}
		else
		{
			throw new \InvalidArgumentException(sprintf('Event callback param "%s" of %s->%s() must declare an event type hint', $params[0]->name, $this->reflection->getDeclaringClass()->name, $this->reflection->name));
		}
		
		return $this->eventName;
	}
1248009
protected function getSchemaMapper()
    {
        if (!$this->schema) {
            $this->schema = Ioc::make($this->schemaClass);
        }

        return Ioc::makeWith(SchemaMapper::class, ['schema' => $this->schema]);
    }
63339
public function getDataMapper()
    {
        if (!$this->mapper) {
            $this->mapper = new DataMapper($this->table, $this->keys);
        }

        return $this->mapper;
    }
171828
protected function getEventDefinitions()
    {
        $scanner = $this->laravel->make('annotations.event.scanner');

        $scanner->setClassesToScan($this->provider->eventScans());

        return '<?php '.PHP_EOL.PHP_EOL.$scanner->getEventDefinitions().PHP_EOL;
    }
519962
public function getFaqMapper()
    {
        if (null === $this->faqMapper) {
            $this->faqMapper = $this->getServiceManager()->get('playgroundfaq_faq_mapper');
        }

        return $this->faqMapper;
    }
848841
public Map<String, Object> getMap() {
        Map<String, Object> retMap = Collections.synchronizedMap(new TreeMap<String, Object>());
        retMap.putAll(eventMap);
        return retMap;
    }
991134
function getEventManager()
    {
        if ($this->eventManager)
            return $this->eventManager;

        $eventManager = $this->getServiceManager()
            ->get('EventManager')
                ->setIdentifiers(array(
                    __CLASS__,
                    get_class($this),
                    // Default Identifier
                    'Zend\Mvc\Application',
                ));

        $this->eventManager = $eventManager;

        return $this->eventManager;
    }
84468
public function getThemeMapper()
    {
        if (null === $this->themeMapper) {
            $this->themeMapper = $this->getServiceManager()->get('playgrounddesign_theme_mapper');
        }

        return $this->themeMapper;
    }
953425
@Beta
    public static Type getMapping(final String eventType) {
        if (!containsMappingFor(eventType)) {
            return null;
        } else {
            return systemEventMappings.get(canonicalizeEventType(eventType));
        }
    }
323205
protected function getContentTypeDomainMapper()
    {
        if ($this->contentTypeDomainMapper !== null) {
            return $this->contentTypeDomainMapper;
        }

        $this->contentTypeDomainMapper = new Helper\ContentTypeDomainMapper(
            $this->persistenceHandler->contentTypeHandler(),
            $this->persistenceHandler->contentLanguageHandler(),
            $this->getFieldTypeRegistry()
        );

        return $this->contentTypeDomainMapper;
    }
1041659
public function getEventQueue()
    {
        if (null === $this->eventQueue) {
            $this->eventQueue = new Event\EventQueue(
                $this->getConfigurationRegistry(),
                $this->getEventDispatcher()
            );
        }

        return $this->eventQueue;
    }
1270028
public function getPrizeMapper()
    {
        if (null === $this->prizeMapper) {
            $this->prizeMapper = $this->serviceLocator->get('playgroundgame_prize_mapper');
        }

        return $this->prizeMapper;
    }
1142922
@Beta
    public Type getCustomEventMapping(final String eventType) {
        if (!containsCustomEventMappingFor(eventType)) {
            return null;
        } else {
            return this.eventTypeToEventDataMapping.get(canonicalizeEventType(eventType));
        }
    }
272294
public function getEvent()
    {
        if (null === $this->event) {
            $this->setEvent(new AdapterChainEvent);
            $this->event->setTarget($this);
        }

        return $this->event;
    }