Register the manager class.

@return void
540853
protected function registerManager()
    {
        $this->app->singleton('flysystem', function (Container $app) {
            $config = $app['config'];
            $factory = $app['flysystem.factory'];

            return new FlysystemManager($config, $factory);
        });

        $this->app->alias('flysystem', FlysystemManager::class);
    }
623255
public function register()
    {
        $this->app->register(\Intervention\Image\ImageServiceProvider::class);

        $this->app->singleton('media', function () {
            return $this->app->make(config('media.manager', Manager::class));
        });
    }
1310759
public function register()
    {
        // Register main classes
        $this->app->make('Laraveldaily\Quickadmin\Controllers\QuickadminController');
        $this->app->make('Laraveldaily\Quickadmin\Controllers\UserActionsController');
        $this->app->make('Laraveldaily\Quickadmin\Controllers\QuickadminMenuController');
        $this->app->make('Laraveldaily\Quickadmin\Cache\QuickCache');
        $this->app->make('Laraveldaily\Quickadmin\Builders\MigrationBuilder');
        $this->app->make('Laraveldaily\Quickadmin\Builders\ModelBuilder');
        $this->app->make('Laraveldaily\Quickadmin\Builders\RequestBuilder');
        $this->app->make('Laraveldaily\Quickadmin\Builders\ControllerBuilder');
        $this->app->make('Laraveldaily\Quickadmin\Builders\ViewsBuilder');
        $this->app->make('Laraveldaily\Quickadmin\Events\UserLoginEvents');
        // Register dependency packages
        $this->app->register('Collective\Html\HtmlServiceProvider');
        $this->app->register('Intervention\Image\ImageServiceProvider');
        $this->app->register('Yajra\Datatables\DatatablesServiceProvider');
        // Register dependancy aliases
        $loader = \Illuminate\Foundation\AliasLoader::getInstance();
        $loader->alias('HTML', 'Collective\Html\HtmlFacade');
        $loader->alias('Form', 'Collective\Html\FormFacade');
        $loader->alias('Image', 'Intervention\Image\Facades\Image');
        $loader->alias('Datatables', 'Yajra\Datatables\Datatables');
    }
726827
protected function loadManager()
    {
        if (null === $this->getManager()) {
            $manager = new Manager($this->getConfig(), $this);
            $this->setManager($manager);
        } else {
            $manager = $this->getManager();
            $manager->setCommand($this);
        }
    }
903585
private function registerMenuManagerService()
    {
        $this->singleton('arcanedev.menus.manager', function () {
            return new MenusManager;
        });

        $this->app->bind(
            \Arcanedev\Menus\Contracts\MenusManager::class,
            \Arcanedev\Menus\MenusManager::class
        );
    }
778759
protected function registerModel()
    {
        $this->app['generate.model'] = $this->app->share(function($app)
        {
            $generator = $this->app->make('Way\Generators\Generator');

            return new ModelGeneratorCommand($generator);
        });

        $this->commands('generate.model');
    }
910789
public function register() {
        $this->loadConfiguration();

        Support\merge_yaml_config_from(
            config_path('yaml/settings/general.yaml') , 'laravel-settings'
        );

        $this->app->singleton('settings-manager', function() {
            return new DriverManager(
                config('laravel-settings')
            );
        });
    }
79965
public function register()
    {
        $this->app->singleton(Collection::class, function ($app) {
            return new Collection();
        });
        $this->app->singleton(Item::class, function ($app) {
            return new Item();
        });
        $this->app->bind(Manager::class, function ($app) {
            $manager = new Manager();
            $request = app('Request');
            $manager->setSerializer(new JsonApiSerializer($request::getSchemeAndHttpHost()));
            return $manager;
        });
    }
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);
    }
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',
                        ]
                    ],
                ]
            ));
        });
    }
507736
public function register()
    {
        $this->app->singleton('server.factory', function ($app) {
            return new ServerFactory($app);
        });

        // By default, the server manager creates a server instance based on the
        // 'server' configuration. We can easily get it through the IoC container
        // or the server facade.
        $this->app->singleton('server', function ($app) {
            return new ServerManager($app, $app['server.factory'], $app['config']['server']);
        });

        // We can get a Swoole server instance from server, this allows us to easily
        // perform in-depth operations.
        $this->app->singleton('server.swoole', function ($app) {
            return $app['server']->getSwooleServer();
        });

        $this->registerCommands($this->commands);
    }
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'];
        } );
    }
428284
public function register()
    {
        $loader = AliasLoader::getInstance();

        // Register aliases
        foreach ($this->getAliases() as $alias => $class) {
            $loader->alias($alias, $class);
        }

        // Register service containers
        foreach ($this->getServiceContainers() as $abstract => $concrete) {
            $this->app->singleton($abstract, $concrete);
        }
    }
103407
public function register()
    {
        if (method_exists($this, 'publishes')) {
            $this->registerResources();
        }

        $this->app->singleton('feed_manager', function($app) {
            $manager_class = config('stream-laravel.feed_manager_class');
            $api_key = config('stream-laravel.api_key');
            $api_secret = config('stream-laravel.api_secret');

            return new $manager_class($api_key, $api_secret, $this->app['config']);
        });
    }
450018
public function register()
    {
        $this->app->singleton('orchestra.avatar', function (Application $app) {
            $manager = new AvatarManager($app);
            $namespace = $this->hasPackageRepository() ? 'orchestra/avatar::' : 'orchestra.avatar';

            $manager->setConfig($app->make('config')->get($namespace));

            return $manager;
        });
    }
877802
protected function registerJsonManager()
    {
        $config = $this->app['config'];
        $this->app->singleton('jsonq.manager', function () use ($config) {
            return new JsonQueriable($config->get('jsonq.json.storage_path'));
        });

        $this->app->alias('jsonq.manager', JsonQueriable::class);
    }
1124313
public function register()
    {
        $this->app->bindShared('packages', function ($app)
        {
            $repository = new Repository($app['config'], $app['files']);

            return new PackageManager($app, $repository);
        });
    }