Registers container and some classes

@return void
176179
protected function setupContainer()
    {
        $container = Registry::init();
        $container->add('app', $this);
        $container->add('registry', $container);

        $container->add('config', function () {
            return new Config($this->getConfigPath(), 'prod');
        });

        $this->config = $container->make('config');

        $container->add('routes', function () {
            return new Collection();
        });

        $this->container = $container;
    }
217341
public function registerComponents()
    {
        // Check objects
        if (empty($this->paths)) {
            return;
        }

        // Work on file paths
        foreach ($this->paths as $action => $actionPaths) {
            // Work on paths
            $actionPaths = !is_array($actionPaths) ? [$actionPaths] : $actionPaths;

            // Work on file name
            $filepath = OL_ZEUS_CACHE.$this->classname.'-'.$action.'-components.php';

            // Check cache file
            if (!file_exists($filepath)) {
                // Store all in cache file
                ClassMapGenerator::dump($actionPaths, $filepath);
            }

            $classmap = include_once $filepath;

            // Instanciate new ClassLoader to load and register components
            $loader = new MapClassLoader($classmap);
            $loader->register();

            // Get current hook
            $current = current_filter();
            $function = in_array($action, ['widgets_init']) ? 'registerWidgets' : 'registerObjects';

            // Register post type
            if ($action === $current) {
                // Already inside an `init` action
                $this->$function($classmap);
            } else {
                // Outside an `init` action
                add_action($action, function () use ($classmap, $function) {
                    $this->$function($classmap);
                });
            }
        }
    }
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();
    }
212778
protected function registerCommands()
    {
        $this->add(new \Daedalus\Command\DumpContainerCommand($this->kernel->getContainer()));
        $this->add(new \Daedalus\Command\HelpCommand($this->kernel->getContainer()));
    }
57230
public function register()
    {
        $this->getContainer()->singleton(Annotation::class, function() {
            Annotation::setContainer($this->getContainer());

            $annotation =  new Annotation((new Parser())->skipPhpDoc());

            return $annotation->addCommand(new Inject())
                ->addCommand(new Provider());
        });
    }
48446
public function register()
    {
        $this->container['crypt'] = function ($container) {
            $config = $container['config']->get('security.crypt');

            return new Crypt($config->key, $config->cipher, $config->padding);
        };
    }
628591
public function register() {
		$this->files = new Filesystem;
		$this->registerScanCommand();

		$method = "singleton";
		// Bind the manager as a singleton on the container.
		$this->app->$method('permacon', function($app) {
			
			/**
			 * Construct the actual manager.
			 */
			return new Permacon($app);
		});
	}
108268
public function registerCommands()
    {
        $commands = (array) $this->get('console.commands');

        foreach ($commands as $command) {
            if ($command === false) {
                continue;
            }

            if (is_string($command)) {
                $command = $this->container->createObject($command);
            }

            $this->addCommand($command);
        }
    }
516938
public function boot()
  {
    if ($this->booted) return;
    
    $this->container = $container = new Container();
    
    $this->registerServices      ($container);
    $this->registerRoutes        ($container);
    $this->registerEventListeners($container);
    
    $this->booted = true;
  }
602790
protected function registerServices(): void
	{
		// Register core services

		$this->serviceRegistrar('core');

		// Register environment specific services

		if($this->isCommandLine())
		{
			$this->registerCLIServices();
		}
		else
		{
			$this->registerWebServices();
		}
	}
428284
public function register()
    {
        $loader = AliasLoader::getInstance();

        // Register aliases
        foreach ($this->getAliases() as $alias => $class) {
            $loader->alias($alias, $class);
        }

        // Register service containers
        foreach ($this->getServiceContainers() as $abstract => $concrete) {
            $this->app->singleton($abstract, $concrete);
        }
    }
319283
public function register(Container $container)
    {
        // Authentication
        $container->share(Authentication::class, [$this, 'authentication'])
            ->bindShared(AuthenticationInterface::class, Authentication::class);

        // Authorisation
        $container->share(Authorisation::class, [$this, 'authorisation'])
            ->bindShared(AuthorisationInterface::class, Authorisation::class);

        // User Handler
        $this->prepareHandler($container);

        // User Manager
        $container->prepareSharedObject(UserManager::class);
    }
1145095
private function registerClasses()
	{
    	$this->addValidator(self::DEFAULT_VALIDATOR_LABEL, new Validator($this)); //Connect form validator
    	$this->setEntityRepository(new EntityRepository($this));
    	$this->setResponse(new Response($this));
    	$this->setDict(new Dictionary($this)); //Connect dictionary
    	$this->setStore(new Store($this)); //Connect Store
		$this->setBin(new Bin($this)); // Connect Bin
    	$this->setUserService(new UserService($this));
    	$this->setRouter(new Router($this));
    }
57978
protected function initialize()
    {
        $this->container = new Container();

        $containerProvider = new ContainerProvider($this->disabledMethods, $this->disabledFormats);
        $this->container->register($containerProvider);

        $this->initialized = false;
    }
1113045
public static function register_providers()
    {
        $provider_instances = [];

        foreach (static::$container->get(Config::class)->get('services.providers') as $provider) {
            try {
                $provider = static::$container->resolve($provider);
                $provider->register();

                $provider_instances[] = $provider;
            } catch (Exception $e) {
                // Fail silently if in production, otherwise throw originalException.
                if (\defined('WP_DEBUG') && WP_DEBUG) {
                    throw new ContainerException($e->getMessage());
                }
            }
        }

        foreach ($provider_instances as $provider) {
            static::$container->resolve_method($provider, 'boot');
        }
    }
635503
public function register()
    {
        $this->container['config']->addLocation($this->container->basePath().'/dev/config');

        foreach ($this->container['config']->get('app.providers') as $provider) {
            $this->container->addProvider($provider);
        }
    }
885116
public function register( Container $container ) {
		$this->container = $container;

		$container->define(
			array( 'assets' => 'Intraxia\Jaxion\Contract\Assets\Register' ),
			$register = new Register( $container->fetch( 'url' ), $container->fetch( 'version' ) )
		);

		$this->add_assets( $register );
	}