Register the application to connect all available managers with it.
@param INabuApplication $nb_application Application instance to be registered.
428963
public function registerApplication(INabuApplication $nb_application)
    {
        $this->nb_manager_list->iterate(
            function($key, $manager) use ($nb_application)
            {
                $manager->registerApplication($nb_application);
                return true;
            }
        );
    }
643754
protected function registerManager(Application $app)
    {
        $app->singleton('opensearch', function ($app) {
            $config = $app['config'];
            $factory = $app['opensearch.factory'];
            return new OpensearchManager($config, $factory);
        });
        $app->alias('opensearch', 'Orzcc\Opensearch\OpensearchManager');
    }
480292
protected function registerBindings(Application $app) {
        $app->bind('bitbucket.connection', function ($app) {
            $manager = $app['bitbucket'];
            return $manager->connection();
        });
        $app->alias('bitbucket.connection', Api::class);
    }
466791
public function register(Application $app)
    {
        $prefix = $this->prefix;

        foreach(array('.server', '.options', '.attributes') as $key) {
            if (!(isset($app[$prefix . $key]))) {
                $app[$prefix. $key] = array();
            }
        }

        $app[$prefix] = $this->getPdo($app, $prefix);
    }
1071079
public function register(Application $app)
    {
        parent::register($app);

        // override this in config to allow a different user entity class to be used.
        if (isset($app['config']['user.entity'])) {
            $app['user.entity'] = $app['config']['user.entity'];
        } else {
            $app['user.entity'] = User::class;
        }

        // setup security for cli commands
        if (php_sapi_name() === 'cli') {
            $app['console.configure'] = $app->extend('console.configure', function ($callbacks) {
                $callbacks[] = function (Command $command) {
                    if ($command instanceof BaseCommand) {
                        $command->addOption('user', 'U', InputOption::VALUE_REQUIRED, 'User ID to run command as');
                    }
                };
                return $callbacks;
            });
            $app['console.prerun'] = $app->extend('console.prerun', function ($callbacks) {
                $callbacks[] = function (Command $command, InputInterface $input, OutputInterface $output) {
                    if ($command instanceof BaseCommand && $input->getOption('user')) {
                        $app = $command->getSilexApplication();
                        /** @var EntityManagerInterface $em */
                        $em = $app['orm.em'];
                        $app['user'] = $em->find($app['user.entity'], $input->getOption('user'));
                    }
                };
                return $callbacks;
            });
        }

        $app['security.firewalls'] = [];
        $app['security.access_rules'] = [];
        $app->register(new SecurityServiceProvider);
    }
1292508
public function registerManager()
    {
        $this->app->singleton('omnipay', function ($app) {
            $factory = new GatewayFactory;
            $manager = new LaravelOmnipayManager($app, $factory);

            return $manager;
        });
    }
795025
protected function registerAccessManager()
    {
        // Bind AccessManager.
        $this->app->singleton(AccessManager::SERVICE_ID, function (Application $app) {
            /** @var Repository $configRepo */
            $configRepo = $app->make('config');

            return new AccessManager(
                $configRepo->get('personality-insights.default_credentials'),
                $configRepo->get('personality-insights.api_version')
            );
        });
    }
119895
public function register()
    {
        // The connection factory is used to create the actual connection instances on
        // the database. We will inject the factory into the manager so that it may
        // make the connections while they are actually needed and not of before.
        $this->app->singleton('db.factory', function ($app) {
            return new ConnectionFactory($app);
        });

        // The database manager is used to resolve various connections, since multiple
        // connections might be managed. It also implements the connection resolver
        // interface which may be used by other components requiring connections.
        $this->app->singleton('db', function ($app) {
            return new DatabaseManager($app, $app['db.factory']);
        });
    }
445203
public function register()
    {
        $this->bindConfig();

        $this->app->bind('Nbobtc\Bitcoind\Bitcoind', function($app) {
            $url_pieces = parse_url(Config::get('counterparty-sender.connection_string'));
            $rpc_user = Config::get('counterparty-sender.rpc_user');
            $rpc_password = Config::get('counterparty-sender.rpc_password');

            $connection_string = "{$url_pieces['scheme']}://{$rpc_user}:{$rpc_password}@{$url_pieces['host']}:{$url_pieces['port']}";
            $bitcoin_client = new Client($connection_string);
            $bitcoind = new Bitcoind($bitcoin_client);
            return $bitcoind;
        });

        $this->app->bind('Tokenly\CounterpartySender\CounterpartySender', function($app) {
            $xcpd_client = $app->make('Tokenly\XCPDClient\Client');
            $bitcoind = $app->make('Nbobtc\Bitcoind\Bitcoind');


            $sender = new CounterpartySender($xcpd_client, $bitcoind);
            return $sender;
        });
    }
