Register the transformer class.

@return void
976237
protected function registerTransformer()
    {
        $this->app->singleton('throttle.transformer', function () {
            return new TransformerFactory();
        });

        $this->app->alias('throttle.transformer', TransformerFactory::class);
        $this->app->alias('throttle.transformer', TransformerFactoryInterface::class);
    }
1078169
public function register()
    {
        $this->app->singleton(
            'datatables.fractal', function () {
                $fractal = new Manager;
                $config  = $this->app['config'];
                $request = $this->app['request'];

                $includesKey = $config->get('datatables-fractal.includes', 'include');
                if ($request->get($includesKey)) {
                    $fractal->parseIncludes($request->get($includesKey));
                }

                $serializer = $config->get('datatables-fractal.serializer', DataArraySerializer::class);
                $fractal->setSerializer(new $serializer);

                return $fractal;
            }
        );

        $this->app->singleton(
            'datatables.transformer', function () {
                return new FractalTransformer($this->app->make('datatables.fractal'));
            }
        );

        $this->commands(
            [
                TransformerMakeCommand::class,
            ]
        );
    }
498400
protected function registerMacro()
    {
        DataTableAbstract::macro(
            'setTransformer', function ($transformer) {
                $this->transformer = [$transformer];

                return $this;
            }
        );

        DataTableAbstract::macro(
            'addTransformer', function ($transformer) {
                $this->transformer[] = $transformer;

                return $this;
            }
        );

        DataTableAbstract::macro(
            'setSerializer', function ($serializer) {
                $this->serializer = $serializer;

                return $this;
            }
        );
    }
1290693
private function registerProviders(): void
    {
        $this->providers = array_merge($this->providers, $this->getConfigProviders());

        foreach ($this->providers as $provider) {
            $provider = $this->container->get($provider);
            $provider->boot();
        }
    }
954893
protected function registerMenuGenerator()
    {
        $this->app->bind('menu', function ($app) {

            $this->loadConfigurationOptions();

            $menu = new MenuGenerator(
                $app['url'],
                $app['config'],
                $this->getTheme()
            );

            if ($this->options['control_access']) {
                $menu->setAccessHandler($app[AccessHandler::class]);
            }

            if ($this->options['translate_texts']) {
                $menu->setLang($app['translator']);
            }

            return $menu;
        });
    }
491361
protected function registerFormHelper()
    {
        $this->app->singleton('laravel-form-helper', function ($app) {

            $configuration = $app['config']->get('laravel-form-builder');

            return new FormHelper($app['view'], $app['translator'], $configuration);
        });

        $this->app->alias('laravel-form-helper', 'Kris\LaravelFormBuilder\FormHelper');
    }
701731
public function boot()
    {
        $this->publishes([
            dirname(dirname(__DIR__)).'/config/repositories.php' => config_path('repositories.php'),
        ]);

        foreach (config('repositories.repositories', []) as $respository_contract => $repository) {
            $this->app->bind($respository_contract, $repository);
        }

        foreach (config('repositories.repository_transformers', []) as $transformer_contract => $transformer) {
            $this->app->bind($transformer, $transformer);
        }

        foreach (config('repositories.repository_transformers', []) as $repository_class => $transformer) {
            $this->app->when($repository_class)
                ->needs(TransformerContract::class)
                ->give(function () use ($transformer) {
                    return $this->app->make($transformer);
                });
        }

        foreach (config('repositories.contextual_repositories', []) as $controller => $repository) {
            $this->app->when($controller)
              ->needs(RepositoryContract::class)
              ->give($repository);
        }

        $this->commands([
            \CroudTech\Repositories\Console\Commands\CreateRepository::class,
        ]);
    }
