Register the Tradeability class.

@return void
964649
protected function registerShipping()
    {
        $this->app->singleton('ups.shipping', function (Container $app) {
            $config = $app->config->get('ups');

            return new Shipping(
                $config['access_key'],
                $config['user_id'],
                $config['password'],
                $config['sandbox'],
                null,
                $app->make('log')
            );
        });
    }
696730
protected function register()
    {
        // Make comment model for the factory.
        $this->setModel($this->makeCommentModel());

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

        // Set columns to the comment, after admin init.
        if ($this->methodExist('columns')) {
            $this->registerColumns();
        }
    }
889996
public function register()
    {

        $this->app->afterResolving(Form::class, function (Form $form) {
            $this->forwardLegacyEvents($form);
        });

        Form::provideValidationBroker(function(Form $form) {

            $broker = new AutoValidatorBroker(new ValidatorFactory());
            $broker->setForm($form);

            $broker->onAfter('setValidator', function ($validator) use ($form) {
                $formName = $form->getName();
                $this->app['events']->fire("form.validator-setted.$formName", [$validator]);
            });
            return $broker;

        });

        Form::provideRequestProvider(function(){
            return $this->getRequestProvider();
        });


        Form::provideUrlProvider(function(){
            return $this->getActionUrlProvider();
        });

        Form::provideRenderer(function(){
            return $this->getRenderer();
        });

        Form::provideAdditionalNamer(function($chain){
            $chain->append($this->getTranslationNamer());
        });

        Form::onRendererChanged(function ($renderer) {
            $this->app['events']->fire('form.renderer-changed', [$renderer]);
            $this->addFormPaths($renderer);
        });

        $this->app->alias('formobject.factory', 'FormObject\Factory');

        $this->app->singleton('formobject.factory', function($app){
            $factory = Form::getFactory();
            $factory->createFieldsWith(function($class) {
                return $this->app->make($class);
            });
            return $factory;
        });

        $this->app->afterResolving('XType\Casting\Contracts\InputCaster', function($caster) {
            $this->registerInputCasters($caster);
        });


    }
198716
protected function registerCustomBindings(): void
    {
        $repositoryFactory = $this->app->make(IRepositoryFactory::class);

        foreach (config('laravel_repositories.bindings') as $className => $repository) {
            $repositoryFactory->register($className, $repository);
        }
    }
920608
public function register() : void
    {
        if ($this->getConfigParam('env') == 'prod') {
            ini_set('display_errors', 'Off');
        } else {
            ini_set('display_errors', 'On');
        }
        error_reporting(E_ALL);
        set_error_handler([$this, 'handleError']);
        set_exception_handler([$this, 'handleException']);
    }
860068
public function register ()
    {
        $callback = array($this, 'display');
        foreach ($this->screens as $screen) {
            $id       = $this->getPropertyForScreen($screen, $this->id);
            $title    = $this->getPropertyForScreen($screen, $this->title);
            $context  = $this->getPropertyForScreen($screen, $this->context);
            $priority = $this->getPropertyForScreen($screen, $this->priority);
            add_meta_box($id, $title, $callback, $screen, $context, $priority);
        }
    }
240533
public function register() {
        $this->commands([
            'Synga\PhpStormMeta\Laravel\Command\ExcludeCommand',
            'Synga\PhpStormMeta\Laravel\Command\IncludeCommand',
            'Synga\PhpStormMeta\Laravel\Command\GenerateCommand',
        ]);

        $this->app->singleton('Synga\InheritanceFinder\InheritanceFinderInterface', function(){
            if(!file_exists(storage_path('class_cache'))){
                mkdir(storage_path('class_cache'));
            }

            $config = new \Synga\InheritanceFinder\File\FileConfig();

            $config->setApplicationRoot(base_path());
            $config->setCacheDirectory(storage_path('class_cache'));

            return InheritanceFinderFactory::getInheritanceFinder($config);
        });
    }
1210162
protected function registerContracts(): void
    {
        $this->app->bind(BanContract::class, Ban::class);
        $this->app->singleton(BanServiceContract::class, BanService::class);
    }
621048
public function register()
    {
        $tokens = array();
        foreach ($this->newTypeCasts as $token => $versions) {
            if (\defined($token)) {
                $tokens[] = constant($token);
            }
        }

        /*
         * Work around tokenizer issues.
         *
         * - (binary) cast is incorrectly tokenized as T_STRING_CAST by PHP and PHPCS.
         * - b"something" binary cast is incorrectly tokenized as T_CONSTANT_ENCAPSED_STRING by PHP and PHPCS.
         * - Since PHPCS 3.4.0, PHPCS *will* tokenize these correctly.
         *
         * @link https://github.com/squizlabs/PHP_CodeSniffer/issues/1574
         */
        if (version_compare(PHPCSHelper::getVersion(), '3.4.0', '<') === true) {
            $tokens[] = \T_STRING_CAST;
            $tokens[] = \T_CONSTANT_ENCAPSED_STRING;
        }

        return $tokens;
    }
