Container::getViewManager() - Code Metrics - Inspection of "Merge pull request #48 from jaxon-php/develop" - jaxon-php/jaxon-core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( f42a52...0a9499 )

by Thierry

created 2019-11-11 06:06 UTC

Container::getViewManager() A

↳ Parent: Container

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
nc	1
nop	0
dl	0
loc	4
rs	10
c	0
b	0
f	0

<?php

/**
 * Container.php - Jaxon data container
 *
 * Provide container service for Jaxon utils class instances.
 *
 * @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\Utils\DI;

use Jaxon\Response\Response;
use Jaxon\Request\Support\CallableRepository;
use Jaxon\Request\Plugin\CallableClass;
use Jaxon\Request\Plugin\CallableDir;
use Jaxon\Request\Plugin\CallableFunction;
use Jaxon\Request\Plugin\FileUpload;
use Jaxon\Request\Handler as RequestHandler;
use Jaxon\Request\Factory\RequestFactory;
use Jaxon\Request\Factory\ParameterFactory;
use Jaxon\Request\Factory\CallableClass\Request as CallableClassRequestFactory;
use Jaxon\Request\Factory\CallableClass\Paginator as CallableClassPaginatorFactory;
use Jaxon\Request\Support\CallableObject;
use Jaxon\Response\Manager as ResponseManager;
use Jaxon\Response\Plugin\JQuery as JQueryPlugin;
use Jaxon\Plugin\Manager as PluginManager;
use Jaxon\Plugin\CodeGenerator;
use Jaxon\Contracts\Template\Renderer as TemplateRenderer;
use Jaxon\Contracts\Session as SessionContract;
use Jaxon\Contracts\Container as ContainerContract;

use Jaxon\App\App;
use Jaxon\App\Bootstrap;

use Jaxon\Utils\Config\Config;
use Jaxon\Utils\Config\Reader as ConfigReader;
use Jaxon\Utils\View\Manager as ViewManager;
use Jaxon\Utils\View\Renderer as ViewRenderer;
use Jaxon\Utils\View\Renderer;
use Jaxon\Utils\Dialogs\Dialog;
use Jaxon\Utils\Template\Minifier;
use Jaxon\Utils\Template\Engine as TemplateEngine;
use Jaxon\Utils\Pagination\Paginator;
use Jaxon\Utils\Pagination\Renderer as PaginationRenderer;
use Jaxon\Utils\Validation\Validator;
use Jaxon\Utils\Translation\Translator;

use Lemon\Event\EventDispatcher;

class Container
{
    /**
     * The Dependency Injection Container
     *
     * @var \Pimple\Container
     */
    private $libContainer = null;

    /**
     * The Dependency Injection Container
     *
     * @var \Jaxon\Contracts\Container
     */
    private $appContainer = null;

    /**
     * The class constructor
     */
    public function __construct()
    {
        $this->libContainer = new \Pimple\Container();

        $sTranslationDir = realpath(__DIR__ . '/../../../translations');
        $sTemplateDir = realpath(__DIR__ . '/../../../templates');
        $this->init($sTranslationDir, $sTemplateDir);
    }

    /**
     * Get the container provided by the integrated framework
     *
     * @return ContainerContract
     */
    public function getAppContainer()
    {
        return $this->appContainer;
    }

    /**
     * Set the container provided by the integrated framework
     *
     * @param ContainerContract  $container     The container implementation
     *
     * @return void
     */
    public function setAppContainer(ContainerContract $container)
    {
        $this->appContainer = $container;
    }

    /**
     * Set the parameters and create the objects in the dependency injection container
     *
     * @param string        $sTranslationDir     The translation directory
     * @param string        $sTemplateDir        The template directory
     *
     * @return void
     */
    private function init($sTranslationDir, $sTemplateDir)
    {
        /*
         * Parameters
         */
        // Translation directory
        $this->libContainer['jaxon.core.translation_dir'] = $sTranslationDir;
        // Template directory
        $this->libContainer['jaxon.core.template_dir'] = $sTemplateDir;

        /*
         * Core library objects
         */
        // Global Response
        $this->libContainer[Response::class] = function () {
            return new Response();
        };
        // Dialog
        $this->libContainer[Dialog::class] = function () {
            return new Dialog();
        };
        // Jaxon App
        $this->libContainer[App::class] = function () {
            return new App();
        };
        // Jaxon App bootstrap
        $this->libContainer[Bootstrap::class] = function () {
            return new Bootstrap();
        };

        /*
         * Plugins
         */
        // Callable objects repository
        $this->libContainer[CallableRepository::class] = function () {
            return new CallableRepository();
        };
        // Callable class plugin
        $this->libContainer[CallableClass::class] = function ($c) {
            return new CallableClass($c[CallableRepository::class]);
        };
        // Callable dir plugin
        $this->libContainer[CallableDir::class] = function ($c) {
            return new CallableDir($c[CallableRepository::class]);
        };
        // Callable function plugin
        $this->libContainer[CallableFunction::class] = function () {
            return new CallableFunction();
        };
        // File upload plugin
        $this->libContainer[FileUpload::class] = function () {
            return new FileUpload();
        };
        // JQuery response plugin
        $this->libContainer[JQueryPlugin::class] = function () {
            return new JQueryPlugin();
        };

        /*
         * Managers
         */
        // Plugin Manager
        $this->libContainer[PluginManager::class] = function () {
            return new PluginManager();
        };
        // Request Handler
        $this->libContainer[RequestHandler::class] = function ($c) {
            return new RequestHandler($c[PluginManager::class], $c[ResponseManager::class], $c[FileUpload::class]);
        };
        // Request Factory
        $this->libContainer[RequestFactory::class] = function ($c) {
            return new RequestFactory($c[CallableRepository::class]);
        };
        // Parameter Factory
        $this->libContainer[ParameterFactory::class] = function () {
            return new ParameterFactory();
        };
        // Response Manager
        $this->libContainer[ResponseManager::class] = function () {
            return new ResponseManager();
        };
        // Code Generator
        $this->libContainer[CodeGenerator::class] = function ($c) {
            return new CodeGenerator($c[PluginManager::class], $c[TemplateEngine::class]);
        };
        // View Manager
        $this->libContainer[ViewManager::class] = function () {
            return new ViewManager();
        };
        // View Renderer
        $this->libContainer[ViewRenderer::class] = function ($c) {
            return new ViewRenderer($c[ViewManager::class]);
        };

        /*
         * Config
         */
        $this->libContainer[Config::class] = function () {
            return new Config();
        };
        $this->libContainer[ConfigReader::class] = function () {
            return new ConfigReader();
        };

        /*
         * Services
         */
        // Minifier
        $this->libContainer[Minifier::class] = function () {
            return new Minifier();
        };
        // Translator
        $this->libContainer[Translator::class] = function ($c) {
            return new Translator($c['jaxon.core.translation_dir'], $c[Config::class]);
        };
        // Template engine
        $this->libContainer[TemplateEngine::class] = function ($c) {
            return new TemplateEngine($c['jaxon.core.template_dir']);
        };
        // Template Renderer
        $this->libContainer[TemplateRenderer::class] = function ($c) {
            return $c[TemplateEngine::class];
        };
        // Validator
        $this->libContainer[Validator::class] = function ($c) {
            return new Validator($c[Translator::class], $c[Config::class]);
        };
        // Pagination Paginator
        $this->libContainer[Paginator::class] = function ($c) {
            return new Paginator($c[PaginationRenderer::class]);
        };
        // Pagination Renderer
        $this->libContainer[PaginationRenderer::class] = function ($c) {
            return new PaginationRenderer($c[TemplateRenderer::class]);
        };
        // Event Dispatcher
        $this->libContainer[EventDispatcher::class] = function () {
            return new EventDispatcher();
        };
    }

    /**
     * Get a class instance
     *
     * @return object        The class instance
     */
    public function get($sClass)
    {
        if($this->appContainer != null && $this->appContainer->has($sClass))
        {
            return $this->appContainer->get($sClass);
        }
        return $this->libContainer[$sClass];
    }

    /**
     * Set a DI closure
     *
     * @param string                $sClass             The full class name
     * @param Closure               $xClosure           The closure
     *
     * @return void
     */
    public function set($sClass, $xClosure)
    {
        $this->libContainer[$sClass] = $xClosure;
    }

    /**
     * Set an alias
     *
     * @param string                $sClass             The class name
     * @param string                $sAlias             The alias name
     *
     * @return void
     */
    public function alias($sClass, $sAlias)
    {
        $this->libContainer[$sClass] = function ($c) use ($sAlias) {
            return $c[$sAlias];
        };
    }

    /**
     * Get the plugin manager
     *
     * @return PluginManager
     */
    public function getPluginManager()
    {
        return $this->libContainer[PluginManager::class];
    }

    /**
     * Get the request handler
     *
     * @return RequestHandler
     */
    public function getRequestHandler()
    {
        return $this->libContainer[RequestHandler::class];
    }

    /**
     * Get the request factory
     *
     * @return RequestFactory
     */
    public function getRequestFactory()
    {
        return $this->libContainer[RequestFactory::class];
    }

    /**
     * Get the parameter factory
     *
     * @return ParameterFactory
     */
    public function getParameterFactory()
    {
        return $this->libContainer[ParameterFactory::class];
    }

    /**
     * Get the response manager
     *
     * @return ResponseManager
     */
    public function getResponseManager()
    {
        return $this->libContainer[ResponseManager::class];
    }

    /**
     * Get the code generator
     *
     * @return CodeGenerator
     */
    public function getCodeGenerator()
    {
        return $this->libContainer[CodeGenerator::class];
    }

    /**
     * Get the callable repository
     *
     * @return CallableRepository
     */
    public function getCallableRepository()
    {
        return $this->libContainer[CallableRepository::class];
    }

    /**
     * Get the config manager
     *
     * @return Config
     */
    public function getConfig()
    {
        return $this->libContainer[Config::class];
    }

    /**
     * Create a new the config manager
     *
     * @param array             $aOptions           The options array
     * @param string            $sKeys              The keys of the options in the array
     *
     * @return Config            The config manager
     */
    public function newConfig(array $aOptions = [], $sKeys = '')
    {
        return new Config($aOptions, $sKeys);
    }

    /**
     * Get the dialog wrapper
     *
     * @return Dialog
     */
    public function getDialog()
    {
        return $this->libContainer[Dialog::class];
    }

    /**
     * Get the minifier
     *
     * @return Minifier
     */
    public function getMinifier()
    {
        return $this->libContainer[Minifier::class];
    }

    /**
     * Get the translator
     *
     * @return Translator
     */
    public function getTranslator()
    {
        return $this->libContainer[Translator::class];
    }

    /**
     * Get the template engine
     *
     * @return Engine
     */
    public function getTemplateEngine()
    {
        return $this->libContainer[TemplateEngine::class];
    }

    /**
     * Get the template renderer
     *
     * @return TemplateRenderer
     */
    public function getTemplateRenderer()
    {
        return $this->libContainer[TemplateRenderer::class];
    }

    /**
     * Get the validator
     *
     * @return Validator
     */
    public function getValidator()
    {
        return $this->libContainer[Validator::class];
    }

    /**
     * Get the paginator
     *
     * @return Paginator
     */
    public function getPaginator()
    {
        return $this->libContainer[Paginator::class];
    }

    /**
     * Get the event dispatcher
     *
     * @return EventDispatcher
     */
    public function getEventDispatcher()
    {
        return $this->libContainer[EventDispatcher::class];
    }

    /**
     * Get the global Response object
     *
     * @return Response
     */
    public function getResponse()
    {
        return $this->libContainer[Response::class];
    }

    /**
     * Create a new Jaxon response object
     *
     * @return Response
     */
    public function newResponse()
    {
        return new Response();
    }

    /**
     * Get the App instance
     *
     * @return App
     */
    public function getApp()
    {
        return $this->libContainer[App::class];
    }

    /**
     * Get the App bootstrap
     *
     * @return Bootstrap
     */
    public function getBootstrap()
    {
        return $this->libContainer[Bootstrap::class];
    }

    /**
     * Get the view manager
     *
     * @return ViewManager
     */
    public function getViewManager()
    {
        return $this->libContainer[ViewManager::class];
    }

    /**
     * Get the view facade
     *
     * @return ViewRenderer
     */
    public function getViewRenderer()
    {
        return $this->libContainer[ViewRenderer::class];
    }

    /**
     * Get the session manager
     *
     * @return SessionContract
     */
    public function getSessionManager()
    {
        return $this->libContainer[SessionContract::class];
    }

    /**
     * Set the session manager
     *
     * @param Closure      $xClosure      A closure to create the session manager instance
     *
     * @return void
     */
    public function setSessionManager($xClosure)
    {
        $this->libContainer[SessionContract::class] = $xClosure;
    }

    /**
     * Set the callable class request factory
     *
     * @param string            $sClassName         The callable class name
     * @param CallableObject    $xCallableObject    The corresponding callable object
     *
     * @return void
     */
    public function setCallableClassRequestFactory($sClassName, CallableObject $xCallableObject)
    {
        $this->libContainer[$sClassName . '_RequestFactory'] = function () use ($xCallableObject) {
            // $xCallableObject = $c[CallableRepository::class]->getCallableObject($sClassName);
            return new CallableClassRequestFactory($xCallableObject);
        };
    }

    /**
     * Get the callable class request factory
     *
     * @param string        $sClassName             The callable class name
     *
     * @return CallableClassRequestFactory
     */
    public function getCallableClassRequestFactory($sClassName)
    {
        return $this->libContainer[$sClassName . '_RequestFactory'];
    }

    /**
     * Set the callable class paginator factory
     *
     * @param string            $sClassName         The callable class name
     * @param CallableObject    $xCallableObject    The corresponding callable object
     *
     * @return void
     */
    public function setCallableClassPaginatorFactory($sClassName, CallableObject $xCallableObject)
    {
        $this->libContainer[$sClassName . '_PaginatorFactory'] = function () use ($xCallableObject) {
            // $xCallableObject = $c[CallableRepository::class]->getCallableObject($sClassName);
            return new CallableClassPaginatorFactory($xCallableObject);
        };
    }

    /**
     * Get the callable class paginator factory
     *
     * @param string        $sClassName             The callable class name
     *
     * @return CallableClassPaginatorFactory
     */
    public function getCallableClassPaginatorFactory($sClassName)
    {
        return $this->libContainer[$sClassName . '_PaginatorFactory'];
    }
}


