Dispatch repository.

@return void
515599
protected function register()
    {
        // Setup taxonomy relationships.
        $this->relation();

        // Make taxonomy model for the factory.
        $this->setModel($this->makeTaxonomyModel());

        // Build taxonomy with model and singularity holders.
        $this->setSingularity($this->makeTaxonomyInstance());

        // Set fields to the taxonomy.
        if ($this->methodExist('fields')) {
            $this->registerFields();
        }

        // Set columns to the taxonomy, after admin init.
        if ($this->methodExist('columns')) {
            $this->registerColumns();
        }
    }
343038
public function dispatch()
    {
        return $this->execute($this->getActionAlias('dispatch'), [
            $this->getSlug(),
            $this->getCallback(),
            $this->getArgument('piority'),
            $this->getArgument('numberOfArguments'),
        ]);
    }
189745
protected function registerRepository()
    {
        $this->app->singleton('neoeloquent.migration.repository', function($app)
        {
            $model = new MigrationModel;

            $label = $app['config']['database.migrations_node'];

            if (isset($label)) {
                $model->setLabel($label);
            }

            return new DatabaseMigrationRepository(
                $app['db'],
                $app['db']->connection('neo4j')->getSchemaBuilder(),
                $model
            );
        });
    }
1372230
protected function registerCouchbaseBucketCacheDriver(): void
    {
        $this->app['cache']->extend('couchbase', function ($app, $config) {
            /** @var \Couchbase\Cluster $cluster */
            $cluster = $app['db']->connection($config['driver'])->getCouchbase();
            $password = (isset($config['bucket_password'])) ? $config['bucket_password'] : '';

            return new Repository(
                new CouchbaseStore(
                    $cluster,
                    $config['bucket'],
                    $password,
                    $app['config']->get('cache.prefix')
                )
            );
        });
    }
1250528
public function run()
    {
        $resolvedRequest = $this->router->route($this->request);
        echo $this->dispatcher->dispatch($resolvedRequest);
    }
569200
public function register()
    {
        $this->app->singleton(DispatcherInterface::class, function ($app) {
            return new Dispatcher($this->mappings, $app);
        });
    }
445555
public function dispatch()
    {
        $this->manager->dispatchTemplate();

        if ($this->hasChildren()) {
            $this->getChildren()
                ->setParent($this)
                ->boostSchemaWithValues($this->getValue());

            if ($this->isTypeOf('repeatable') && empty($this->getValue())) {
                $this->dispatchSchema();
            }
        }
    }
891417
protected function registerRepository()
    {
        $this->app->singleton(
            'mongolid.migration.repository',
            function ($app) {
                $collection = $app['config']['database.mongodb.default.migrations'] ?? 'migrations';

                return new MongolidMigrationRepository($app[Pool::class], $collection);
            }
        );
    }
1249297
protected function registerServices()
    {
        $this->app->bindShared('modules', function ($app) {
            $path = $app['config']->get('modules.paths.modules');

            return new Repository($app, $path);
        });
    }
1039252
protected function registerConfigBindings()
    {
        $loader = new FileLoader(new Filesystem(), $this->resourcePath('config'));

        $this->singleton('config', function () use ($loader) {
            return new Repository($loader, $this->environment());
        });
    }
402798
private function callRepository()
    {
        // check the config
        if (config('generators.settings.controller.repository_contract')) {
            if ($this->confirm("Create a reposity and contract for the $this->resource resource?")) {
                $name = $this->getModelName();

                $this->repositoryContract = true;

                $this->callCommandFile('contract', $name);
                $this->callCommandFile('repository', $name);

                //$contract = $name . config('generators.settings.contract.postfix');
                //$this->callCommandFile('repository', $name, ['--contract' => $contract]);
            }
        }
    }
723170
public function execute() {
        global $CFG;
        require_once($CFG->dirroot . '/repository/lib.php');

        $instances = \repository::get_instances(['type' => 'dropbox']);
        foreach ($instances as $instance) {
            $instance->cron();
        }
    }
995479
public function handle()
    {
        $repository_generator = new \CroudTech\Repositories\RepositoryGenerator($this->argument('model-name'), $this->argument('repository-name'));

        try {
            if ($repository_generator->generateRepository()) {
                $this->info(sprintf('Generated %s repository', $repository_generator->getFullRepositoryPath()));
                $this->info(sprintf('Using %s contract', $repository_generator->getFullContractPath()));
            } else {
                $this->error('Repository generation failed.');
            }
        } catch (\Exception $e) {
            $this->error('There was an error when generating the repository. Please check your error log.');
            \Illuminate\Support\Facades\Log::error($e);
        }
    }
1090955
public function dispatch()
    {
        Eresus_Kernel::log(__METHOD__, LOG_DEBUG, 'starting...');
        /** @var TClientUI $page */
        $page = $this->getPage();
        $response = $page->render($this->getRequest());

        Eresus_Kernel::log(__METHOD__, LOG_DEBUG, 'done');
        return $response;
    }
1226985
public function boot()
    {
        Cache::extend('redis', function ($app, $config) {
            $store = new RedisStore(
                $app['redis'],
                Arr::get($config, 'prefix', $this->app['config']['cache.prefix']),
                Arr::get($config, 'connection', 'default')
            );

            $repository = new Repository($store);

            if ($app->bound('Illuminate\Contracts\Events\Dispatcher')) {
                $repository->setEventDispatcher(
                    $app['Illuminate\Contracts\Events\Dispatcher']
                );
            }

            return $repository;
        });
    }
83181
public function dispatch(): void
    {
        $dispatcher = new Dispatcher();

        if ($this->connector) {
            $dispatcher->add($this->listenConnector());
        }

        if ($this->exchangeWorkersData) {
            $dispatcher->add($this->listenWorkers());
        }

        $dispatcher->dispatch();
    }
1209160
protected function registerRepository()
	{
		$this->app->singleton('migration.orient.repository', function($app)
		{
			$table = $app['config']['database.migrations'];
                        $db = $app->make("ConnectionResolverInterface");

			return new DatabaseMigrationRepository($db, $table);
		});
	}