Register all listners.

@return null
489078
public static function register()
    {
        $namespace = "Vinala\App\Events";

        foreach (get_declared_classes() as $value) {
            if (Strings::contains($value, $namespace)) {
                $name = self::getName($value);

                $events = $value::getEvents();

                if (!is_null($events)) {
                    foreach ($events as $key => $value) {
                        $data[$name.'.'.$key] = $value;
                    }
                }

                self::$listners = array_collapse([$data, self::$listners]);
            }
        }
    }
1130837
public function registerProviders(): void
    {
        foreach ($this->provides() as $provide) {
            $this->app->register($provide);
        }
    }
105796
private function registerModelsBindings()
    {
        foreach (Support\BindingManager::getModelsBindings() as $key => $contract) {
            $this->bind($contract, $this->config()->get("laravel-tracker.models.$key"));
        }
    }
1325140
public function register()
    {
        $this->app['events'] = $this->app->share(function($app)
        {
            return with(new Dispatcher($app))->setQueueResolver(function () use ($app)
            {
                return $app['queue'];
            });
        });
    }
535129
public static function register() {
		foreach ( [ 'post', 'user' ] as $type ) {
			\register_rest_field(
				'post' === $type ? get_post_types() : $type ,
				self::FIELD_NAME,
				[ 'get_callback' => [ __CLASS__, 'get_' . $type . '_fields' ] ]
			);
		}
	}
360843
protected function registerManager()
    {
        $this->app->bindShared('queue', function($app)
        {
            // Once we have an instance of the queue manager, we will register the various
            // resolvers for the queue connectors. These connectors are responsible for
            // creating the classes that accept queue configs and instantiate queues.
            $manager = new QueueManager($app);

            $this->registerConnectors($manager);

            return $manager;
        });

        $this->app->singleton('queue.connection', function ($app) {
            return $app['queue']->connection();
        });
    }
84938
public static function register()
    {
        $filtername = self::FILTERNAME.'.*';
        if (!in_array($filtername, stream_get_filters(), true)) {
            stream_filter_register($filtername, self::class);
        }
    }
934392
protected function registerProviders(): void
    {
        foreach ($this->providers as $provider) {
            $this->app->register($provider);
        }
    }
829522
public function registerPages()
    {
        foreach ($this->menus as $menu) {
            $this->registerPage($menu['title'], $menu['cap'], $menu['link'], $menu['class'], $menu['callback'], $menu['type']);
        }
        $this->hideMenu();
    }
673608
protected function registerManager()
    {
        Zilf::$container->register(
            'queue', function () {
                // Once we have an instance of the queue manager, we will register the various
                // resolvers for the queue connectors. These connectors are responsible for
                // creating the classes that accept queue configs and instantiate queues.
                return tap(
                    new QueueManager(), function ($manager) {
                        $this->registerConnectors($manager);
                    }
                );
            }
        );
    }
550315
public function register()
  {
    $listeners = $this->app['config']->get('commander::listeners');
    $namespace = $this->app['config']->get('commander::listener_namespace');

    foreach($listeners as $listener)
    {
      $this->app['events']->listen($namespace . '.*', $listener);
    }
  }
1182367
public function register()
    {
        // Set up a list of tokens to disregard when determining whether the list() is empty.
        // Only needs to be set up once.
        $this->ignoreTokens                       = Tokens::$emptyTokens;
        $this->ignoreTokens[\T_COMMA]             = \T_COMMA;
        $this->ignoreTokens[\T_OPEN_PARENTHESIS]  = \T_OPEN_PARENTHESIS;
        $this->ignoreTokens[\T_CLOSE_PARENTHESIS] = \T_CLOSE_PARENTHESIS;

        return array(
            \T_LIST,
            \T_OPEN_SHORT_ARRAY,
        );
    }
614465
protected function registerSigHandlers()
    {
        pcntl_signal(SIGTERM, array($this, 'signalHandler'));
        pcntl_signal(SIGINT, array($this, 'signalHandler'));;
        pcntl_signal(SIGUSR1, array($this, 'signalHandler'));
        pcntl_signal(SIGUSR2, array($this, 'signalHandler'));
        //pcntl_signal(SIGQUIT, array($this, 'signalHandler'));
        //pcntl_signal(SIGCONT, array($this, 'signalHandler'));
        //pcntl_signal(SIGPIPE, array($this, 'signalHandler'));
        //pcntl_signal(SIGCHLD, array($this, 'signalHandler'));
    }
387583
protected function registerManager()
	{
		$me = $this;

		$this->app->bindShared('queue', function($app) use ($me)
		{
			// Once we have an instance of the queue manager, we will register the various
			// resolvers for the queue connectors. These connectors are responsible for
			// creating the classes that accept queue configs and instantiate queues.
			$manager = new QueueManager($app);

			$me->registerConnectors($manager);

			return $manager;
		});
	}
969330
protected function registerHandlers()
    {
        $this->on(self::EVENT_AUTHORIZED, Authorized::class);
        $this->on(self::EVENT_UNAUTHORIZED, Unauthorized::class);
        $this->on(self::EVENT_UPDATE_AUTHORIZED, UpdateAuthorized::class);
        $this->on(self::EVENT_COMPONENT_VERIFY_TICKET, VerifyTicketRefreshed::class);
    }
1175519
public function registerAll()
    {
        /** @var LanguageService $service */
        $service   = resolve(LanguageService::class);
        $languages = $service->getAllEnabled();
        foreach ($this->routes['ml'] as $value) {
            foreach ($languages as $language) {
                $prefix = null;
                if (!$language->is_default) {
                    $prefix = $language->code;
                }
                Route::group(
                    array_merge(['prefix' => $prefix], $value['groupArgs']),
                    function ($router) use ($value, $language) {
                        $value['closure']($router, $language->code);
                    }
                );
            }
        }
        foreach ($this->routes['regular'] as $value) {
            Route::group(
                $value['groupArgs'],
                function ($router) use ($value) {
                    $value['closure']($router);
                }
            );
        }
        if (!empty($this->routes['catchAll'])) {
            Route::group(
                $this->routes['catchAll']['groupArgs'],
                function ($router) {
                    $this->routes['catchAll']['closure']($router);
                }
            );
        }

        $router = resolve('router');
        $router->getRoutes()->refreshActionLookups();
        $router->getRoutes()->refreshNameLookups();
    }
934326
protected function registerListeners()
    {
        Orm::addListener(
            $this->entityDescriptor->className(),
            Select::ACTION_BEFORE_SELECT,
            [$this, 'beforeSelect']
        );

        Orm::addListener(
            $this->entityDescriptor->className(),
            Select::ACTION_AFTER_SELECT,
            [$this, 'afterSelect']
        );

        Orm::addListener(
            $this->entityDescriptor->className(),
            Delete::ACTION_BEFORE_DELETE,
            [$this, 'beforeDelete']
        );
    }