Register components.
485389
protected function registerComponents()
    {
        ComponentManager::instance()->registerComponents(function ($manager) {
            $manager->registerComponent(\Cms\Components\ViewBag::class, 'viewBag');
            $manager->registerComponent(\Cms\Components\Resources::class, 'resources');
        });
    }
201298
protected void registerSelf() {
        publishSelf();
        serviceRegistry.get().registerService(getServiceDescription());
        serviceRegistry.get().subscribe((pair, err) -> {
            serviceEvent(pair.car(), pair.cdr(), err);
        });
        heartBeat();
        Log.Info(this, "registered at serviceRegistry.");
    }
1179336
public function register()
    {
        $this->registerBindings();
        $this->app['events']->listen(BuildingSidebar::class, RegisterCartSidebar::class);

        $this->app['events']->listen(LoadingBackendTranslations::class, function (LoadingBackendTranslations $event) {
            $event->load('cartitems', array_dot(trans('cart::cartitems')));
            // append translations
        });
    }
859771
protected function registerCommands()
    {
        $this->app->singleton('command.vueg.component', function ($app) {
            return $app[MakeComponent::class];
        });

        $this->app->singleton('command.vueg.mixin', function ($app) {
            return $app[MakeMixin::class];
        });

        $this->commands('command.vueg.component');

        $this->commands('command.vueg.mixin');
    }
999322
public function register()
	{
		$this->app['arguments'] = function($app)
		{
			global $argv;

			// Register namespace for App commands and component commands
			// @FIXME: neither of these work yet...
			Arguments::registerNamespace('\App\Commands');
			Arguments::registerNamespace('\Components\{$1}\Cli\Commands');

			return new Arguments($argv);
		};
	}
1238413
public synchronized void registerComponent(Class<?> _clazz) {
        if (_clazz == null) {
            return;
        }

        if (isIncluded(_clazz.getName()) || _clazz.getName().equals(this.getClass().getName())) {
            String classVersion = getVersionWithReflection(_clazz);
            if (classVersion != null) {
                componentVersions.put(_clazz.getName(), classVersion);
            }
        }
    }
1158362
public function register()
    {
        $displayer = new BasicDisplayer;
        $handler = new Handler($displayer);
        $this->container->bind('error', $handler);
    }
10915
private function componentsReady()
    {
        $this->getRegistryCache()->isAppReady();

        if ($this->componentsloaded) {
            foreach ($this->components as $component) {
                $component->ready($this);
            }
        }
    }
1256301
public synchronized void registerComponent(Class<?> _clazz, String _version) {
        componentVersions.put(_clazz.getName(), _version);
    }
1212872
private function registerComponents($app)
    {
        foreach ($this->getModules() as $id => $module) {
            // set an alias for all user modules
            Yii::setAlias('@'.$id, $module->getBasePath());
            // see if the module has a registerComponents method
            foreach ($module->registerComponents() as $componentId => $definition) {
                if (!$app->has($componentId)) {
                    Yii::trace('Register component ' . $componentId, __METHOD__);
                    $app->set($componentId, $definition);
                }
            }
        }
    }
622797
public Application register(Class<?> componentClass, Map<Class<?>, Integer> contracts) {
        config.register(componentClass, contracts);
        return this;
    }
584084
function _registerAll() {
  if (!registerAllCalled) {
    registerAllCalled = true;
    Object.keys(ComponentsHash)
      .filter(tagName => typeof ComponentsHash[tagName] !== 'function')
      .forEach(tagName => _registerComponent(tagName));
  }
}
811761
protected function registerThirdPartyProviders()
    {
        if (
            'testing' == $this->app->environment()
            ||
            version_compare(Application::VERSION, '5.5.0', '<')
        ) {
            $this->registerMenuComponent();
            $this->registerFormComponent();
            $this->registerFlashComponent();
            $this->registerBreadcrumbsComponent();
            $this->registerSluggableComponent();
        }

        $this->mergeBreadCrumbsConfig();
    }
848625
protected function _registerFromConfigure()
    {
        $configure = Configure::read('PostTypes.Register');

        if (!is_array($configure)) {
            $configure = [];
        }

        foreach ($configure as $key => $item) {
            $this->register($key, $item);
        }
    }
1064124
public function register_components() {

		foreach ( $this->struct['component'] as $component_id => $component_struct ) {

			if ( ! empty( $component_struct['id'] ) ) {
				$component_id = $component_struct['id'];
			}

			$component_struct += $this->base_component( $component_id );

			if ( ! empty( $component_struct['setup'] ) ) {
				$component_struct['section'] = $component_struct['setup'];
				unset( $component_struct['setup'] );
			}

			$this->modals[] = $this->modal( $component_id, $component_struct );
		}

	}
513217
protected function registerSupports()
    {
        do_action("before_theme_add_supports");

        foreach ($this->getConfig("supports") as $feature => $enabled):
            if (!$enabled):
                continue;
            endif;
            add_theme_support($feature);
        endforeach;

        do_action("after_theme_add_supports");
    }
749140
private void registerListeners() {
    protocol.registerExecuteHandler(this::execute);
    protocol.registerBackupHandler(this::backup);
    protocol.registerRestoreHandler(this::restore);
    protocol.registerCloseHandler(this::close);
    protocol.registerMetadataHandler(this::metadata);
  }