Register the aliases from this module.
505843
protected function registerAliases()
    {
        $loader = AliasLoader::getInstance();
        foreach ($this->get('aliases', []) as $aliasName => $aliasClass) {
            $loader->alias($aliasName, $aliasClass);
        }
    }
53324
protected function registerAliases()
    {
        $this->app->alias('afroware.jwT', JwT::class);
        $this->app->alias('afroware.jwT.auth', JwTauth::class);
        $this->app->alias('afroware.jwT.provider.jwT', JwTContract::class);
        $this->app->alias('afroware.jwT.provider.auth', Auth::class);
        $this->app->alias('afroware.jwT.provider.storage', Storage::class);
        $this->app->alias('afroware.jwT.manager', Manager::class);
        $this->app->alias('afroware.jwT.blacklist', Blacklist::class);
        $this->app->alias('afroware.jwT.payload.factory', Factory::class);
        $this->app->alias('afroware.jwT.validators.payload', PayloadValidator::class);
    }
1080340
def register(self, alias, uri):
        
        # TODO: do we want to constrain the valid alias names.
        if isinstance(uri, dict):
            id = uri.get('id', alias)
            self.resolver.store[id] = uri
            uri = id
        self.aliases[alias] = uri
5434
protected function registerEloquentModels()
    {
        $files = $this->app['files']->files(storage_path('framework/entities'));
        
        foreach ($files as $file) {
            if ($this->app['files']->extension($file) == '') {
                require_once $file;
            }
        }
    }
1350531
protected function registerNamespaces()
    {
        $this->mergeConfigFrom(__DIR__.'/src/config/config.php', 'menus');
        $this->loadViewsFrom(__DIR__.'/src/views', 'menus');

        $this->publishes([
            __DIR__.'/src/config/config.php' => config_path('menus.php'),
        ], 'config');

        $this->publishes([
            __DIR__.'/src/views' => base_path('resources/views/vendor/pingpong/menus'),
        ], 'views');
    }
475962
protected function registerSingletons()
    {
        foreach ($this->singletons as $concrete => $abstracts) {
            if (!is_array($abstracts)) {
                $this->app->singleton($abstracts, $concrete);
                continue;
            }

            $first = array_shift($abstracts);

            $this->app->singleton($first, $concrete);

            foreach ($abstracts as $abstract) {
                $this->app->alias($first, $abstract);
            }
        }
    }
497314
def save_intrinsic_alias(module):
    
    for v in module.values():
        if isinstance(v, dict):  # Submodules case
            save_intrinsic_alias(v)
        else:
            IntrinsicAliases[v] = frozenset((v,))
            if isinstance(v, Class):
                save_intrinsic_alias(v.fields)
143871
protected function registerAliases()
    {
        $aliases = [
            // Facades
            'bForm' => 'NukaCode\Bootstrap\Support\Html\Form',
            'bHTML' => 'NukaCode\Bootstrap\Support\Html\HTML',
        ];

        $exclude = $this->app['config']->get('nukacode-core.excludeAliases');

        $this->loadAliases($aliases, $exclude);
    }
249355
public function registerFacades()
    {
        AliasLoader::getInstance($this->facades);

        # Auto-register alias
        foreach ($this->facades as $alias => $name) {
            AliasLoader::getInstance()->alias($alias, $name);
        }
    }
655897
protected function registerAliases()
    {
        $this->app->alias(Responder::class, 'responder');
        $this->app->alias(SuccessResponseBuilder::class, 'responder.success');
        $this->app->alias(ErrorResponseBuilder::class, 'responder.error');
        $this->app->alias(Manager::class, 'responder.manager');
        $this->app->alias(Manager::class, 'responder.serializer');
    }
480197
private function registerLocalization()
    {
        $this->singleton(Contracts\Localization::class, Localization::class);

        if ($alias = $this->config()->get('localization.facade')) {
            $this->alias($alias, Facades\Localization::class);

            $this->registerAliases();
        }
    }
1086427
protected function registerClassAliases(): void
	{
		$aliases = $this->config->get('application.class_aliases');

		if(!empty($aliases))
		{
			$aliasLoader = new AliasLoader($aliases);

			spl_autoload_register([$aliasLoader, 'load']);
		}
	}
1046794
private void applyAliases()
   {
      CustomFieldContainer fields = m_projectFile.getCustomFields();
      for (Map.Entry<FieldType, String> entry : ALIASES.entrySet())
      {
         fields.getCustomField(entry.getKey()).setAlias(entry.getValue());
      }
   }
846327
public function registerEntityAliases() {

		$factory = Yii::$app->factory->getContainer();

		$factory->set( 'chatService', 'cmsgears\community\common\services\entities\ChatService' );

		$factory->set( 'groupService', 'cmsgears\community\common\services\entities\GroupService' );
	}
1220806
public void setAliases(java.util.Collection<Alias> aliases) {
        if (aliases == null) {
            this.aliases = null;
            return;
        }

        this.aliases = new java.util.ArrayList<Alias>(aliases);
    }
1097835
protected function registerServices()
    {
        foreach ($this->serviceBindings as $key => $value) {
            is_numeric($key)
                    ? $this->app->singleton($value)
                    : $this->app->singleton($key, $value);
        }
    }
1101622
private function registerFilters()
    {
        $filters = config('app.render_filters', []);

        foreach ($filters as $filter) {
            $filter = app($filter);

            if ($filter instanceof FilterContract) {
                $this->twigEnvironment->addFilter(new \Twig_SimpleFilter($filter->getName(), $filter->getFilter()));
                $this->twigStringEnvironment->addFilter(new \Twig_SimpleFilter($filter->getName(),
                    $filter->getFilter()));
            }
        }
    }