Register manager.

@return void
345874
protected function registerServer()
    {
        $this->app->singleton(Server::class, function () {
            if (is_null(static::$server)) {
                $this->createSwooleServer();
                $this->configureSwooleServer();
            }

            return static::$server;
        });
        $this->app->alias(Server::class, 'swoole.server');
    }
696792
public function register(): void
    {
        $this->resolveLogManager();
        /** @var LogManager $log */
        $log = $this->app[LoggerInterface::class];
        $log->extend('fluent', function ($app, array $config) {
            $manager = $app->make(FluentLogManager::class);

            return $manager($config);
        });
    }
177752
public function register()
    {
        // Bind the manager interface to the default implementation
        $this->app->bind(ValidatorManagerInterface::class, ValidatorManager::class);
        $this->app->bind(ValidatorForSubjectInterface::class, ValidatorForSubjectManager::class);
    }
1132083
public function register()
    {
        $this->logger->debug('Registering worker ' . $this->getId());
        $this->resque->getClient()->sadd($this->resque->getKey(Resque::WORKERS_KEY), $this->getId());
        $this->resque->getClient()->set($this->getJobKey() . ':started', strftime('%a %b %d %H:%M:%S %Z %Y'));
    }
801372
private function registerUsermanagement() {

        $this->app->bind('usermanagement', function($app) {
            return new Usermanagement($app);
        });

        $this->app->bind(
            'Illuminate\Contracts\Auth\Registrar',
            'Lasallecms\Usermanagement\Services\Registrar'
        );
    }
1101086
public function register()
    {
        // The system resource manager is used to resolve various system resource types.
        // It also implements the resolver interface which may be used by other components adding system resource types.
        $this->app->singleton('df.system.resource', function ($app) {
            return new SystemResourceManager($app);
        });

        $this->app->resolving('df.service', function (ServiceManager $df) {
            // Add the system service
            $df->addType(new ServiceType([
                    'name'              => 'system',
                    'label'             => 'System Management',
                    'description'       => 'Service supporting management of the system.',
                    'group'             => ServiceTypeGroups::SYSTEM,
                    'singleton'         => true,
                    'config_handler'    => Config::class,
                    'factory'           => function ($config) {
                        return new System($config);
                    },
                    'access_exceptions' => [
                        [
                            'verb_mask' => 31, //Allow all verbs
                            'resource'  => 'admin/session',
                        ],
                        [
                            'verb_mask' => 2, //Allow POST only
                            'resource'  => 'admin/password',
                        ],
                        [
                            'verb_mask' => 1,
                            'resource'  => 'environment',
                        ]
                    ],
                ]
            ));
        });
    }
990779
protected function registerManager()
    {
        $this->app->singleton('updater', function (Container $app) {
            return new UpdaterManager($app);
        });
        $this->app->alias('updater', UpdaterManager::class);
    }
461434
public function registerManager()
    {
        $this->app->singleton('mollie', function (Container $app) {
            return new MollieManager($app);
        });

        $this->app->alias('mollie', MollieManager::class);
    }
307946
public function register()
	{
        $this->app->singleton('FilemanagerLaravel', function () {
            return new FilemanagerLaravel;
        });
		$this->app->booting(function()
		{
		  $loader = \Illuminate\Foundation\AliasLoader::getInstance();
		  $loader->alias('FilemanagerLaravel', 'Pqb\FilemanagerLaravel\Facades\FilemanagerLaravel');
		});
		$this->publishes([
            __DIR__ . '/../../controllers' => base_path('app/Http/Controllers'),
            __DIR__ . '/../../views' => base_path('resources/views/vendor/filemanager-laravel'),
            __DIR__ . '/../../../public' => base_path('public'),
        ]);
        $this->loadViewsFrom(__DIR__ . 'resources/views', 'filemanager-laravel');
	}
417780
public function register()
    {
        $this->app->singleton('menu.manager', function ($app) {
            return new MenuManager($app['view'], $app['url']);
        });

        $this->app->register(ActiveServiceProvider::class);
    }
974435
public function register()
    {
        $this->app['events']->listen('doctrine.extensions.booting', function () {
            $registry = $this->app->make('registry');

            foreach ($registry->getManagers() as $manager) {
                $chain = $manager->getConfiguration()->getMetadataDriverImpl();

                if ($this->hasAnnotationReader($chain)) {
                    $this->registerGedmoForAnnotations($chain);
                }

                if ($this->hasFluentDriver($chain)) {
                    $this->registerGedmoForFluent($chain);
                }
            }
        });
    }
115742
public function register()
    {
        $this->app->bindIf(IndexManagerInterface::class, DefaultManager::class);
        $this->app->resolving(DefaultManager::class, function(DefaultManager $manager) {
            $manager->addIndex(Page::class, PageIndex::class);
        });
    }
882969
public function register()
    {
        $app = $this->app;

        $app['image'] = $app->share(function ($app) {
            return new ImageManager($app['config']->get('image::config'));
        });

        $app->alias('image', 'Intervention\Image\ImageManager');
    }
51092
private function registerModuleRegistry()
    {
        $this->app->singleton( 'arbory', function ()
        {
            return new Admin(
                $this->app['sentinel'],
                new Menu(),
                new AssetPipeline()
            );
        } );

        $this->app->singleton( Admin::class, function ()
        {
            return $this->app['arbory'];
        } );
    }
103854
public function register()
    {
        $this->mergeConfigFrom(__DIR__ . '/../../config/verification.php', 'verification');

        $this->app->singleton('auth.verification', function ($app) {
            return new VerificationBrokerManager($app);
        });

        $this->app->bind('auth.verification.broker', function ($app) {
            return $app->make('auth.verification')->broker();
        });

        foreach ($this->aliases as $key => $aliases) {
            foreach ($aliases as $alias) {
                $this->app->alias($key, $alias);
            }
        }

        $this->registerCommands();
    }
1255032
public function register()
    {
        $this->app->bind(Moderator::class, function ($app) {
            $config = $app->config->get('moderate', []);

            return new Moderator($config, $app['cache'], $app->getLocale());
        });

        // Register update event with the application
        $this->app['events']->listen('blacklist.updated', function () {
            $this->app[Moderator::class]->reloadBlacklist();
        });
    }
830294
protected function registerManager()
    {
        $this->app->singleton('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.
            return tap(new QueueManager($app), function ($manager) {
                $this->registerConnectors($manager);
            });
        });
    }