Registers the bindings in the container.

@param  \Zapheus\Container\WritableInterface $container
@return \Zapheus\Container\ContainerInterface
189477
public function register(WritableInterface $container)
    {
        $factory = new RequestFactory;

        list($file, $response) = array(new FileFactory, new Response);

        $config = $container->get(Application::CONFIG);

        $files = $config->get('app.http.uploaded', (array) $_FILES);

        $factory->cookies($config->get('app.http.cookies', $_COOKIE));

        $factory->data($config->get('app.http.post', $_POST));

        $factory->files($file->normalize((array) $files));

        $factory->queries($config->get('app.http.get', $_GET));

        $factory->server($config->get('app.http.server', $_SERVER));

        $container->set(self::REQUEST, $factory->make());

        return $container->set(Application::RESPONSE, $response);
    }
1100781
private function addShellFacade(DependencyContainerInterface $container): DependencyContainerInterface
    {
        $container[self::SHELL_FACADE] = function (DependencyContainerInterface $container) {
            return $container->getLocator()->shell()->facade();
        };

        return $container;
    }
149778
protected function registerAssetsManager(Container $container)
    {
        $container['assets/config'] = function (Container $container) {
            $config = $container['view/config']->get('assets');

            return new AssetsConfig($config);
        };

        $container['assets/builder'] = function () {
            return new AssetsBuilder();
        };

        /**
         * @param Container $container Pimple DI container.
         * @return AssetManager
         */
        $container['assets'] = function (Container $container) {
            $assetsBuilder = $container['assets/builder'];
            $assetsConfig = $container['assets/config'];

            return $assetsBuilder($assetsConfig);
        };
    }
135989
public function register(Container $container)
    {
        $container->prepareSharedObject(ErrorManager::class, function (ErrorManager $error, Container $container) {
            foreach ((array) $this->config->get('error.handlers', []) as $key => $handler) {
                if (is_string($handler)) {
                    $handler = $container->newInstance($handler);
                }

                $error->addHandler($handler, is_numeric($key) ? null : $key);
            }

            return $error;
        });

        $container->extend(LoggerManager::class, function (LoggerManager $manager, Container $container) {
            if ($container->get('config')->get('error.log', false)) {
                $logger = $manager->createRotatingLogger('error', LogLevel::ERROR);
            } else {
                $logger = new NullLogger();
            }

            $manager->addLogger('error', $logger);

            return $manager;
        });
    }
167123
protected function registerFormats(Container $container)
    {
        foreach ($this->formats as $formatClass) {
            $container['format.'.$formatClass::getName()] = $container->factory(function() use ($formatClass) {
                return new $formatClass();
            });
        }
    }
59911
protected function registerProviders(Container $container): void
    {
        foreach (self::$providers as $className) {
            $container->addServiceProvider($className);
        }
    }
323834
protected function bindInitialInstances(ContainerInterface $container)
	{
		foreach($this->komponents as $komponent)
		{
			$container->bindInstance(get_class($komponent), $komponent);
		}
	}
37192
public function register(Container $container)
    {
        $container->prepareSharedObject(AssetManager::class);
        $container->prepareSharedObject(ScriptManager::class);

        AbstractScript::$instance = function () use ($container) {
            return $container->get(ScriptManager::class);
        };
    }
761843
public function register(Container $container)
    {
        $container->share(MatcherInterface::class, [$this, 'matcher']);

        $container->prepareSharedObject(RouteCreator::class);
        $container->prepareSharedObject(MainRouter::class);
    }
669578
public function addContainer(ContainerInterface $container)
    {
        $container->setDelegator($this);
        $this->containers[] = $container;
        return $this;
    }
1154437
public function pathResolvable(Container $container)
    {
        $event = $this->loadEventFromPath($container);
        return ($event instanceof EventInterface) && $event->id();
    }
176282
public function register(WritableInterface $container)
    {
        $config = $container->get(self::CONFIG);

        $paths = $config->get('app.views', $this->paths);

        $renderer = new Renderer((array) $paths);

        return $container->set(self::RENDERER, $renderer);
    }
797197
public function setContainer(ContainerInterface $container)
    {
        $application = $this;
        $container->share(ApplicationInterface::class, $application);
        $container->share(\Interop\Container\ContainerInterface::class, $container);

        $this->container = $container;

        return $this;
    }
1073975
public function register(Container $container)
    {
        $container['extensions.sections'] = function ($c) {
            return new Sections($c['section.factory'], $c['events']);
        };

        $container['extensions.helpers'] = function ($c) {
            return new Helpers($c['escaper'], $c['options']);
        };

        $container['extensions.walker'] = function ($c) {
            return new Walker($c['command'], $c['escaper'], $c['options']);
        };

        $container['extensions.filters'] = function () {
            return new Filters();
        };

        $container['extensions.aura_html'] = function ($c) {
            return new AuraHtmlExtension(
                $c['aura.html.locator'],
                $c['options']['html_tags_functions']
            );
        };
    }
565239
public function register(Container $container)
    {
        $container->share(get_class($this->package), $this->package)
            ->bindShared(AbstractPackage::class, get_class($this->package));

        $container->share('controller.resolver', function (Container $container) {
            return new ControllerResolver($this->package, $container);
        });

        $container->share('repository.resolver', function (Container $container) {
            return new RepositoryResolver($this->package, $container);
        })->alias('model.resolver', 'repository.resolver');

        $container->share('view.resolver', function (Container $container) {
            return new ViewResolver($this->package, $container);
        });

        $container->share('mvc.resolver', function (Container $container) {
            return new MvcResolver(
                $container->get('controller.resolver'),
                $container->get('repository.resolver'),
                $container->get('view.resolver')
            );
        });

        if ($this->package->app->isWeb()) {
            // Router
            $container->prepareSharedObject(PackageRouter::class)->alias('router', PackageRouter::class);
        }
    }
134522
public function register(Container $container)
    {
        $container->prepareSharedObject(CsrfGuard::class)
            ->alias('security.csrf', CsrfGuard::class);

        // Always new instance in every usage
        $container->bind(CipherInterface::class, function (Container $container) {
            $config = $container->get('config');
            $class  = $this->getCipher($config->get('crypt.cipher', 'blowfish'));

            return $container->newInstance($class);
        });

        $container->share(Crypt::class, function (Container $container) {
            $config = $container->get('config');
            $key    = md5('Windwalker-Crypt::' . $config->get('system.secret'));

            return $container->newInstance(Crypt::class, ['key' => $key]);
        })->bindShared(CryptInterface::class, Crypt::class);

        $container->prepareSharedObject(ModernPassword::class)
            ->bindShared(HasherInterface::class, ModernPassword::class)
            ->bindShared(Password::class, ModernPassword::class);
    }
848346
protected function injectPackages(ContainerInterface $container)
	{
		foreach ($this->getPackages() as $package) {
			$package->inject($container);
		}
	}