Register the flysystem factory class.

@return void
345024
protected function registerFlysystemFactory()
    {
        $this->app->singleton('flysystem.factory', function (Container $app) {
            $adapter = $app['flysystem.adapterfactory'];
            $cache = $app['flysystem.cachefactory'];

            return new FlysystemFactory($adapter, $cache);
        });

        $this->app->alias('flysystem.factory', FlysystemFactory::class);
    }
32854
public function register()
    {
        // Register Sub Providers
        $this->registerSubProviders(collect($this->subProviders));
        // Register bindings.
        $this->registerBindings(collect($this->bindings));
        // Register migrations.
        $this->registerMigrations(collect($this->migrations));
        // Register seeders.
        $this->registerSeeders(collect($this->seeders));
        // Register model factories.
        $this->registerFactories(collect($this->factories));
    }
1125884
public function register()
    {
        $this->app->bindShared('db.factory', function($app)
        {
            return new ConnectionFactory($app);
        });

        $this->app->bindShared('db', function($app)
        {
            return new DatabaseManager($app, $app['db.factory']);
        });
    }
1188401
public function registerConsole()
    {
        $this->commands(TypeMakeCommand::class);
        $this->commands(QueryMakeCommand::class);
        $this->commands(MutationMakeCommand::class);
    }
200888
public function register()
	{
		$this->app->singleton('command.session.database', function($app)
		{
			return new Console\SessionTableCommand($app['files'], $app['composer']);
		});

		$this->commands('command.session.database');
	}
401358
public function register()
    {
        // Configs
        $this->mergeConfigFrom(__DIR__ . '/../../../config/combine-core.php', 'combine-core');
        $this->mergeConfigFrom(__DIR__ . '/../../../config/fractal.php', 'fractal');
        config(['database.connections.combineTesting' => [
            'driver' => 'sqlite',
            'database' => ':memory:',
            'prefix' => '',
        ]]);

        // Factories
        $this->registerEloquentFactoriesFrom(__DIR__ . '/../../../factories');
    }
240533
public function register() {
        $this->commands([
            'Synga\PhpStormMeta\Laravel\Command\ExcludeCommand',
            'Synga\PhpStormMeta\Laravel\Command\IncludeCommand',
            'Synga\PhpStormMeta\Laravel\Command\GenerateCommand',
        ]);

        $this->app->singleton('Synga\InheritanceFinder\InheritanceFinderInterface', function(){
            if(!file_exists(storage_path('class_cache'))){
                mkdir(storage_path('class_cache'));
            }

            $config = new \Synga\InheritanceFinder\File\FileConfig();

            $config->setApplicationRoot(base_path());
            $config->setCacheDirectory(storage_path('class_cache'));

            return InheritanceFinderFactory::getInheritanceFinder($config);
        });
    }
443953
public function register()
    {   
        $this->app->bind('messagebird', function($app){
            $client = new \MessageBird\Client($app['config']['messagebird']['access_key']);
            return new Messagebird($client);
        });
    }
679500
public function register()
    {
        $this->app->singleton(SecurityContext::class);
        $this->app->bind(RepositoryFactory::class, function(Container $container){
            return
                new ContainerBindingRepositoryFactory($container,
                    new ConfigurationRepositoryFactory($container,
                        new DefaultRepositoryFactory($container)
                    )
                );
        });
    }
824048
public function boot()
    {
        if ($this->app instanceof LumenApplication) {
            $this->app->configure('filesystems');
        }

        $this->app->make('filesystem')
                  ->extend('cosv5', function ($app, $config) {
                      $client = new Client($config);
                      $flysystem = new Filesystem(new Adapter($client, $config), $config);

                      $flysystem->addPlugin(new PutRemoteFile());
                      $flysystem->addPlugin(new PutRemoteFileAs());
                      $flysystem->addPlugin(new GetUrl());
                      $flysystem->addPlugin(new CDN());
                      $flysystem->addPlugin(new TCaptcha());
                      $flysystem->addPlugin(new GetFederationToken());

                      return $flysystem;
                  });
    }
742797
protected function register()
    {
        // Make posttype model for the factory.
        $this->setModel($this->makePosttypeModel());

        // Build posttype with model.
        $this->setSingularity($this->makePosttypeInstance());

        // Set columns to the posttype, after admin init.
        if ($this->methodExist('columns')) {
            $this->registerColumns();
        }

        // Set posttype post templates.
        if ($this->methodExist('templates')) {
            $this->registerTemplates();
        }
    }
696730
protected function register()
    {
        // Make comment model for the factory.
        $this->setModel($this->makeCommentModel());

        // Build comment with model.
        $this->setSingularity($this->makeCommentInstance());

        // Set columns to the comment, after admin init.
        if ($this->methodExist('columns')) {
            $this->registerColumns();
        }
    }
1074573
public function register()
    {
        $this->commands('Someline\Repository\Generators\Commands\RepositoryCommand');
        $this->commands('Someline\Repository\Generators\Commands\TransformerCommand');
        $this->commands('Someline\Repository\Generators\Commands\PresenterCommand');
        $this->commands('Someline\Repository\Generators\Commands\EntityCommand');
        $this->commands('Someline\Repository\Generators\Commands\ValidatorCommand');
        $this->commands('Someline\Repository\Generators\Commands\ControllerCommand');
        $this->commands('Someline\Repository\Generators\Commands\BindingsCommand');
        $this->commands('Someline\Repository\Generators\Commands\CriteriaCommand');
    }
516835
protected function registerFlysystem()
  {
    $this->registerManager();

    $this->app->singleton('filesystem.disk', function ($app) {
      return $app['filesystem']->disk($this->getDefaultDriver());
    });
  }
1367471
public function registerFactory()
    {
        $this->app->bindShared('view', function($app)
        {
            // Next we need to grab the engine resolver instance that will be used by the
            // environment. The resolver will be used by an environment to get each of
            // the various engine implementations such as plain PHP or Template engine.
            $resolver = $app['view.engine.resolver'];

            $finder = $app['view.finder'];

            $factory = new Factory($resolver, $finder, $app['events']);

            // We will also set the container instance on this view environment since the
            // view composers may be classes registered in the container, which allows
            // for great testable, flexible composers for the application developer.
            $factory->setContainer($app);

            $factory->share('app', $app);

            return $factory;
        });
    }
638663
public function register()
    {
        $this->app->singleton('column.factory', function ($app) {
            return new ColumnFactory($app);
        });

        $this->app->alias('column.factory', ColumnFactory::class);
    }
579468
protected function registerFactory()
    {
        $this->app->singleton(Factory::class, function ($app) {
            return new Factory($app[LoopInterface::class], $app[ConnectorInterface::class]);
        });
        $this->app->alias(Factory::class, 'ami.factory');
    }