1			<?php
2
3			/**
4			* Container.php - Jaxon data container
5			*
6			* Provide container service for Jaxon utils class instances.
7			*
8			* @package jaxon-core
9			* @author Thierry Feuzeu <[email protected]>
10			* @copyright 2016 Thierry Feuzeu <[email protected]>
11			* @license https://opensource.org/licenses/BSD-3-Clause BSD 3-Clause License
12			* @link https://github.com/jaxon-php/jaxon-core
13			*/
14
15			namespace Jaxon\Utils\DI;
16
17			use Jaxon\Response\Response;
18			use Jaxon\Request\Support\CallableRepository;
19			use Jaxon\Request\Plugin\CallableClass;
20			use Jaxon\Request\Plugin\CallableDir;
21			use Jaxon\Request\Plugin\CallableFunction;
22			use Jaxon\Request\Plugin\FileUpload;
23			use Jaxon\Request\Handler as RequestHandler;
24			use Jaxon\Request\Factory\RequestFactory;
25			use Jaxon\Request\Factory\ParameterFactory;
26			use Jaxon\Request\Factory\CallableClass\Request as CallableClassRequestFactory;
27			use Jaxon\Request\Factory\CallableClass\Paginator as CallableClassPaginatorFactory;
28			use Jaxon\Request\Support\CallableObject;
29			use Jaxon\Response\Manager as ResponseManager;
30			use Jaxon\Response\Plugin\JQuery as JQueryPlugin;
31			use Jaxon\Plugin\Manager as PluginManager;
32			use Jaxon\Plugin\CodeGenerator;
33			use Jaxon\Contracts\Template\Renderer as TemplateRenderer;
34			use Jaxon\Contracts\Session as SessionContract;
35			use Jaxon\Contracts\Container as ContainerContract;
36
37			use Jaxon\App\App;
38			use Jaxon\App\Bootstrap;
39
40			use Jaxon\Utils\Config\Config;
41			use Jaxon\Utils\Config\Reader as ConfigReader;
42			use Jaxon\Utils\View\Manager as ViewManager;
43			use Jaxon\Utils\View\Renderer as ViewRenderer;
44			use Jaxon\Utils\View\Renderer;
45			use Jaxon\Utils\Dialogs\Dialog;
46			use Jaxon\Utils\Template\Minifier;
47			use Jaxon\Utils\Template\Engine as TemplateEngine;
48			use Jaxon\Utils\Pagination\Paginator;
49			use Jaxon\Utils\Pagination\Renderer as PaginationRenderer;
50			use Jaxon\Utils\Validation\Validator;
51			use Jaxon\Utils\Translation\Translator;
52
53			use Lemon\Event\EventDispatcher;
54
55			class Container
56			{
57			/**
58			* The Dependency Injection Container
59			*
60			* @var \Pimple\Container
61			*/
62			private $libContainer = null;
63
64			/**
65			* The Dependency Injection Container
66			*
67			* @var \Jaxon\Contracts\Container
68			*/
69			private $appContainer = null;
70
71			/**
72			* The class constructor
73			*/
74			public function __construct()
75			{
76			$this->libContainer = new \Pimple\Container();
77
78			$sTranslationDir = realpath(__DIR__ . '/../../../translations');
79			$sTemplateDir = realpath(__DIR__ . '/../../../templates');
80			$this->init($sTranslationDir, $sTemplateDir);
81			}
82
83			/**
84			* Get the container provided by the integrated framework
85			*
86			* @return ContainerContract
87			*/
88			public function getAppContainer()
89			{
90			return $this->appContainer;
91			}
92
93			/**
94			* Set the container provided by the integrated framework
95			*
96			* @param ContainerContract $container The container implementation
97			*
98			* @return void
99			*/
100			public function setAppContainer(ContainerContract $container)
101			{
102			$this->appContainer = $container;
103			}
104
105			/**
106			* Set the parameters and create the objects in the dependency injection container
107			*
108			* @param string $sTranslationDir The translation directory
109			* @param string $sTemplateDir The template directory
110			*
111			* @return void
112			*/
113			private function init($sTranslationDir, $sTemplateDir)
114			{
115			/*
116			* Parameters
117			*/
118			// Translation directory
119			$this->libContainer['jaxon.core.translation_dir'] = $sTranslationDir;
120			// Template directory
121			$this->libContainer['jaxon.core.template_dir'] = $sTemplateDir;
122
123			/*
124			* Core library objects
125			*/
126			// Global Response
127			$this->libContainer[Response::class] = function () {
128			return new Response();
129			};
130			// Dialog
131			$this->libContainer[Dialog::class] = function () {
132			return new Dialog();
133			};
134			// Jaxon App
135			$this->libContainer[App::class] = function () {
136			return new App();
137			};
138			// Jaxon App bootstrap
139			$this->libContainer[Bootstrap::class] = function () {
140			return new Bootstrap();
141			};
142
143			/*
144			* Plugins
145			*/
146			// Callable objects repository
147			$this->libContainer[CallableRepository::class] = function () {
148			return new CallableRepository();
149			};
150			// Callable class plugin
151			$this->libContainer[CallableClass::class] = function ($c) {
152			return new CallableClass($c[CallableRepository::class]);
153			};
154			// Callable dir plugin
155			$this->libContainer[CallableDir::class] = function ($c) {
156			return new CallableDir($c[CallableRepository::class]);
157			};
158			// Callable function plugin
159			$this->libContainer[CallableFunction::class] = function () {
160			return new CallableFunction();
161			};
162			// File upload plugin
163			$this->libContainer[FileUpload::class] = function () {
164			return new FileUpload();
165			};
166			// JQuery response plugin
167			$this->libContainer[JQueryPlugin::class] = function () {
168			return new JQueryPlugin();
169			};
170
171			/*
172			* Managers
173			*/
174			// Plugin Manager
175			$this->libContainer[PluginManager::class] = function () {
176			return new PluginManager();
177			};
178			// Request Handler
179			$this->libContainer[RequestHandler::class] = function ($c) {
180			return new RequestHandler($c[PluginManager::class], $c[ResponseManager::class], $c[FileUpload::class]);
181			};
182			// Request Factory
183			$this->libContainer[RequestFactory::class] = function ($c) {
184			return new RequestFactory($c[CallableRepository::class]);
185			};
186			// Parameter Factory
187			$this->libContainer[ParameterFactory::class] = function () {
188			return new ParameterFactory();
189			};
190			// Response Manager
191			$this->libContainer[ResponseManager::class] = function () {
192			return new ResponseManager();
193			};
194			// Code Generator
195			$this->libContainer[CodeGenerator::class] = function ($c) {
196			return new CodeGenerator($c[PluginManager::class], $c[TemplateEngine::class]);
197			};
198			// View Manager
199			$this->libContainer[ViewManager::class] = function () {
200			return new ViewManager();
201			};
202			// View Renderer
203			$this->libContainer[ViewRenderer::class] = function ($c) {
204			return new ViewRenderer($c[ViewManager::class]);
205			};
206
207			/*
208			* Config
209			*/
210			$this->libContainer[Config::class] = function () {
211			return new Config();
212			};
213			$this->libContainer[ConfigReader::class] = function () {
214			return new ConfigReader();
215			};
216
217			/*
218			* Services
219			*/
220			// Minifier
221			$this->libContainer[Minifier::class] = function () {
222			return new Minifier();
223			};
224			// Translator
225			$this->libContainer[Translator::class] = function ($c) {
226			return new Translator($c['jaxon.core.translation_dir'], $c[Config::class]);
227			};
228			// Template engine
229			$this->libContainer[TemplateEngine::class] = function ($c) {
230			return new TemplateEngine($c['jaxon.core.template_dir']);
231			};
232			// Template Renderer
233			$this->libContainer[TemplateRenderer::class] = function ($c) {
234			return $c[TemplateEngine::class];
235			};
236			// Validator
237			$this->libContainer[Validator::class] = function ($c) {
238			return new Validator($c[Translator::class], $c[Config::class]);
239			};
240			// Pagination Paginator
241			$this->libContainer[Paginator::class] = function ($c) {
242			return new Paginator($c[PaginationRenderer::class]);
243			};
244			// Pagination Renderer
245			$this->libContainer[PaginationRenderer::class] = function ($c) {
246			return new PaginationRenderer($c[TemplateRenderer::class]);
247			};
248			// Event Dispatcher
249			$this->libContainer[EventDispatcher::class] = function () {
250			return new EventDispatcher();
251			};
252			}
253
254			/**
255			* Get a class instance
256			*
257			* @return object The class instance
258			*/
259			public function get($sClass)
260			{
261			if($this->appContainer != null && $this->appContainer->has($sClass))
262			{
263			return $this->appContainer->get($sClass);
264			}
265			return $this->libContainer[$sClass];
266			}
267
268			/**
269			* Set a DI closure
270			*
271			* @param string $sClass The full class name
272			* @param Closure $xClosure The closure
273			*
274			* @return void
275			*/
276			public function set($sClass, $xClosure)
277			{
278			$this->libContainer[$sClass] = $xClosure;
279			}
280
281			/**
282			* Set an alias
283			*
284			* @param string $sClass The class name
285			* @param string $sAlias The alias name
286			*
287			* @return void
288			*/
289			public function alias($sClass, $sAlias)
290			{
291			$this->libContainer[$sClass] = function ($c) use ($sAlias) {
292			return $c[$sAlias];
293			};
294			}
295
296			/**
297			* Get the plugin manager
298			*
299			* @return PluginManager
300			*/
301			public function getPluginManager()
302			{
303			return $this->libContainer[PluginManager::class];
304			}
305
306			/**
307			* Get the request handler
308			*
309			* @return RequestHandler
310			*/
311			public function getRequestHandler()
312			{
313			return $this->libContainer[RequestHandler::class];
314			}
315
316			/**
317			* Get the request factory
318			*
319			* @return RequestFactory
320			*/
321			public function getRequestFactory()
322			{
323			return $this->libContainer[RequestFactory::class];
324			}
325
326			/**
327			* Get the parameter factory
328			*
329			* @return ParameterFactory
330			*/
331			public function getParameterFactory()
332			{
333			return $this->libContainer[ParameterFactory::class];
334			}
335
336			/**
337			* Get the response manager
338			*
339			* @return ResponseManager
340			*/
341			public function getResponseManager()
342			{
343			return $this->libContainer[ResponseManager::class];
344			}
345
346			/**
347			* Get the code generator
348			*
349			* @return CodeGenerator
350			*/
351			public function getCodeGenerator()
352			{
353			return $this->libContainer[CodeGenerator::class];
354			}
355
356			/**
357			* Get the callable repository
358			*
359			* @return CallableRepository
360			*/
361			public function getCallableRepository()
362			{
363			return $this->libContainer[CallableRepository::class];
364			}
365
366			/**
367			* Get the config manager
368			*
369			* @return Config
370			*/
371			public function getConfig()
372			{
373			return $this->libContainer[Config::class];
374			}
375
376			/**
377			* Create a new the config manager
378			*
379			* @param array $aOptions The options array
380			* @param string $sKeys The keys of the options in the array
381			*
382			* @return Config The config manager
383			*/
384			public function newConfig(array $aOptions = [], $sKeys = '')
385			{
386			return new Config($aOptions, $sKeys);
387			}
388
389			/**
390			* Get the dialog wrapper
391			*
392			* @return Dialog
393			*/
394			public function getDialog()
395			{
396			return $this->libContainer[Dialog::class];
397			}
398
399			/**
400			* Get the minifier
401			*
402			* @return Minifier
403			*/
404			public function getMinifier()
405			{
406			return $this->libContainer[Minifier::class];
407			}
408
409			/**
410			* Get the translator
411			*
412			* @return Translator
413			*/
414			public function getTranslator()
415			{
416			return $this->libContainer[Translator::class];
417			}
418
419			/**
420			* Get the template engine
421			*
422			* @return Engine
423			*/
424			public function getTemplateEngine()
425			{
426			return $this->libContainer[TemplateEngine::class];
427			}
428
429			/**
430			* Get the template renderer
431			*
432			* @return TemplateRenderer
433			*/
434			public function getTemplateRenderer()
435			{
436			return $this->libContainer[TemplateRenderer::class];
437			}
438
439			/**
440			* Get the validator
441			*
442			* @return Validator
443			*/
444			public function getValidator()
445			{
446			return $this->libContainer[Validator::class];
447			}
448
449			/**
450			* Get the paginator
451			*
452			* @return Paginator
453			*/
454			public function getPaginator()
455			{
456			return $this->libContainer[Paginator::class];
457			}
458
459			/**
460			* Get the event dispatcher
461			*
462			* @return EventDispatcher
463			*/
464			public function getEventDispatcher()
465			{
466			return $this->libContainer[EventDispatcher::class];
467			}
468
469			/**
470			* Get the global Response object
471			*
472			* @return Response
473			*/
474			public function getResponse()
475			{
476			return $this->libContainer[Response::class];
477			}
478
479			/**
480			* Create a new Jaxon response object
481			*
482			* @return Response
483			*/
484			public function newResponse()
485			{
486			return new Response();
487			}
488
489			/**
490			* Get the App instance
491			*
492			* @return App
493			*/
494			public function getApp()
495			{
496			return $this->libContainer[App::class];
497			}
498
499			/**
500			* Get the App bootstrap
501			*
502			* @return Bootstrap
503			*/
504			public function getBootstrap()
505			{
506			return $this->libContainer[Bootstrap::class];
507			}
508
509			/**
510			* Get the view manager
511			*
512			* @return ViewManager
513			*/
514			public function getViewManager()
515			{
516			return $this->libContainer[ViewManager::class];
517			}
518
519			/**
520			* Get the view facade
521			*
522			* @return ViewRenderer
523			*/
524			public function getViewRenderer()
525			{
526			return $this->libContainer[ViewRenderer::class];
527			}
528
529			/**
530			* Get the session manager
531			*
532			* @return SessionContract
533			*/
534			public function getSessionManager()
535			{
536			return $this->libContainer[SessionContract::class];
537			}
538
539			/**
540			* Set the session manager
541			*
542			* @param Closure $xClosure A closure to create the session manager instance
543			*
544			* @return void
545			*/
546			public function setSessionManager($xClosure)
547			{
548			$this->libContainer[SessionContract::class] = $xClosure;
549			}
550
551			/**
552			* Set the callable class request factory
553			*
554			* @param string $sClassName The callable class name
555			* @param CallableObject $xCallableObject The corresponding callable object
556			*
557			* @return void
558			*/
559			public function setCallableClassRequestFactory($sClassName, CallableObject $xCallableObject)
560			{
561			$this->libContainer[$sClassName . '_RequestFactory'] = function () use ($xCallableObject) {
562			// $xCallableObject = $c[CallableRepository::class]->getCallableObject($sClassName);
563			return new CallableClassRequestFactory($xCallableObject);
564			};
565			}
566
567			/**
568			* Get the callable class request factory
569			*
570			* @param string $sClassName The callable class name
571			*
572			* @return CallableClassRequestFactory
573			*/
574			public function getCallableClassRequestFactory($sClassName)
575			{
576			return $this->libContainer[$sClassName . '_RequestFactory'];
577			}
578
579			/**
580			* Set the callable class paginator factory
581			*
582			* @param string $sClassName The callable class name
583			* @param CallableObject $xCallableObject The corresponding callable object
584			*
585			* @return void
586			*/
587			public function setCallableClassPaginatorFactory($sClassName, CallableObject $xCallableObject)
588			{
589			$this->libContainer[$sClassName . '_PaginatorFactory'] = function () use ($xCallableObject) {
590			// $xCallableObject = $c[CallableRepository::class]->getCallableObject($sClassName);
591			return new CallableClassPaginatorFactory($xCallableObject);
592			};
593			}
594
595			/**
596			* Get the callable class paginator factory
597			*
598			* @param string $sClassName The callable class name
599			*
600			* @return CallableClassPaginatorFactory
601			*/
602			public function getCallableClassPaginatorFactory($sClassName)
603			{
604			return $this->libContainer[$sClassName . '_PaginatorFactory'];
605			}
606			}
607

jaxon-php / jaxon-core

Push — master ( f42a52...0a9499 )

Container::getViewManager() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like