Returns an array of system events
@return array
514344
protected function getListReportEvent()
    {
        $conditions = $this->query_filter;
        $conditions['limit'] = $this->data_limit;

        $list = (array) $this->report->getList($conditions);
        $this->prepareListReportEvent($list);
        return $list;
    }
637861
public function getEventActions($eventName)
    {
        $events = isset($this->events[$eventName]) ? $this->events[$eventName] : [];

        return is_array($events) ? $events : [$events];
    }
46006
public function implementedEvents()
    {
        $this->setupDetectors();

        // make sure the listener does absolutely nothing unless
        // the application/vnd.api+json Accept header is used.
        if (!$this->_checkRequestType('jsonapi')) {
            return [];
        }

        // accept body data posted with Content-Type `application/vnd.api+json`
        $this->_controller()->RequestHandler->setConfig('inputTypeMap', [
            'jsonapi' => ['json_decode', true]
        ]);

        return [
            'Crud.beforeHandle' => ['callable' => [$this, 'beforeHandle'], 'priority' => 10],
            'Crud.setFlash' => ['callable' => [$this, 'setFlash'], 'priority' => 5],
            'Crud.beforeSave' => ['callable' => [$this, 'beforeSave'], 'priority' => 20],
            'Crud.afterSave' => ['callable' => [$this, 'afterSave'], 'priority' => 90],
            'Crud.afterDelete' => ['callable' => [$this, 'afterDelete'], 'priority' => 90],
            'Crud.beforeRender' => ['callable' => [$this, 'respond'], 'priority' => 100],
            'Crud.beforeRedirect' => ['callable' => [$this, 'beforeRedirect'], 'priority' => 100],
            'Crud.beforePaginate' => ['callable' => [$this, 'beforeFind'], 'priority' => 10],
            'Crud.beforeFind' => ['callable' => [$this, 'beforeFind'], 'priority' => 10],
            'Crud.afterFind' => ['callable' => [$this, 'afterFind'], 'priority' => 50],
        ];
    }
1134827
def events(self):
        ''''''
        ret = []
        while self.out_queue.qsize():
            ret.append(self.out_queue.get())
        return ret
1126470
public function getInspectionData()
    {
        return [
            static::PARAM_TIME                   => $this->time,
            static::PARAM_MEMORY                 => $this->memory,
            static::PARAM_EVENT_ID               => $this->eventId,
            static::PARAM_IS_START               => $this->isStart,
            static::PARAM_EVENT                  => $this->event->getObject(),
            static::PARAM_NAME                   => $this->name,
            static::PARAM_TARGET                 => $this->target->getValue(),
            static::PARAM_PARAMS                 => $this->params->getValue(),
            static::PARAM_PROPAGATION_IS_STOPPED => $this->propagationIsStopped,
            static::PARAM_TRACE                  => $this->trace->getValue(),
        ];
    }
1110191
public static function getDriverEvents()
    {
        return [
            DriverEvents::DRIVER_GET_CONFIGURATION => [
                ["getConfiguration", 0],
            ],
            DriverEvents::DRIVER_LOAD_CONFIGURATION => [
                ["loadConfiguration", 0],
            ],
            DriverEvents::INDEX_CREATE => [
                ["createIndex", 0],
            ],
            DriverEvents::INDEX_EXISTS => [
                ["indexExists", 0],
            ],
            DriverEvents::INDEX_DELETE => [
                ["deleteIndex", 0],
            ],
            DriverEvents::INDEXES_PERSIST => [
                ["persistIndexes", 0],
            ],
            DriverEvents::INDEX_SEARCH_QUERY => [
                ["executeSearchQuery", 0],
            ]
        ];
    }
349263
public function getEvents()
    {
        $inotifyEvents = $this->readEvents();

        $inotifyEvents = is_array($inotifyEvents) ? $inotifyEvents : array();

        $last = end($inotifyEvents);
        if (IN_Q_OVERFLOW === $last['mask']) {
            throw new RuntimeException('Event queue overflowed. Either read events more frequently or increase the limit for queues. The limit can be changed in /proc/sys/fs/inotify/max_queued_events');
        }

        foreach ($inotifyEvents as $event) {
            foreach ($this->bag->get($event['wd']) as $watched) {
                $watched->setEvent($event['mask'], $event['name']);
            }
        }

        $events = array();

        foreach ($this->checkers as $meta) {
            $tracked = $meta['tracked'];
            $watched = $meta['checker'];
            foreach ($watched->getChangeset() as $change) {
                $events[] = new FilesystemEvent($tracked, $change['resource'], $change['event']);
            }
        }

        return $events;
    }
