factory.class.php

Go to the documentation of this file.

<?php
final class factory {

        private static $cfg;

        private static $loadedCfg = array();

        private static $loadedClass = array();

        private static $loadFiles = array();

        private static $cacheLoad = null;

        private static $saveCacheLoad = false;

        private static $constants;


        private function __construct() {}

        public static function init() {
                self::$constants = get_defined_constants(true);
                self::initCache();
                self::$cfg = new config(factory::loadCfg(__CLASS__));
        }

        public static function initCache() {
                self::$saveCacheLoad = false;
                self::$cacheLoad = cache::getInstance();
                self::$cacheLoad->get(self::$loadFiles, array(
                        'ttl'=>0,
                        'id'=>'load',
                        'request'=>array('uri'=>false,'meth'=>array()),
                        'serialize'=>true
                ));
        }

        public static function saveCache() {
                if (self::$saveCacheLoad)
                        self::$cacheLoad->save();
                file::saveCache();
        }

        public static function loadCfg($className, $searchParent=true) {
                if (!array_key_exists($className, self::$loadedCfg)) {
                        self::$loadedCfg[$className] = array();

                        if ($searchParent) {
                                $ref = new nReflection($className);
                                // Load the parent class configuration
                                if ($parent = $ref->getParentClass())
                                                self::mergeCfg(self::$loadedCfg[$className], self::loadCfg($parent->getName()));

                                // Load the implements class configuration
                                if (count($implements = $ref->getInterfaces()) > 0)
                                        foreach($implements as $imp)
                                                self::mergeCfg(self::$loadedCfg[$className], self::loadCfg($imp->getName()));
                        }

                        $listCfg = file::nyroExists(Array(
                                'name'=>$className,
                                'type'=>'cfg',
                                'rtl'=>false,
                                'list'=>true
                        ));

                        if (!empty($listCfg))
                                foreach($listCfg as $lc) {
                                        include($lc);
                                        if (isset($cfg))
                                                self::mergeCfg(self::$loadedCfg[$className], $cfg, $className);
                                        $cfg = null;
                                }
                        self::mergeCfg(self::$loadedCfg[$className], nyro::getGlobalCfg($className));
                        self::removeKeepUnique(self::$loadedCfg[$className]);
                }
                return self::$loadedCfg[$className];
        }

        public static function mergeCfg(array &$prm, array $cfg) {
                if (!array_key_exists(REPLACECONF, $cfg)) {
                        $keepUnique = array_key_exists(KEEPUNIQUE, $prm);
                        foreach($cfg as $k=>&$v) {
                                if (is_numeric($k) && !$keepUnique) {
                                        $prm[] = &$v;
                                } else if (is_array($v) && array_key_exists($k, $prm) && is_array($prm[$k]))
                                        self::mergeCfg($prm[$k], $v);
                                else
                                        $prm[$k] = &$v;
                        }
                } else {
                        unset($cfg[REPLACECONF]);
                        $prm = $cfg;
                }
        }

        private static function removeKeepUnique(array &$prm) {
                unset($prm[KEEPUNIQUE]);
                foreach($prm as &$v) {
                        if (is_array($v))
                                self::removeKeepUnique($v);
                }
        }

        public static function get($className, array $cfg = array()) {
                self::load($className);
                $ref = new nReflection();
                if ($ref->rebuild($className)) {
                        $prm = self::loadCfg($className);
                        self::mergeCfg($prm, $cfg);
                        $inst = $ref->newInstanceCfg(new config($prm));
                        return $inst;
                } else
                        throw new nException('Factory - load: Unable to bluid '.$className.'.');
        }

        public static function getHelper($className, array $cfg = array()) {
                return self::get('helper_'.$className, $cfg);
        }

        public static function getModule($name, array $cfg=array(), &$scaffold = false, $allowScaffold=true) {
                $className = 'module_'.$name.'_controller';
                if (!self::isCreable($className)) {
                        if ($allowScaffold && in_array($name, db::getInstance()->getTables())) {
                                $className = self::$cfg->scaffoldController;
                                $cfg['name'] = $name;
                                $scaffold = true;
                        } else
                                throw new module_exception('Factory - getModule: Name '.$name.' unknown.');
                }
                return self::get($className, $cfg);
        }

        public static function load($className) {
                if (!class_exists($className) && !in_array($className, self::$loadedClass)) {
                        if (!array_key_exists($className, self::$loadFiles)) {
                                if ($file = file::nyroExists(array('name'=>$className))) {
                                        require($file);
                                        self::$loadFiles[$className] = array($file);
                                        self::$saveCacheLoad = true;
                                        self::$loadedClass[] = $className;

                                        if (defined('RUNKIT_VERSION')) {
                                                $filesExtend = file::nyroExists(Array(
                                                        'name'=>$className,
                                                        'type'=>'extend',
                                                        'rtl'=>false,
                                                        'list'=>true
                                                ));
                                                if (!empty($filesExtend)) {
                                                        self::$loadFiles[$className][1] = $filesExtend;
                                                        foreach($filesExtend as $fe)
                                                                runkit_import($fe);
                                                }
                                        }
                                } else if (!lib::load($className)) {
                                        throw new nException('Factory - load: Unable to find the file for '.$className.'.');
                                }
                        } else {
                                require(self::$loadFiles[$className][0]);
                                self::$loadedClass[] = $className;
                                if (defined('RUNKIT_VERSION') && array_key_exists(1, self::$loadFiles[$className])) {
                                        foreach(self::$loadFiles[$className][1] as $fe)
                                                runkit_import($fe);
                                }
                        }
                }
                return true;
        }

        public static function isCreable($className) {
                return (file::nyroExists(array('name'=>$className)) !== false);
        }

}