Register repository.

@return void
499961
protected function register()
    {
        // Make comment model for the factory.
        $this->setModel($this->makeUserModel());

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

        // Set columns to the users, after admin init.
        if ($this->methodExist('columns')) {
            $this->registerColumns();
        }
    }
976687
public function register()
    {
        /**
         * Override the binding for data repository contract and implementation
         */
        $this->app->bind(
            \ActualReports\PDFGeneratorAPILaravel\Contracts\DataRepository::class,
            \App\Repositories\DataRepository::class
        );
    }
198716
protected function registerCustomBindings(): void
    {
        $repositoryFactory = $this->app->make(IRepositoryFactory::class);

        foreach (config('laravel_repositories.bindings') as $className => $repository) {
            $repositoryFactory->register($className, $repository);
        }
    }
233583
protected function registerTokenRepository()
    {
        $this->app->singleton('auth.password.tokens', function($app)
        {
            $connection = $app['db']->connection();

            // The database token repository is an implementation of the token repository
            // interface, and is responsible for the actual storing of auth tokens and
            // their e-mail addresses. We will inject this table and hash key to it.
            $table = $app['config']['auth.password.table'];

            $key = $app['config']['app.key'];

            $expire = $app['config']->get('auth.password.expire', 60);

            return new DbRepository($connection, $table, $key, $expire);
        });
    }
593732
public function register()
    {
        $this->mergeConfigFrom(
            __DIR__.'/../config/modules.php', 'modules'
        );

        $this->app->register(ConsoleServiceProvider::class);
        $this->app->register(GeneratorServiceProvider::class);
        $this->app->register(BladeServiceProvider::class);

        $this->app->singleton('modules', function ($app) {
            return new RepositoryManager($app);
        });
    }
687946
public function registerCacheRepository()
    {
        $this->app->singleton('translation.cache.repository', function ($app) {
            $cacheStore = $app['cache']->getStore();
            return CacheRepositoryFactory::make($cacheStore, $app['config']->get('translator.cache.suffix'));
        });
    }
598488
public function register()
    {
        $this->mergeConfig();

        /** @var Repository $config */
        $config = $this->app->make('config');

        $this->registerCoreServices($config);
        $this->registerEntityAuditConfigurations($config);
    }
704331
public function register()
    {
        $adapter = $this->getContainer()->get(AdapterInterface::class);
        $this->getContainer()->share('repo.user', new UsersRepository($adapter));
        $this->getContainer()->share('repo.media', new MediaRepository($adapter));
        $this->getContainer()->share('repo.comment', new CommentsRepository($adapter));
        $this->getContainer()->share('repo.like', new LikesRepository($adapter));
        $this->getContainer()->share('repo.tag', new TagsRepository($adapter));
        $this->getContainer()->share('repo.location', new LocationsRepository($adapter));
    }
621618
public function register()
    {
        $this->registerRevisionRepository();
        $this->registerUserRepository();
        $this->registerGroupRepository();
        $this->registerCredentials();

        $this->registerLoginController();
        $this->registerRegistrationController();
        $this->registerResetController();
        $this->registerActivationController();
    }
1017504
public function register()
    {
        $this->app->singleton(BaseRepository::class, function () {
            return new BaseRepository;
        });

        $this->app->alias(BaseRepository::class, 'baserepository');
    }
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)
                    )
                );
        });
    }
826502
public function register()
    {
        $this->app->bind(self::PIWIK_CONFIG, function () {
            return new FileConfigRepository();
        });

        $this->app->bind('piwik.request', function () {
            $config = $this->app->make(self::PIWIK_CONFIG);

            return new GuzzleRequestRepository($config, new Client());
        });

        $this->app->bind('piwik', function () {
            $config = $this->app->make(self::PIWIK_CONFIG);
            $request = $this->app->make('piwik.request');

            return new Piwik($config, $request);
        });
    }
176140
public function register() {
        $this->loadConfiguration();

        /** Register language repository . */
        $this->app->bind('lang-db-repo', function() {
            return new LanguageRepository(
                new Language()
            );
        });

        /** Register translations repository . */
        $this->app->bind('translations-db-repo', function() {
            return new TranslationsRepository(
                new Translation()
            );
        });

        /** Register driver manager */
        $this->app->bind('driver-translator-manager', function() {
            return (new Manager(
                config('laravel-translator')
            ));
        });

        /** Register translator . */
        $this->app->singleton('laravel-translator', function($app) {
            return new Translator(
                config('laravel-translator'),
                $app['driver-translator-manager']
            );
        });
    }
949143
public function register()
    {
        // $this->configPath = config_path('laramin.php');
        $this->publishablePath = $this->getPublishablePath();
        $this->registerConsoleCommands();

        // $this->mergeConfigFrom($this->configPath, 'Laramin');
        $this->registerConfigs();
        $loader = AliasLoader::getInstance();
        $loader->alias('Laramin', LaraminFacade::class);

        $this->app->singleton('laramin', function ($app) {
            return new Laramin();
        });
        if ($this->app->runningInConsole()) {
            $this->registerPublishableResources();
        }
    }
1323438
protected function register()
    {
        return function () {
            foreach ($this->repository as $field) {
                register_meta('term', $field->getName(), [
                    'type' => $field->getOption('data_type', 'string'),
                    'single' => ! $field->getOption('multiple', false),
                    'show_in_rest' => $field->getOption('show_in_rest', false),
                    'sanitize_callback' => $this->sanitize($field)
                ]);
            }
        };
    }
561546
public function register()
    {
        $this->registerConfigurationMapper();
        $this->registerCacheManager();
        $this->registerEntityManager();
        $this->registerClassMetadataFactory();
        $this->registerValidationVerifier();

        $this->commands([
            'Mitch\LaravelDoctrine\Console\GenerateProxiesCommand',
            'Mitch\LaravelDoctrine\Console\SchemaCreateCommand',
            'Mitch\LaravelDoctrine\Console\SchemaUpdateCommand',
            'Mitch\LaravelDoctrine\Console\SchemaDropCommand'
        ]);
    }
9101
public function register() {
        $configPath = __DIR__ . '/../config/backup-manager.php';
        $this->mergeConfigFrom($configPath, 'backup-manager');
        $this->registerFilesystemProvider();
        $this->registerDatabaseProvider();
        $this->registerCompressorProvider();
        $this->registerShellProcessor();
        $this->registerArtisanCommands();
    }