Gets the system-wide events registry
@return Events
352400
public function events()
    {
        if (!isset($this->_events)) {
            $this->_events = new \Pheasant\Events();
        }

        return $this->_events;
    }
1146975
public function implementedEvents()
    {
        return [
            (string)EventName::APP_MODEL_GET_CALENDARS() => 'getPluginCalendars',
            (string)EventName::APP_MODEL_GET_EVENTS() => 'getPluginCalendarEvents',
            (string)EventName::PLUGIN_CALENDAR_MODEL_GET_CALENDARS() => 'sendGetCalendarsToApp',
            (string)EventName::PLUGIN_CALENDAR_MODEL_GET_EVENTS() => 'sendGetCalendarEventsToApp',
            (string)EventName::APP_ADD_EVENT() => 'addEvent',
        ];
    }
534215
public function implementedEvents()
    {
        $events = parent::implementedEvents();

        $events['Crud.beforeRender'][] = ['callable' => [$this, 'publishSuccess']];

        if (method_exists($this, 'viewVar')) {
            $events['Crud.beforeRender'][] = ['callable' => [$this, 'publishViewVar']];
        }

        return $events;
    }
1080520
public function getEventManager()
    {
        if (!$this->events instanceof EventManagerInterface) {
            $identifiers = array(__CLASS__, get_called_class());
            if (isset($this->eventIdentifier)) {
                if ((is_string($this->eventIdentifier))
                    || (is_array($this->eventIdentifier))
                    || ($this->eventIdentifier instanceof Traversable)
                ) {
                    $identifiers = array_unique($identifiers + (array) $this->eventIdentifier);
                } elseif (is_object($this->eventIdentifier)) {
                    $identifiers[] = $this->eventIdentifier;
                }
                // silently ignore invalid eventIdentifier types
            }
            $this->setEventManager(new EventManager($identifiers));
        }
        return $this->events;
    }
1041659
public function getEventQueue()
    {
        if (null === $this->eventQueue) {
            $this->eventQueue = new Event\EventQueue(
                $this->getConfigurationRegistry(),
                $this->getEventDispatcher()
            );
        }

        return $this->eventQueue;
    }
276566
public function events(array $events = null)
    {
        if (null !== $events) {
            return $this->events = $events;
        }

        return $this->events;
    }
306056
def get_events(self):
        
        res = copy.copy(self.events)
        del self.events[:]
        return res
2924
protected function discoveredEvents()
    {
        if ($this->app->eventsAreCached()) {
            return require $this->app->getCachedEventsPath();
        }

        return $this->shouldDiscoverEvents()
                    ? $this->discoverEvents()
                    : [];
    }
8596
protected static function get_cron_events() {

		$crons  = _get_cron_array();
		$events = array();

		if ( empty( $crons ) ) {
			return new WP_Error(
				'no_events',
				'You currently have no scheduled cron events.'
			);
		}

		foreach ( $crons as $time => $hooks ) {
			foreach ( $hooks as $hook => $hook_events ) {
				foreach ( $hook_events as $sig => $data ) {

					$events[] = (object) array(
						'hook'     => $hook,
						'time'     => $time,
						'sig'      => $sig,
						'args'     => $data['args'],
						'schedule' => $data['schedule'],
						'interval' => Utils\get_flag_value( $data, 'interval' ),
					);

				}
			}
		}

		$events = array_map( 'Cron_Event_Command::format_event', $events );

		return $events;

	}
654069
public static function getEventManager()
    {
        if (!isset(self::$event_manager[get_called_class()])) {
            self::$event_manager[get_called_class()] =
                EventDispatcher::getShareable(static::$static_scope);
        }
        return self::$event_manager[get_called_class()];
    }
682845
public function getAllActiveEvents(): array
    {
        $activeEvents = [];
        foreach (self::$eventsMap as $eventName => $eventClass) {
            if (!class_exists($eventClass)) {
                continue;
            }

            $activeEvents[] = $eventName;
        }

        $listeners = $this->eventDispatcher->getListeners();
        $activeEvents = array_unique(array_merge($activeEvents, array_keys($listeners)));

        asort($activeEvents);

        return $activeEvents;
    }
210089
protected function dispatchConfigurationEvents(): self
    {
        foreach ($this->iterationsEvents as $event) {
            if (!($this->loopCount % $event['count'])) {
                $this->dispatchEvent($event['name']);
            }
        }

        return $this;
    }
1345770
public function getEventManager()
    {
        if (!$this->events) {
            $events = new EventManager();
            $this->setEventManager($events);
        }

        return $this->events;
    }
578495
public function managerGetRegistrations()
    {
        $registrations = $this->getRegistrations();

        $regInfo = [];
        /** @var Registration $reg */
        foreach ($registrations as $reg) {
            $regInfo[] = [
                'id'                    => $reg->getId(),
                'invoke'                => $reg->getInvokeType(),
                'thruway_multiregister' => $reg->getAllowMultipleRegistrations(),
                'disclose_caller'       => $reg->getDiscloseCaller(),
                'session'               => $reg->getSession()->getSessionId(),
                'authid'                => $reg->getSession()->getAuthenticationDetails()->getAuthId(),
                'statistics'            => $reg->getStatistics()
            ];
        }
    }
141996
public function getLoggableEvents() {
		$list = [
			EVENT_CORE_USER_REGISTER,
			EVENT_CORE_BO_LOGIN_OK,
			EVENT_CORE_BO_LOGIN_FAIL,
			EVENT_CORE_LOG_CLEAR,
			//EVENT_CORE_DIR_CREATE,
			//EVENT_CORE_DIR_EDIT,
			//EVENT_CORE_DIR_DELETE,
			//EVENT_CORE_MATH_CREATE,
			//EVENT_CORE_MATH_EDIT,
			//EVENT_CORE_MATH_DELETE,
			//EVENT_CORE_MATH_PUB,
			//EVENT_CORE_MATH_UNPUB,
			//EVENT_CORE_USER_PROP,
		];
		
		return  array_diff(
			array_merge ( $list, (array)$this->configGet('events_log_enabled') ),
			(array)$this->configGet('events_log_disabled')
		);
	}
367611
public FSArray getEvents() {
    if (Document_Type.featOkTst && ((Document_Type)jcasType).casFeat_events == null)
      jcasType.jcas.throwFeatMissing("events", "de.julielab.jules.types.ace.Document");
    return (FSArray)(jcasType.ll_cas.ll_getFSForRef(jcasType.ll_cas.ll_getRefValue(addr, ((Document_Type)jcasType).casFeatCode_events)));}
830112
public function getSubscribedEvents()
    {
        $events = [
            $this->command . '.resolve' => 'resolveDnsQuery',
            $this->command . '.resolver' => 'getResolverEvent',
        ];

        if ($this->enableCommand) {
            $events['command.' . $this->command] = 'handleDnsCommand';
        }

        return $events;
    }