Register bindings in the container.
188097
public function register()
    {
        $this->setConfigPath();
        $this->assertConfigDir();

        $mikado = new Mikado();

        foreach (new DirectoryIterator($this->configPath) as $fileInfo) {
            if ($fileInfo->isDot()) {
                continue;
            }
            $this->addManager($fileInfo, $mikado);
        }

        $this->app->singleton('kriskbx\mikado\Mikado', function ($app) use ($mikado) {
            return $mikado;
        });
    }
48792
public static function register()
	{
		Container::extensionMethod("addTags", function (Container $container, $name, $label = NULL) {
			return $container[$name] = new TagControl($label);
		});
	}
748286
protected function registerRouteBindings()
    {
        Routes\Admin\PagesRoutes::bindings();
        Routes\Admin\FootersRoutes::bindings();
        Routes\Admin\MetasRoutes::bindings();
        Routes\Admin\RedirectsRoutes::bindings();
    }
448878
protected function registerBaseBindings()
    {
        static::setInstance($this);

        $this->instance('app', $this);
        $this->instance('Nano7\Application', $this);
        $this->instance('Illuminate\Contracts\Container\Container', $this);
    }
248255
private void register() {
        this.yamlConstructors.put(Tag.MAP, mapConstruct());
        this.yamlConstructors.put(Tag.OMAP, omapConstruct());
        this.yamlConstructors.put(Tag.PAIRS, pairsConstruct());
        this.yamlConstructors.put(Tag.SEQ, seqConstruct());
        this.yamlConstructors.put(Tag.SET, setConstruct());
        this.yamlConstructors.put(Tag.BINARY, binaryConstruct());
        this.yamlConstructors.put(Tag.BOOL, boolConstruct());
        this.yamlConstructors.put(Tag.FLOAT, floatConstruct());
        this.yamlConstructors.put(Tag.INT, intConstruct());
        this.yamlConstructors.put(Tag.NULL, nullConstruct());
        this.yamlConstructors.put(Tag.STR, strConstruct());
        this.yamlConstructors.put(Tag.TIMESTAMP, timestampConstruct());
    }
595365
function register() {
    ko.extenders['searchArray'] = searchArrayExtension;
    ko.components.register('grid', {
        template: template,
        viewModel: viewModel
    });
}
34076
private function applyBindings()
    {
        foreach ($this->bindings as $abstract => $binding) {
            list($concrete, $shared) = $binding;

            $this->app->bind($abstract, $concrete, $shared);
        }
    }
1210162
protected function registerContracts(): void
    {
        $this->app->bind(BanContract::class, Ban::class);
        $this->app->singleton(BanServiceContract::class, BanService::class);
    }
1146006
protected function registerServices()
    {
        $this->app->bind(
            'Xuma\Amaran\ViewBinder',
            'Xuma\Amaran\AmaranViewBinder'
        );

        $this->app->singleton('amaran', function($app) {
            $binder = new AmaranViewBinder($app['events']);

            return $this->app->make('Xuma\Amaran\AmaranHandler');
        });
    }
1261471
def bind(cls, app, *paths, methods=None, name=None, view=None):
        """"""
        # Register self in admin
        if view is None:
            app.ps.admin.register(cls)
            if not paths:
                paths = ('%s/%s' % (app.ps.admin.cfg.prefix, name or cls.name),)
            cls.url = paths[0]
        return super(AdminHandler, cls).bind(app, *paths, methods=methods, name=name, view=view)
770096
protected function registerBindings()
    {
        $this->app->singleton('assetLoader', 'Monarkee\Bumble\Repositories\FieldAssetRepository');

        $this->app->singleton('bumblestr', function ()
        {
            return $this->app->make('Monarkee\Bumble\Support\BumbleStr');
        });

        $this->app->singleton('bumble-gravatar', function ()
        {
            return $this->app->make('Monarkee\Bumble\Support\Gravatar');
        });

        $this->app->bind('Monarkee\Bumble\Repositories\ModelRepository', 'Monarkee\Bumble\Repositories\ArrayConfigModelRepository');
    }
1150386
public function register()
    {
        $this->registerBindingsServiceProviderMakeCommand();
        $this->registerMakeCommand();
        $this->registerRepositoryInterfaceMakeCommand();
        $this->registerServiceMakeCommand();
        $this->registerTraitMakeCommand();
    }
43387
private void registerOperations() {
    Class<?> type = getClass();
    for (Method method : type.getMethods()) {
      if (isOperationMethod(method)) {
        registerMethod(method);
      }
    }
  }
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();
        }
    }
1268102
public function register()
    {
        $this->config = $this->app->make('config');
        $this->packages = $this->config->get('domains.user-binding');

        $files = \File::allFiles(config_path('domains'));

        foreach ($files as $file) {
            if ($bindings = $this->config->get('domains.'.basename($file->getFilename(), '.php'))) {
                if (array_has($bindings, 'providers')) {
                    $this->provideService(array_get($bindings, 'providers'));
                }

                if (array_has($bindings, 'repositories')) {
                    $this->provideRepositories(array_get($bindings, 'repositories'));
                }

                if (array_has($bindings, 'eloquent_repositories')) {
                    $this->provideEloquentRepositories(array_get($bindings, 'eloquent_repositories'));
                }
            }
        }

        if ($this->app->runningInConsole()) {
            $this->commands([
                GenerateDomain::class,
            ]);
        }
    }
366564
protected function registerBaseBindings()
    {
        static::setInstance($this);

        $this->instance('app', $this);

        $this->instance(Container::class, $this);

        $this->instance(PackageManifest::class, new PackageManifest(
            new Filesystem, $this->basePath(), $this->getCachedPackagesPath()
        ));
    }
1321762
protected function registerContracts()
    {
        $this->app->bind(LikeContract::class, Like::class);
        $this->app->bind(LikeCounterContract::class, LikeCounter::class);
        $this->app->singleton(LikeableServiceContract::class, LikeableService::class);
    }