Container::val() - Code Metrics - jaxon-php/jaxon-mono - Measure and Improve Code Quality continuously with Scrutinizer

Container::val() A
last analyzed 2026-01-09 04:43 UTC

↳ Parent: Container
Complexity

Conditions	1
Paths	1
Size

Total Lines	3
Code Lines	1
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	1
eloc	1
nc	1
nop	2
dl	0
loc	3
rs	10
c	1
b	0
f	0
<?php

/**
 * Container.php
 *
 * Jaxon DI container. Provide container service for Jaxon classes.
 *
 * @package jaxon-core
 * @author Thierry Feuzeu <[email protected]>
 * @copyright 2016 Thierry Feuzeu <[email protected]>
 * @license https://opensource.org/licenses/BSD-3-Clause BSD 3-Clause License
 * @link https://github.com/jaxon-php/jaxon-core
 */

namespace Jaxon\Di;

use Jaxon\App\I18n\Translator;
use Jaxon\App\Session\SessionInterface;
use Jaxon\Exception\SetupException;
use Lagdo\Facades\ContainerWrapper;
use Pimple\Container as PimpleContainer;
use Psr\Container\ContainerInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use Closure;
use Throwable;

use function dirname;
use function is_a;

class Container implements ContainerInterface
{
    use Traits\AppTrait;
    use Traits\PsrTrait;
    use Traits\RequestTrait;
    use Traits\ResponseTrait;
    use Traits\PluginTrait;
    use Traits\CallableTrait;
    use Traits\ViewTrait;
    use Traits\UtilTrait;
    use Traits\MetadataTrait;
    use Traits\DiAutoTrait;

    /**
     * The library Dependency Injection Container
     *
     * @var PimpleContainer
     */
    private $xLibContainer;

    /**
     * The application or framework Dependency Injection Container
     *
     * @var ContainerInterface
     */
    private $xAppContainer = null;

    /**
     * The class constructor
     */
    public function __construct()
    {
        $this->xLibContainer = new PimpleContainer();

        // The container instance is saved in the container.
        $this->val(Container::class, $this);

        // Register the null logger by default
        $this->setLogger(new NullLogger());

        // Setup the logger facade. Don't overwrite if it's already set.
        ContainerWrapper::setContainer($this, false);

        $sBaseDir = dirname(__DIR__, 2);
        // Template directory
        $this->val('jaxon.core.dir.template', "$sBaseDir/templates");

        // Translation directory
        $this->val('jaxon.core.dir.translation', "$sBaseDir/translations");

        $this->registerAll();
        $this->setEventHandlers();
    }

    /**
     * The container for parameters
     *
     * @return Container
     */
    protected function cn(): Container
    {
        return $this;
    }

    /**
     * Register the values into the container
     *
     * @return void
     */
    private function registerAll()
    {
        $this->registerApp();
        $this->registerPsr();
        $this->registerRequests();
        $this->registerResponses();
        $this->registerPlugins();
        $this->registerCallables();
        $this->registerViews();
        $this->registerUtils();
        $this->registerMetadataReader();
    }

    /**
     * Set the logger
     *
     * @param LoggerInterface|Closure $xLogger
     *
     * @return void
     */
    public function setLogger(LoggerInterface|Closure $xLogger)
    {
        is_a($xLogger, LoggerInterface::class) ?
            $this->val(LoggerInterface::class, $xLogger) :
            $this->set(LoggerInterface::class, $xLogger);
    }

    /**
     * Get the logger
     *
     * @return LoggerInterface
     */
    public function getLogger(): LoggerInterface
    {
        return $this->get(LoggerInterface::class);
    }

    /**
     * Set the container provided by the integrated framework
     *
     * @param ContainerInterface $xContainer    The container implementation
     *
     * @return void
     */
    public function setContainer(ContainerInterface $xContainer)
    {
        $this->xAppContainer = $xContainer;
    }

    /**
     * Check if a class is defined in the container
     *
     * @param string $sClass    The full class name
     *
     * @return bool
     */
    public function h(string $sClass): bool
    {
        return $this->xLibContainer->offsetExists($sClass);
    }

    /**
     * Check if a class is defined in the container
     *
     * @param string $sClass    The full class name
     *
     * @return bool
     */
    public function has(string $sClass): bool
    {
        return $this->xAppContainer != null && $this->xAppContainer->has($sClass) ?
            true : $this->xLibContainer->offsetExists($sClass);
    }

    /**
     * Get a class instance
     *
     * @template T
     * @param class-string<T> $sClass The full class name

     *
     * @return T
     */
    public function g(string $sClass): mixed
    {
        return $this->xLibContainer->offsetGet($sClass);
    }

    /**
     * Get a class instance
     *
     * @template T
     * @param class-string<T> $sClass The full class name

     *
     * @return T
     * @throws SetupException
     */
    public function get(string $sClass): mixed
    {
        try
        {
            return $this->xAppContainer != null && $this->xAppContainer->has($sClass) ?
                $this->xAppContainer->get($sClass) : $this->xLibContainer->offsetGet($sClass);
        }
        catch(Throwable $e)
        {
            $xLogger = $this->g(LoggerInterface::class);
            $xTranslator = $this->g(Translator::class);
            $sMessage = $e->getMessage() . ': ' . $xTranslator->trans('errors.class.container', ['name' => $sClass]);
            $xLogger->error($e->getMessage(), ['message' => $sMessage]);
            throw new SetupException($sMessage);
        }
    }

    /**
     * Save a closure in the container
     *
     * @param string|class-string $sClass    The full class name

     * @param Closure $xClosure    The closure
     * @param bool $bIsSingleton
     *
     * @return void
     */
    public function set(string $sClass, Closure $xClosure, bool $bIsSingleton = true)
    public function set(string $sClass, /** @scrutinizer ignore-unused */ Closure $xClosure, bool $bIsSingleton = true)
    {
        // Wrap the user closure into a new closure, so it can take this container as a parameter.
        $xClosure = fn() => $xClosure($this);
        $this->xLibContainer->offsetSet($sClass, $bIsSingleton ?
            $xClosure : $this->xLibContainer->factory($xClosure));
    }

    /**
     * Save a value in the container
     *
     * @param string|class-string $sKey    The key

     * @param mixed $xValue    The value
     *
     * @return void
     */
    public function val(string $sKey, $xValue)
    {
       $this->xLibContainer->offsetSet($sKey, $xValue);
    }

    /**
     * Set an alias in the container
     *
     * @param string|class-string $sAlias    The alias name

     * @param string|class-string $sClass    The class name
     *
     * @return void
     */
    public function alias(string $sAlias, string $sClass)
    {
        $this->set($sAlias, function($di) use ($sClass) {
            return $di->get($sClass);
        });
    }

    /**
     * Get the session manager
     *
     * @return SessionInterface|null
     */
    public function getSessionManager(): ?SessionInterface
    {
        return $this->h(SessionInterface::class) ? $this->g(SessionInterface::class) : null;
    }

    /**
     * Set the session manager
     *
     * @param Closure $xClosure    A closure to create the session manager instance
     *
     * @return void
     */
    public function setSessionManager(Closure $xClosure)
    {
        $this->set(SessionInterface::class, $xClosure);
    }
}

jaxon-php / jaxon-mono

Container::val() A last analyzed 2026-01-09 04:43 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Container::val() A
last analyzed 2026-01-09 04:43 UTC