588977
public function getEvents()
    {
        if (empty($this->events)) {
            return [];
        }

        $events = call_user_func_array('array_merge', $this->events);

        foreach ($events as &$e) {
            if (!$e['timestamp'] instanceof \DateTime) {
                $dt             = new DateTimeHelper($e['timestamp'], 'Y-m-d H:i:s', 'UTC');
                $e['timestamp'] = $dt->getDateTime();
                unset($dt);
            }
        }

        if (!empty($this->orderBy)) {
            usort(
                $events,
                function ($a, $b) {
                    switch ($this->orderBy[0]) {
                        case 'eventLabel':
                            $aLabel = '';
                            if (isset($a['eventLabel'])) {
                                $aLabel = (is_array($a['eventLabel'])) ? $a['eventLabel']['label'] : $a['eventLabel'];
                            }

                            $bLabel = '';
                            if (isset($b['eventLabel'])) {
                                $bLabel = (is_array($b['eventLabel'])) ? $b['eventLabel']['label'] : $b['eventLabel'];
                            }

                            return strnatcmp($aLabel, $bLabel);

                        case 'date_added':
                            if ($a['timestamp'] == $b['timestamp']) {
                                $aPriority = isset($a['eventPriority']) ? (int) $a['eventPriority'] : 0;
                                $bPriority = isset($b['eventPriority']) ? (int) $b['eventPriority'] : 0;

                                return $aPriority - $bPriority;
                            }

                            return $a['timestamp'] < $b['timestamp'] ? -1 : 1;

                        case 'contact_id':
                            if ($a['contactId'] == $b['contactId']) {
                                return 0;
                            }

                            return $a['contactId'] < $b['contactId'] ? -1 : 1;

                        case 'type':

                            return strnatcmp($a['eventType'], $b['eventType']);

                        default:

                            return strnatcmp($a[$this->orderBy[0]], $b[$this->orderBy[0]]);
                    }
                }
            );

            if ('DESC' == $this->orderBy[1]) {
                $events = array_reverse($events);
            }
        }

        return $events;
    }
605408
public function getInvocations(): array
    {
        if (empty($this->invocations)) {
            $this->locateInvocations($this->getTokens());
        }

        return $this->invocations;
    }
895818
public function getCallbackEvents(): array
    {
        $events = [];
        foreach ($this->getHydratedEntries() as $hydratedEntry) {
            /** @var \Kerox\Messenger\Model\Callback\Entry $hydratedEntry */
            $events = array_merge($events, $hydratedEntry->getEvents());
        }

        return $events;
    }
1353732
public function emitBufferedEvents()
    {
        $result = [];

        while ($event = array_shift($this->bufferedEvents)) {
            $result[] = parent::emit($event);
        }

        return $result;
    }
809152
public function getSubscribedEvents()
    {
        $events = array();
        $self = $this;
        foreach ($this->plugins as $plugin) {
            foreach (array_keys($plugin->getSubscribedEvents()) as $event) {
                if (isset($events[$event])) {
                    continue;
                }
                $events[$event] = function() use ($event, $self) {
                    $self->handleEvent($event, func_get_args());
                };
            }
        }
        return $events;
    }
830112
public function getSubscribedEvents()
    {
        $events = [
            $this->command . '.resolve' => 'resolveDnsQuery',
            $this->command . '.resolver' => 'getResolverEvent',
        ];

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

        return $events;
    }
1312234
public function events()
    {
        return [
            Server::ON_CONNECT => 'onConnect',
            Server::ON_MESSAGE => 'onMessage',
            Server::ON_CLOSE => 'onClose',
            Server::ON_ERROR => 'onError',
            Server::ON_BAD_PACKET => 'onBadPacket',
            Server::ON_BUFFER_FULL => 'onBufferFull',
            Server::ON_BUFFER_DRAIN => 'onBufferDrain',
            Server::ON_SSL_HANDSHAKED => 'onSSLHandShaked',
            Server::ON_UDP_PACKET => 'onUdpPacket',
            Server::ON_START_ACCEPT => 'onStartAccept',
            Server::ON_STOP_ACCEPT => 'onStopAccept',
        ];
    }
399639
public static function getEventNames()
    {
        $names = [];
        $reflection = new \ReflectionClass(self::class);
        foreach ($reflection->getConstants() as $constant => $value) {
            if ('REPEATED_' === substr($constant, 0, 9)) {
                $names[] = $value;
            }
        }

        return $names;
    }
794754
private function _getEventsConfig()
    {
        $content = array(self:: MAIN_EVENTS_FILE => array());

        $configPath = $this->_configPath;
        if (! is_dir($configPath)) {
            return $content;
        }

        $files = DirData::listFilesRecursive($configPath, self:: MAIN_EVENTS_FILE . self::EXT);
        foreach ($files as $file) {
            $content[self:: MAIN_EVENTS_FILE] = array_merge_recursive(require($file), $content[self:: MAIN_EVENTS_FILE]);
        }

        return $content;
    }
219959
public function listPublicNetworkEvents(): array
    {
        return $this->getApi()->request($this->getApi()->sprintf('/networks/:owner/:repo/events',
            $this->getActivity()->getOwner(), $this->getActivity()->getRepo()));
    }