950447
public function register()
    {
        // Set convention to use
        $this->app->bind(
                Convention::class,
                $this->resolveConventionClass(
                    $this->app->config->get('concord.convention', 'default')
                )
        );

        // Register interface -> actual class binding as singleton
        // For the sake of flexibility it's possible to replace
        // the actual class by setting `class` in the config
        $this->app->singleton(
            ConcordContract::class,
            $this->app->config->get('concord.class', Concord::class)
        );

        // Make an instance
        $concordInstance = $this->app->make(ConcordContract::class);
        // And make it available as the 'concord' service
        $this->app->instance('concord', $concordInstance);

        $this->registerCommands();

        $modules = config("concord.modules") ?: [];

        foreach ($modules as $key => $value) {
            $module = is_string($key) ? $key : $value;
            $config = is_array($value) ? $value : [];
            $concordInstance->registerModule($module, $config);
        }
    }
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,
            ]
        );
    }
419968
public function register()
    {
        $this->mergeConfigFrom(__DIR__.'/../config/tracy.php', 'tracy');

        $config = Arr::get($this->app['config'], 'tracy');

        if (Arr::get($config, 'panels.terminal') === true) {
            $this->app->register(TerminalServiceProvider::class);
        }

        $this->app->singleton(BlueScreen::class, function () {
            return Debugger::getBlueScreen();
        });

        $this->app->singleton(Bar::class, function ($app) use ($config) {
            return (new BarManager(Debugger::getBar(), $app['request'], $app))
                ->loadPanels(Arr::get($config, 'panels', []))
                ->getBar();
        });

        $this->app->singleton(DebuggerManager::class, function ($app) use ($config) {
            return (new DebuggerManager(
                DebuggerManager::init($config),
                $app[Bar::class],
                $app[BlueScreen::class],
                new Session
            ))->setUrlGenerator($app['url']);
        });
    }
605425
public function register()
    {
        $this->app->bind(ViewTrackerRepositoryContract::class, function () {
            $repository = new ViewTrackerRepository(new ViewTracker());

            if (config('webed-caching.repository.enabled')) {
                return new ViewTrackerRepositoryCacheDecorator($repository);
            }

            return $repository;
        });
    }
424525
public function register()
    {
        $this->app->singleton(Dispatcher::class, function (Container $app) {
            return new Dispatcher($app, function ($connection = null) use ($app) {
                return $app->make(Factory::class)->connection($connection);
            });
        });

        $this->app->alias(Dispatcher::class, DispatcherContract::class);
        $this->app->alias(Dispatcher::class, QueueingDispatcherContract::class);
    }
1083579
public function register()
    {
        $this->registerConfig();
        $this->app->bind('Joselfonseca\LaravelTactician\Locator\LocatorInterface', config('laravel-tactician.locator'));
        $this->app->bind('League\Tactician\Handler\MethodNameInflector\MethodNameInflector', config('laravel-tactician.inflector'));
        $this->app->bind('League\Tactician\Handler\CommandNameExtractor\CommandNameExtractor', config('laravel-tactician.extractor'));
        $this->app->bind('Joselfonseca\LaravelTactician\CommandBusInterface', config('laravel-tactician.bus'));

        // Register Command Generator
        $this->app->singleton(
            'laravel-tactician.make.command', function ($app) {
                return new MakeTacticianCommandCommand($app['files']);
            }
        );
        $this->commands('laravel-tactician.make.command');

        // Register Handler Generator
        $this->app->singleton(
            'laravel-tactician.make.handler', function ($app) {
                return new MakeTacticianHandlerCommand($app['files']);
            }
        );
        $this->commands('laravel-tactician.make.handler');

        // Register Comman+Handler Generator Command
        $this->app->singleton(
            'laravel-tactician.make.tactician', function () {
                return new MakeTacticianCommand();
            }
        );
        $this->commands('laravel-tactician.make.tactician');
    }
1261109
public function register()
    {
        // Handle case-insensitivity of interface names.
        $this->internalInterfaces = $this->arrayKeysToLowercase($this->internalInterfaces);

        $targets = array(\T_CLASS);

        if (\defined('T_ANON_CLASS')) {
            $targets[] = \T_ANON_CLASS;
        }

        return $targets;
    }
188110
public function register()
    {

        if ('LaravelCommode\Common\CommodeCommonServiceProvider' !== get_class($this)) {
            /**
             * Prepare service
             */
            $this->prepareService();

            /**
             * Bind app's 'booting' event resolving, aliases and launching methods
             */
            $this->app->booting($this->getResolver()->makeClosure(function () {

                if (count($this->aliases) > 0) {
                    $loader = AliasLoader::getInstance();

                    foreach ($this->aliases as $facadeName => $facadeClass) {
                        $loader->alias($facadeName, $facadeClass);
                    }
                }

                $this->launchClosure();
            }));

        }

        /**
         * Register service
         */
        $this->registering();
    }