Register the commands.

@return void
553005
protected function registerCommands()
    {
        ensure_trait_used_in_subclass_of_or_fail(self::class, $this, ServiceProvider::class);

        foreach (array_keys($this->commands) as $command) {
            $method = "register{$command}Command";
            call_user_func_array([$this, $method], []);
        }
        $this->commands(array_values($this->commands));
    }
108268
public function registerCommands()
    {
        $commands = (array) $this->get('console.commands');

        foreach ($commands as $command) {
            if ($command === false) {
                continue;
            }

            if (is_string($command)) {
                $command = $this->container->createObject($command);
            }

            $this->addCommand($command);
        }
    }
691086
public function registerCommands()
	{
		$this->app->singleton('command.cache.clear', function($app)
		{
			return new ClearCommand($app['cache']);
		});

		$this->app->singleton('command.cache.table', function($app)
		{
			return new CacheTableCommand($app['files'], $app['composer']);
		});

		$this->commands('command.cache.clear', 'command.cache.table');
	}
590251
private function registerCommand()
    {
        $this->app->singleton('command.lada-cache.flush', function() {
            return new FlushCommand();
        });

        $this->app->singleton('command.lada-cache.enable', function() {
            return new EnableCommand();
        });

        $this->app->singleton('command.lada-cache.disable', function() {
            return new DisableCommand();
        });

        $this->commands([
            'command.lada-cache.flush',
            'command.lada-cache.enable',
            'command.lada-cache.disable',
        ]);
    }
724318
public function registerCommands() : void {
		// Register a command for basset
		$this->app->singleton('command.basset', function($app) {
			return new BuildCommand($app['basset'], $app['basset.builder'], $app['basset.builder.cleaner']);
		});

		$this->commands('command.basset');
	}
445998
public function register(): void
    {
        $this->app->register(EventServiceProvider::class);

        $this->commands([
            InstallCommand::class
        ]);

        $this->registerBindings();
    }
300650
public function register()
    {
        $this->commands([
            Commands\SetEnv::class,
            Commands\GetEnv::class,
            Commands\DeleteEnv::class,
            Commands\ListEnv::class,
        ]);
    }
334091
protected function registerCommands()
    {
        $this->app->bind('command.log-reader.delete', 'Jackiedo\LogReader\Console\Commands\LogReaderDeleteCommand');
        $this->app->bind('command.log-reader.detail', 'Jackiedo\LogReader\Console\Commands\LogReaderDetailCommand');
        $this->app->bind('command.log-reader.file-list', 'Jackiedo\LogReader\Console\Commands\LogReaderFileListCommand');
        $this->app->bind('command.log-reader.get', 'Jackiedo\LogReader\Console\Commands\LogReaderGetCommand');
        $this->app->bind('command.log-reader.remove-file', 'Jackiedo\LogReader\Console\Commands\LogReaderRemoveFileCommand');

        $this->commands('command.log-reader.delete');
        $this->commands('command.log-reader.detail');
        $this->commands('command.log-reader.file-list');
        $this->commands('command.log-reader.get');
        $this->commands('command.log-reader.remove-file');
    }
33783
protected function registerCommand()
    {
        $this->app->singleton(
            'command.laroute.generate',
            function ($app) {
                $config     = $app['config'];
                $routes     = new Routes($app['router']->getRoutes(), $config->get('laroute.filter', 'all'), $config->get('laroute.action_namespace', ''));
                $generator  = $app->make('Lord\Laroute\Generators\GeneratorInterface');

                return new LarouteGeneratorCommand($config, $routes, $generator);
            }
        );

        $this->commands('command.laroute.generate');
    }
961282
public function registerCommands()
    {
        $this->app->bind('mediasort.fasten', function ($app) {
            return new Commands\FastenCommand(
                $app['view'], $app['files']
            );
        });

        // TODO: Get this working
        //$this->app->bind('mediasort.refresh', function ($app) {
        //    return new Commands\RefreshCommand(
        //        new Services\ImageRefreshService()
        //    );
        //});

        $this->commands([
            'mediasort.fasten',
            //'mediasort.refresh',
        ]);
    }
1222032
public function registerCommands()
	{
		$this->app['foruminstallcommand'] = $this->app->share(function($app)
        {
            return new InstallCommand;
        });
		$this->commands('foruminstallcommand');
	}
1109415
private function registerCommands()
    {
        //scheduled:summary
        $this->app->bindShared('command.scheduled.summary', function (Application $app) {
            return $app->make('Indatus\Dispatcher\Commands\ScheduleSummary');
        });

        //scheduled:make
        $this->app->bindShared('command.scheduled.make', function (Application $app) {
            return $app->make('Indatus\Dispatcher\Commands\Make');
        });

        //scheduled:run
        $this->app->bindShared('command.scheduled.run', function (Application $app) {
            return $app->make('Indatus\Dispatcher\Commands\Run');
        });

        $this->commands($this->provides());
    }
876648
public function register()
    {
        $this->commands([
            \WebEd\Base\Console\Commands\InstallCmsCommand::class,
            \WebEd\Base\Console\Commands\UpdateCmsCommand::class,
        ]);
    }
856381
protected function registerCommands(array $commands)
    {
        foreach ($commands as $command) {
            if ( ! $command instanceof SymfonyCommand) {
                $command = $this->container[$command];
            }

            $this->container['console']->add($command);
        }
    }
327657
public function register()
    {
        $this->commands([
            Commands\DeployCommand::class,
            Commands\ListCommand::class,
            Commands\RollbackCommand::class,
            Commands\SyncCommand::class,
        ]);
    }
944137
protected function registerCommands()
    {
        $this->app->singleton('cms.commands.models.cache-information', Commands\CacheModelInformation::class);
        $this->app->singleton('cms.commands.models.clear-information-cache', Commands\ClearModelInformationCache::class);
        $this->app->singleton('cms.commands.models.show-information', Commands\ShowModelInformation::class);
        $this->app->singleton('cms.commands.models.write-information', Commands\WriteModelInformation::class);

        $this->commands([
            'cms.commands.models.cache-information',
            'cms.commands.models.clear-information-cache',
            'cms.commands.models.show-information',
            'cms.commands.models.write-information',
        ]);

        return $this;
    }
170236
protected function registerCommands()
    {
        if ($this->app->runningInConsole()) {
            $this->commands([
                Console\InstallCommand::class,
                Console\AssetsCommand::class,
                Console\HorizonCommand::class,
                Console\ListCommand::class,
                Console\PurgeCommand::class,
                Console\PauseCommand::class,
                Console\ContinueCommand::class,
                Console\StatusCommand::class,
                Console\SupervisorCommand::class,
                Console\SupervisorsCommand::class,
                Console\TerminateCommand::class,
                Console\TimeoutCommand::class,
                Console\WorkCommand::class,
            ]);
        }

        $this->commands([Console\SnapshotCommand::class]);
    }