230676
public function register()
    {
        $this->registerLoader();

        $this->app->singleton('translator', function ($app) {

            $loader = $app['translation.loader'];

            // When registering the translator component, we'll need to set the default
            // locale as well as the fallback locale.
            $locale = TransHelper::getLanguage();

            $trans = new \Netcore\Translator\Translator($loader, $locale);

            $trans->setFallback($app['config']['app.fallback_locale']);

            return $trans;
        });

        // Views
        $viewNamespace = 'translations';
        $this->loadViewsFrom(__DIR__.'/views', $viewNamespace);

        // Default config
        $this->mergeConfigFrom(
            __DIR__.'/config/translations.php',
            'translations'
        );

        // Publish config to override defaults
        $this->publishes([
            __DIR__.'/config/translations.php' => config_path('translations.php'),
        ], 'config');

        // Migrations
        $this->loadMigrationsFrom(__DIR__.'/migrations');

        // View composers
        view()->composer($viewNamespace.'::*', function(View $view) use ($viewNamespace) {
            $view->with(compact('viewNamespace'));
        });

        view()->composer($viewNamespace.'::languages.*', function(View $view) {
            $uiTranslations = config('translations.ui_translations.languages', []);
            $view->with(compact('uiTranslations'));
        });

        view()->composer($viewNamespace.'::translations.*', function(View $view) {
            $uiTranslations = config('translations.ui_translations.translations', []);
            $view->with(compact('uiTranslations'));
        });

        view()->composer($viewNamespace.'::partials.*', function(View $view) {
            $uiTranslations = config('translations.ui_translations.partials', []);
            $view->with(compact('uiTranslations'));
        });

        // Commands
        $this->commands([
            DownloadTranslations::class
        ]);

        Blade::directive('lg', function ($expression) {
            return "<?php echo lg($expression); ?>";
        });

        // Global helpers
        require_once __DIR__ . '/Helpers/Global.php';
    }
139346
protected function registerCompiler()
    {
        $this->app->singleton('markdown.compiler', function (Container $app) {
            $markdown = $app['markdown'];
            $files = $app['files'];
            $storagePath = $app->config->get('view.compiled');

            return new MarkdownCompiler($markdown, $files, $storagePath);
        });

        $this->app->alias('markdown.compiler', MarkdownCompiler::class);
    }
913624
public function register()
    {
        $this->mergeConfigFrom(__DIR__ . '/../config/laravel-ffmpeg.php', 'laravel-ffmpeg');

        $this->app->singleton('laravel-ffmpeg', function ($app) {
            return $app->make(FFMpeg::class);
        });
    }
374483
public function register()
    {
        $this->registerAliases();

        $this->registerJWTProvider();
        $this->registerAuthProvider();
        $this->registerStorageProvider();
        $this->registerJWTBlacklist();

        $this->registerManager();
        $this->registerTokenParser();

        $this->registerJWT();
        $this->registerJWTAuth();
        $this->registerPayloadValidator();
        $this->registerClaimFactory();
        $this->registerPayloadFactory();
        $this->registerJWTCommand();

        $this->commands('tymon.jwt.secret');
    }
787165
static public function registerTransformation(iTransformation $transformation) {
        self::$transformations[$transformation->getName()] = get_class($transformation);

        print_r(self::$transformations);
    }
1226068
public void registerTransformer(Class<?> keyClass, Class<? extends Transformer> transformerClass) {
      transformerTypes.put(keyClass, transformerClass);
   }
719727
public function register()
	{
		$this->app['dispatcher'] = function($app)
		{
			$dispatcher = new Dispatcher();

			if ($app['config'] instanceof Repository)
			{
				if ($app['config']->get('debug'))
				{
					$dispatcher = new TraceableDispatcher($dispatcher);
				}
			}

			return $dispatcher;
		};
	}
1032755
public function register()
    {
        $this->registerLoader();

        $this->app->singleton('webklex.translator', function ($app) {
            return new Translator($app['webklex.translator.loader'], $app->getLocale());
        });
    }
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'
        ]);
    }
1148148
public function register()
    {
        $loader = \Illuminate\Foundation\AliasLoader::getInstance();
        // Register the alias.
        $loader->alias('Identicon', \Identicon\Identicon::class);
    }