52430
protected function registerMapperInitializer(Application $app)
    {
        $initializer = function ($mapper, $app) {
            $mapper->setSqlFactory(new SqlFactory);
        };

        $app->initializer('Synapse\Mapper\AbstractMapper', $initializer);
    }
174648
public function registerModules(Application $app)
    {
        foreach ($this->getRegisteredModules() as $module) {
            $module->register($app);
        }

        return $this;
    }
1198597
private function registerAppNamespace()
    {
        // get app namespace
        $namespace = $this->applicationConfig->get('Application.Namespace', false);
        if (!$namespace) {
            throw new BootstrapException('Unable to register application namespace. You must define the application namespace in your App.yaml config file.');
        }

        try{
            // register the namespace
            ClassLoader::getInstance()->registerMap([$namespace => $this->applicationAbsolutePath.'App']);
        }catch (\Exception $e){
            throw new BootstrapException('Unable to register application ('.$namespace.' => '.$this->applicationAbsolutePath.'App'.') namespace with ClassLoader.');
        }

    }
163196
public static function setApplicationConnection(Application $application = null, $connName)
    {
        if (is_null($application)) {
            throw new \InvalidArgumentException('Application instance needed!');
        }

        $helperSet = $application->getHelperSet();

        /** @var ManagerRegistry $doctrine */
        $doctrine = $helperSet->get('doctrine');

        /** @var Connection $connection */
        $connection = $doctrine->getConnection($connName);

        $helperSet->set(new ConnectionHelper($connection), 'db');
    }
811628
public function register()
    {
        if (!defined('ADMINLTETEMPLATE_PATH')) {
            define('ADMINLTETEMPLATE_PATH', realpath(__DIR__.'/../../'));
        }

        if ($this->app->runningInConsole()) {
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\PublishAdminLTE::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\PublishAdminLTEAlt::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\PublishAdminLTESidebar::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\PublishAdminLTESidebarAlt::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\MakeAdminUserSeeder::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\AdminLTEAdmin::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\AdminLTEAdminAlt::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\MakeView::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\AdminLTEMenu::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\AdminLTEMenuAlt::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\MakeRoute::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\MakeMenu::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\MakeV::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\MakeVC::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\MakeMVC::class]);
            $this->commands([\Acacha\AdminLTETemplateLaravel\Console\Username::class]);
        }

        $this->app->bind('AdminLTE', function () {
            return new \Acacha\AdminLTETemplateLaravel\AdminLTE();
        });

        if (config('adminlte.gravatar', true)) {
            $this->registerGravatarServiceProvider();
        }

        if (config('adminlte.guestuser', true)) {
            $this->registerGuestUserProvider();
        }
        if (config('auth.providers.users.field', 'email') === 'username'  &&
            config('adminlte.add_nullable_username', true)) {
            $this->loadMigrationsFrom(ADMINLTETEMPLATE_PATH .'/database/migrations/username_login');
        }
    }
692992
protected function registerAppVersionManager()
    {
        $this->app->singleton(AppVersionManager::class, function (Application $app) {
            $config = (array) $app
                ->make('config')
                ->get(static::getConfigRootKeyName());

            return new AppVersionManager($config);
        });

        $this->app->bind(AppVersionManagerContract::class, AppVersionManager::class);
        $this->app->bind(static::VERSION_MANAGER_ALIAS, AppVersionManagerContract::class);
    }
422366
protected function registerConnectionServices()
    {
        // The connection factory is used to create the actual connection instances on
        // the database. We will inject the factory into the manager so that it may
        // make the connections while they are actually needed and not of before.
        $this->getContainer()->share('db.factory', ConnectionFactory::class);

        // The database manager is used to resolve various connections, since multiple
        // connections might be managed. It also implements the connection resolver
        // interface which may be used by other components requiring connections.
        $this->getContainer()->share('db', DatabaseManager::class)
            ->withArgument(Application::class)
            ->withArgument(ConnectionFactory::class);

        $this->getContainer()->share('db.connection', function () {
            return app('db')->connection();
        });
    }
972075
public function register(Application $App) {
        $App->addCommand(new \YourApp\Command\Foo());
        $App->addCommand(new \YourApp\Command\Bar());
        $App->addCommand(new \YourApp\Command\Baz());
    }