Engine

Package engine
Inheritance class Engine » LsObject
Since 1.0
Source Code /engine/classes/Engine.class.php
Основной класс движка. Ядро.

Производит инициализацию плагинов, модулей, хуков. Через этот класс происходит выполнение методов всех модулей, которые вызываются как 
$this->Module_Method();
Также отвечает за автозагрузку остальных классов движка.

В произвольном месте (не в классах движка у которых нет обработки метода __call() на выполнение модулей) метод модуля можно вызвать так: 
Engine::getInstance()->Module_Method();

Public Properties

Hide inherited properties

PropertyTypeDescriptionDefined By
iTimeLoadModule int Время загрузки модулей в микросекундах Engine

Protected Properties

Hide inherited properties

PropertyTypeDescriptionDefined By
aConfigModule array Содержит конфиг модулей. Engine
aModules array Список загруженных модулей Engine
aPlugins array Список загруженных плагинов Engine
iTimeInit int|null Текущее время в микросекундах на момент инициализации ядра(движка). Engine
oInstance Engine Текущий экземпляр движка, используется для синглтона. Engine

Public Methods

Hide inherited methods

MethodDescriptionDefined By
GetActionName() Возвращает имя экшена Engine
GetClassInfo() Возвращает информацию об объекта или классе Engine
GetClassPath() Возвращает информацию о пути до файла класса. Engine
GetEntity() Создает объект сущности, контролируя варианты кастомизации Engine
GetEntityName() Возвращает имя сущности Engine
GetMapper() Получает объект маппера Engine
GetModule() Возвращает объект модуля, имя модуля и имя вызванного метода Engine
GetModuleName() Возвращает имя модуля Engine
GetModuleObject() Возвращает объект модуля Engine
GetPluginName() Возвращает имя плагина моудля если модул принадлежит плагину. Engine
GetPluginPrefix() Возвращает префикс плагина Engine
GetPlugins() Возвращает список активных плагинов Engine
GetTimeInit() Возвращает время старта выполнения движка в микросекундах Engine
Init() Инициализация ядра движка Engine
LoadModule() Выполняет загрузку модуля по его названию Engine
Shutdown() Завершение работы движка Engine
_CallModule() Вызывает метод нужного модуля Engine
__call() Ставим хук на вызов неизвестного метода и считаем что хотели вызвать метод какого либо модуля Engine
autoload() Автозагрузка классов Engine
getInstance() Ограничиваем объект только одним экземпляром. Engine
getStats() Возвращает статистику выполнения Engine
isFileExists() Проверяет файл на существование, если используется кеширование memcache то кеширует результат работы Engine
isInitModule() Проверяет модуль на инициализацию Engine

Protected Methods

Hide inherited methods

MethodDescriptionDefined By
InitHooks() Регистрирует хуки из /classes/hooks/ Engine
InitModule() Инициализирует модуль Engine
InitModules() Производит инициализацию всех модулей Engine
InitPluginHooks() Инициализация хуков активированных плагинов Engine
InitPlugins() Инициализация активированных(загруженных) плагинов Engine
LoadConfig() Выполняет загрузку конфигов Engine
LoadModules() Загружает модули из авто-загрузки и передает им в конструктор ядро Engine
LoadPlugins() Загрузка плагинов и делегирование Engine
ShutdownModules() Завершаем работу всех модулей Engine
__clone() Блокируем копирование/клонирование объекта ядра Engine
__construct() Вызывается при создании объекта ядра. Engine

Property Details

aConfigModule property
protected array $aConfigModule;

Содержит конфиг модулей. Используется для получания списка модулей для авто-загрузки. Остальные модули загружаются при первом обращении. В конфиге определен так: 

$config['module']['autoLoad'] = array('Hook','Cache','Security','Session','Lang','Message','User');

aModules property
protected array $aModules;

Список загруженных модулей

aPlugins property
protected array $aPlugins;

Список загруженных плагинов

iTimeInit property
protected int|null $iTimeInit;

Текущее время в микросекундах на момент инициализации ядра(движка). Определается так: 

$this->iTimeInit=microtime(true);

iTimeLoadModule property
public int $iTimeLoadModule;

Время загрузки модулей в микросекундах

oInstance property
protected static Engine $oInstance;

Текущий экземпляр движка, используется для синглтона.

See Also

Method Details

GetActionName() method
public static string|null GetActionName($oAction $oAction)
$oAction $oAction Объект экшена
{return} string|null
Source Code: /engine/classes/Engine.class.php#871 (show)
public static function GetActionName($oAction) {
    return self::GetClassInfo($oAction, self::CI_ACTION, true);
}

Возвращает имя экшена

GetClassInfo() method
public static array|string|null GetClassInfo(LsObject|string $oObject, int $iFlag=8191, bool $bSingle=false)
$oObject LsObject|string Объект или имя класса
$iFlag int Маска по которой нужно вернуть рузультат. Доступные маски определены в константах CI_* Например, получить информацию о плагине и модуле: 
Engine::GetClassInfo($oObject,Engine::CI_PLUGIN | Engine::CI_MODULE);
$bSingle bool Возвращать полный результат или только первый элемент
{return} array|string|null
Source Code: /engine/classes/Engine.class.php#888 (show)
public static function GetClassInfo($oObject,$iFlag=self::CI_DEFAULT,$bSingle=false){
    $sClassName = is_string($oObject) ? $oObject : get_class($oObject);
    $aResult = array();
    if($iFlag & self::CI_PLUGIN){
        $aResult[self::CI_PLUGIN] = preg_match('/^Plugin([^_]+)/',$sClassName,$aMatches)
            ? $aMatches[1]
            : null
        ;
    }
    if($iFlag & self::CI_ACTION){
        $aResult[self::CI_ACTION] = preg_match('/^(?:Plugin[^_]+_|)Action([^_]+)/',$sClassName,$aMatches)
            ? $aMatches[1]
            : null
        ;
    }
    if($iFlag & self::CI_MODULE){
        $aResult[self::CI_MODULE] = preg_match('/^(?:Plugin[^_]+_|)Module(?:ORM|)([^_]+)/',$sClassName,$aMatches)
            ? $aMatches[1]
            : null
        ;
    }
    if($iFlag & self::CI_ENTITY){
        $aResult[self::CI_ENTITY] = preg_match('/_Entity(?:ORM|)([^_]+)/',$sClassName,$aMatches)
            ? $aMatches[1]
            : null
        ;
    }
    if($iFlag & self::CI_MAPPER){
        $aResult[self::CI_MAPPER] = preg_match('/_Mapper(?:ORM|)([^_]+)/',$sClassName,$aMatches)
            ? $aMatches[1]
            : null
        ;
    }
    if($iFlag & self::CI_HOOK){
        $aResult[self::CI_HOOK] = preg_match('/^(?:Plugin[^_]+_|)Hook([^_]+)$/',$sClassName,$aMatches)
            ? $aMatches[1]
            : null
        ;
    }
    if($iFlag & self::CI_BLOCK){
        $aResult[self::CI_BLOCK] = preg_match('/^(?:Plugin[^_]+_|)Block([^_]+)$/',$sClassName,$aMatches)
            ? $aMatches[1]
            : null
        ;
    }
    if($iFlag & self::CI_METHOD){
        $sModuleName = isset($aResult[self::CI_MODULE])
            ? $aResult[self::CI_MODULE]
            : self::GetClassInfo($sClassName, self::CI_MODULE, true)
        ;
        $aResult[self::CI_METHOD] = preg_match('/_([^_]+)$/',$sClassName,$aMatches)
            ? ($sModuleName && strtolower($aMatches[1]) == strtolower('module'.$sModuleName)
                ? null
                : $aMatches[1]
            )
            : null
        ;
    }
    if($iFlag & self::CI_PPREFIX){
        $sPluginName = isset($aResult[self::CI_PLUGIN])
            ? $aResult[self::CI_PLUGIN]
            : self::GetClassInfo($sClassName, self::CI_PLUGIN, true)
        ;
        $aResult[self::CI_PPREFIX] = $sPluginName
            ? "Plugin{$sPluginName}_"
            : ''
        ;
    }
    if($iFlag & self::CI_INHERIT){
        $aResult[self::CI_INHERIT] = preg_match('/_Inherits?_(\w+)$/',$sClassName,$aMatches)
            ? $aMatches[1]
            : null
        ;
    }
    if($iFlag & self::CI_INHERITS){
        $sInherit = isset($aResult[self::CI_INHERIT])
            ? $aResult[self::CI_INHERIT]
            : self::GetClassInfo($sClassName, self::CI_INHERIT, true)
        ;
        $aResult[self::CI_INHERITS] = $sInherit
            ? self::GetClassInfo(
                $sInherit,
                self::CI_OBJECT,
                false)
            : null
        ;
    }
    if($iFlag & self::CI_CLASSPATH){
        $aResult[self::CI_CLASSPATH] = self::GetClassPath($sClassName);
    }

    return $bSingle ? array_pop($aResult) : $aResult;
}

Возвращает информацию об объекта или классе

GetClassPath() method
public static null|string GetClassPath(LsObject $oObject)
$oObject LsObject Объект - модуль, экшен, плагин, хук, сущность
{return} null|string
Source Code: /engine/classes/Engine.class.php#990 (show)
public static function GetClassPath($oObject){
    $aInfo = self::GetClassInfo(
        $oObject,
        self::CI_OBJECT
    );
    $sPath = Config::get('path.root.server').'/';
    if($aInfo[self::CI_ENTITY]){
        // Сущность
        if($aInfo[self::CI_PLUGIN]){
            // Сущность модуля плагина
            $sPath .= 'plugins/'.func_underscore($aInfo[self::CI_PLUGIN])
                .'/classes/modules/'.strtolower($aInfo[self::CI_MODULE])
                .'/entity/'.$aInfo[self::CI_ENTITY].'.entity.class.php'
            ;
        }else{
            // Сущность модуля ядра
            $sPath .= 'classes/modules/'.strtolower($aInfo[self::CI_MODULE])
                .'/entity/'.$aInfo[self::CI_ENTITY].'.entity.class.php'
            ;
            if(!is_file($sPath)){
                $sPath = str_replace('/classes/modules/','/engine/modules/',$sPath);
            }
        }
    }elseif($aInfo[self::CI_MAPPER]){
        // Маппер
        if($aInfo[self::CI_PLUGIN]){
            // Маппер модуля плагина
            $sPath .= 'plugins/'.func_underscore($aInfo[self::CI_PLUGIN])
                .'/classes/modules/'.strtolower($aInfo[self::CI_MODULE])
                .'/mapper/'.$aInfo[self::CI_MAPPER].'.mapper.class.php'
            ;
        }else{
            // Маппер модуля ядра
            $sPath .= 'classes/modules/'.strtolower($aInfo[self::CI_MODULE])
                .'/mapper/'.$aInfo[self::CI_MAPPER].'.mapper.class.php'
            ;
            if(!is_file($sPath)){
                $sPath = str_replace('/classes/modules/','/engine/modules/',$sPath);
            }
        }
    }elseif($aInfo[self::CI_ACTION]){
        // Экшн
        if($aInfo[self::CI_PLUGIN]){
            // Экшн плагина
            $sPath .= 'plugins/'.func_underscore($aInfo[self::CI_PLUGIN])
                .'/classes/actions/Action'.$aInfo[self::CI_ACTION].'.class.php'
            ;
        }else{
            // Экшн ядра
            $sPath .= 'classes/actions/Action'
                .$aInfo[self::CI_ACTION].'.class.php'
            ;
        }
    }elseif($aInfo[self::CI_MODULE]){
        // Модуль
        if($aInfo[self::CI_PLUGIN]){
            // Модуль плагина
            $sPath .= 'plugins/'.func_underscore($aInfo[self::CI_PLUGIN])
                .'/classes/modules/'.strtolower($aInfo[self::CI_MODULE])
                .'/'.$aInfo[self::CI_MODULE].'.class.php';
            ;
        }else{
            // Модуль ядра
            $sPath .= 'classes/modules/'.strtolower($aInfo[self::CI_MODULE])
                .'/'.$aInfo[self::CI_MODULE].'.class.php'
            ;
            if(!is_file($sPath)){
                $sPath = str_replace('/classes/modules/','/engine/modules/',$sPath);
            }
        }
    }elseif($aInfo[self::CI_HOOK]){
        // Хук
        if($aInfo[self::CI_PLUGIN]){
            // Хук плагина
            $sPath .= 'plugins/'.func_underscore($aInfo[self::CI_PLUGIN])
                .'/classes/hooks/Hook'.$aInfo[self::CI_HOOK]
                .'.class.php';
            ;
        }else{
            // Хук ядра
            $sPath .= 'classes/hooks/Hook'.$aInfo[self::CI_HOOK].'.class.php';
        }
    }elseif($aInfo[self::CI_BLOCK]){
        // Блок
        if($aInfo[self::CI_PLUGIN]){
            // Блок плагина
            $sPath .= 'plugins/'.func_underscore($aInfo[self::CI_PLUGIN])
                .'/classes/blocks/Block'.$aInfo[self::CI_BLOCK]
                .'.class.php';
            ;
        }else{
            // Блок ядра
            $sPath .= 'classes/blocks/Block'.$aInfo[self::CI_BLOCK].'.class.php';
        }
    }elseif($aInfo[self::CI_PLUGIN]){
        // Плагин
        $sPath .= 'plugins/'.func_underscore($aInfo[self::CI_PLUGIN])
            .'/Plugin'.$aInfo[self::CI_PLUGIN]
            .'.class.php';
        ;
    }else{
        $sClassName = is_string($oObject) ? $oObject : get_class($oObject);
        $sPath .= 'engine/classes/'.$sClassName.'.class.php';
    }
    return is_file($sPath) ? $sPath : null;
}

Возвращает информацию о пути до файла класса. Используется в автозагрузке

GetEntity() method
public static Entity GetEntity(string $sName, array $aParams=array ( ))
$sName string Имя сущности, возможны сокращенные варианты. Например 
ModuleUser_EntityUser
эквивалентно 
User_User
и эквивалентно 
User
т.к. имя сущности совпадает с именем модуля
$aParams array
{return} Entity
Source Code: /engine/classes/Engine.class.php#718 (show)
public static function GetEntity($sName,$aParams=array()) {
    /**
     * Сущности, имеющие такое же название как модуль,
     * можно вызывать сокращенно. Например, вместо User_User -> User
     */
    switch (substr_count($sName,'_')) {
        case 0:
            $sEntity = $sModule = $sName;
            break;

        case 1:
            /**
             * Поддержка полного синтаксиса при вызове сущности
             */
            $aInfo = self::GetClassInfo(
                $sName,
                self::CI_ENTITY
                    |self::CI_MODULE
                    |self::CI_PLUGIN
            );
            if ($aInfo[self::CI_MODULE]
                && $aInfo[self::CI_ENTITY]) {
                $sName=$aInfo[self::CI_MODULE].'_'.$aInfo[self::CI_ENTITY];
            }

            list($sModule,$sEntity) = explode('_',$sName,2);
            /**
             * Обслуживание короткой записи сущностей плагинов
             * PluginTest_Test -> PluginTest_ModuleTest_EntityTest
             */
            if($aInfo[self::CI_PLUGIN]) {
                $sPlugin = $aInfo[self::CI_PLUGIN];
                $sModule = $sEntity;
            }
            break;

        case 2:
            /**
             * Поддержка полного синтаксиса при вызове сущности плагина
             */
            $aInfo = self::GetClassInfo(
                $sName,
                self::CI_ENTITY
                    |self::CI_MODULE
                    |self::CI_PLUGIN
            );
            if ($aInfo[self::CI_PLUGIN]
                && $aInfo[self::CI_MODULE]
                && $aInfo[self::CI_ENTITY]) {
                $sName='Plugin'.$aInfo[self::CI_PLUGIN]
                    .'_'.$aInfo[self::CI_MODULE]
                    .'_'.$aInfo[self::CI_ENTITY]
                ;
            }
            /**
             * Entity плагина
             */
            if($aInfo[self::CI_PLUGIN]) {
                list(,$sModule,$sEntity)=explode('_',$sName);
                $sPlugin = $aInfo[self::CI_PLUGIN];
            } else {
                throw new Exception("Unknown entity '{$sName}' given.");
            }
            break;

        default:
            throw new Exception("Unknown entity '{$sName}' given.");
    }

    $sClass=isset($sPlugin)
        ? 'Plugin'.$sPlugin.'_Module'.$sModule.'_Entity'.$sEntity
        : 'Module'.$sModule.'_Entity'.$sEntity;

    /**
     * If Plugin Entity doesn't exist, search among it's Module delegates
     */
    if(isset($sPlugin) && !self::GetClassPath($sClass)) {
        $aModulesChain = Engine::GetInstance()->Plugin_GetDelegationChain('module','Plugin'.$sPlugin.'_Module'.$sModule);
        foreach($aModulesChain as $sModuleName) {
            $sClassTest=$sModuleName.'_Entity'.$sEntity;
            if(self::GetClassPath($sClassTest)) {
                $sClass=$sClassTest;
                break;
            }
        }
        if(!self::GetClassPath($sClass)) {
            $sClass='Module'.$sModule.'_Entity'.$sEntity;
        }
    }

    /**
     * Определяем наличие делегата сущности
     * Делегирование указывается только в полной форме!
     */
    $sClass=self::getInstance()->Plugin_GetDelegate('entity',$sClass);

    $oEntity=new $sClass($aParams);
    return $oEntity;
}

Создает объект сущности, контролируя варианты кастомизации

GetEntityName() method
public static string|null GetEntityName(Entity $oEntity)
$oEntity Entity Объект сущности
{return} string|null
Source Code: /engine/classes/Engine.class.php#860 (show)
public static function GetEntityName($oEntity) {
    return self::GetClassInfo($oEntity, self::CI_ENTITY, true);
}

Возвращает имя сущности

GetMapper() method
public static mixed GetMapper(string $sClassName, string|null $sName=NULL, DbSimple_Mysql|null $oConnect=NULL)
$sClassName string Класс модуля маппера
$sName string|null Имя маппера
$oConnect DbSimple_Mysql|null Объект коннекта к БД Можно получить так: 
Engine::getInstance()->Database_GetConnect($aConfig);
{return} mixed
Source Code: /engine/classes/Engine.class.php#690 (show)
public static function GetMapper($sClassName,$sName=null,$oConnect=null) {
    $sModuleName = self::GetClassInfo(
        $sClassName,
        self::CI_MODULE,
        true
    );
    if ($sModuleName) {
        if (!$sName) {
            $sName=$sModuleName;
        }
        $sClass=$sClassName.'_Mapper'.$sName;
        if (!$oConnect) {
            $oConnect=Engine::getInstance()->Database_GetConnect();
        }
        $sClass=self::getInstance()->Plugin_GetDelegate('mapper',$sClass);
        return new $sClass($oConnect);
    }
    return null;
}

Получает объект маппера

GetModule() method
public array GetModule(string $sName)
$sName string Имя метода модуля в полном виде Например 
Module_Method
{return} array
Source Code: /engine/classes/Engine.class.php#576 (show)
public function GetModule($sName) {
    /**
     * Поддержка полного синтаксиса при вызове метода модуля
     */
    $aInfo = self::GetClassInfo(
        $sName,
        self::CI_MODULE
            |self::CI_PPREFIX
            |self::CI_METHOD
    );
    if($aInfo[self::CI_MODULE] && $aInfo[self::CI_METHOD]){
        $sName = $aInfo[self::CI_MODULE].'_'.$aInfo[self::CI_METHOD];
        if($aInfo[self::CI_PPREFIX]){
            $sName = $aInfo[self::CI_PPREFIX].$sName;
        }
    }

    $aName=explode("_",$sName);

    if(count($aName)==2) {
        $sModuleName=$aName[0];
        $sModuleClass='Module'.$aName[0];
        $sMethod=$aName[1];
    } elseif (count($aName)==3) {
        $sModuleName=$aName[0].'_'.$aName[1];
        $sModuleClass=$aName[0].'_Module'.$aName[1];
        $sMethod=$aName[2];
    } else {
        throw new Exception("Undefined method module: ".$sName);
    }
    /**
     * Подхватыем делегат модуля (в случае наличия такового)
     */
    if(!in_array($sModuleName,array('Plugin','Hook'))){
        $sModuleClass=$this->Plugin_GetDelegate('module',$sModuleClass);
    }

    if (isset($this->aModules[$sModuleClass])) {
        $oModule=$this->aModules[$sModuleClass];
    } else {
        $oModule=$this->LoadModule($sModuleClass,true);
    }

    return array($oModule,$sModuleName,$sMethod);
}

Возвращает объект модуля, имя модуля и имя вызванного метода

GetModuleName() method
public static string|null GetModuleName(Module $oModule)
$oModule Module Объект модуля
{return} string|null
Source Code: /engine/classes/Engine.class.php#849 (show)
public static function GetModuleName($oModule) {
    return self::GetClassInfo($oModule, self::CI_MODULE, true);
}

Возвращает имя модуля

GetModuleObject() method
public void GetModuleObject(string $sName)
$sName string Имя модуля
Source Code: /engine/classes/Engine.class.php#627 (show)
public function GetModuleObject($sName) {
    if(self::GetPluginPrefix($sName)){
        if(substr_count($sName,'_')<2) {
            $sName.='_x';
        }
    } else {
        if(substr_count($sName,'_')<1) {
            $sName.='_x';
        }
    }
    $aCallArray=$this->GetModule($sName);
    return $aCallArray[0];
}

Возвращает объект модуля

GetPluginName() method
public static string|null GetPluginName(Module $oModule)
$oModule Module Объект модуля
{return} string|null
Source Code: /engine/classes/Engine.class.php#826 (show)
public static function GetPluginName($oModule) {
    return self::GetClassInfo($oModule, self::CI_PLUGIN, true);
}

Возвращает имя плагина моудля если модул принадлежит плагину. Например 

Openid

GetPluginPrefix() method
public static string GetPluginPrefix(Module $oModule)
$oModule Module Объект модуля
{return} string Если плагина нет, возвращает пустую строку
Source Code: /engine/classes/Engine.class.php#838 (show)
public static function GetPluginPrefix($oModule) {
    return self::GetClassInfo($oModule, self::CI_PPREFIX, true);
}

Возвращает префикс плагина Например 

PluginOpenid_

GetPlugins() method
public array GetPlugins()
{return} array
Source Code: /engine/classes/Engine.class.php#494 (show)
public function GetPlugins() {
    return $this->aPlugins;
}

Возвращает список активных плагинов

GetTimeInit() method
public int GetTimeInit()
{return} int
Source Code: /engine/classes/Engine.class.php#655 (show)
public function GetTimeInit() {
    return $this->iTimeInit;
}

Возвращает время старта выполнения движка в микросекундах

Init() method
public void Init()
Source Code: /engine/classes/Engine.class.php#234 (show)
public function Init() {
    /**
     * Загружаем плагины
     */
    $this->LoadPlugins();
    /**
     * Инициализируем хуки
     */
    $this->InitHooks();
    /**
     * Загружаем модули автозагрузки
     */
    $this->LoadModules();
    /**
     * Инициализируем загруженные модули
     */
    $this->InitModules();
    /**
     * Инициализируем загруженные плагины
     */
    $this->InitPlugins();
    /**
     * Запускаем хуки для события завершения инициализации Engine
     */
    $this->Hook_Run('engine_init_complete');
}

Инициализация ядра движка

InitHooks() method
protected void InitHooks()
Source Code: /engine/classes/Engine.class.php#418 (show)
protected function InitHooks() {
    $sDirHooks=Config::Get('path.root.server').'/classes/hooks/';
    $aFiles=glob($sDirHooks.'Hook*.class.php');

    if($aFiles and count($aFiles)) {
        foreach ($aFiles as $sFile) {
            if (preg_match("/Hook([^_]+)\.class\.php$/i",basename($sFile),$aMatch)) {
                //require_once($sFile);
                $sClassName='Hook'.$aMatch[1];
                $oHook=new $sClassName;
                $oHook->RegisterHook();
            }
        }
    }

    /**
     * Подгружаем хуки активных плагинов
     */
    $this->InitPluginHooks();
}

Регистрирует хуки из /classes/hooks/

InitModule() method
protected void InitModule(Module $oModule, bool $bHookParent=true)
$oModule Module Объект модуля
$bHookParent bool Вызывает хук на родительском модуле, от которого наследуется текущий
Source Code: /engine/classes/Engine.class.php#294 (show)
protected function InitModule($oModule, $bHookParent = true){
    $sOrigClassName = $sClassName = get_class($oModule);
    $bRunHooks = false;

    if($this->isInitModule('ModuleHook')){
        $bRunHooks = true;
        if($bHookParent){
            while(self::GetPluginName($sClassName)){
                $sParentClassName = get_parent_class($sClassName);
                if(!self::GetClassInfo($sParentClassName, self::CI_MODULE, true)){
                    break;
                }
                $sClassName = $sParentClassName;
            }
        }
    }
    if($bRunHooks || $sClassName == 'ModuleHook'){
        $sHookPrefix = 'module_';
        if($sPluginName = self::GetPluginName($sClassName)){
            $sHookPrefix .= "plugin{$sPluginName}_";
        }
        $sHookPrefix .= self::GetModuleName($sClassName).'_init_';
    }
    if($bRunHooks){
        $this->Hook_Run($sHookPrefix.'before');
    }
    $oModule->Init();
    $oModule->SetInit();
    if($bRunHooks || $sClassName == 'ModuleHook'){
        $this->Hook_Run($sHookPrefix.'after');
    }
}

Инициализирует модуль

InitModules() method
protected void InitModules()
Source Code: /engine/classes/Engine.class.php#272 (show)
protected function InitModules() {
    foreach ($this->aModules as $oModule) {
        if(!$oModule->isInit()) {
            /**
             * Замеряем время инициализации модуля
             */
            $oProfiler=ProfilerSimple::getInstance();
            $iTimeId=$oProfiler->Start('InitModule',get_class($oModule));

            $this->InitModule($oModule);

            $oProfiler->Stop($iTimeId);
        }
    }
}

Производит инициализацию всех модулей

InitPluginHooks() method
protected void InitPluginHooks()
Source Code: /engine/classes/Engine.class.php#443 (show)
protected function InitPluginHooks() {
    if($aPluginList = func_list_plugins()) {
        $sDirHooks=Config::Get('path.root.server').'/plugins/';

        foreach ($aPluginList as $sPluginName) {
            $aFiles=glob($sDirHooks.$sPluginName.'/classes/hooks/Hook*.class.php');
            if($aFiles and count($aFiles)) {
                foreach ($aFiles as $sFile) {
                    if (preg_match("/Hook([^_]+)\.class\.php$/i",basename($sFile),$aMatch)) {
                        //require_once($sFile);
                        $sPluginName = func_camelize($sPluginName);
                        $sClassName="Plugin{$sPluginName}_Hook{$aMatch[1]}";
                        $oHook=new $sClassName;
                        $oHook->RegisterHook();
                    }
                }
            }
        }
    }
}

Инициализация хуков активированных плагинов

InitPlugins() method
protected void InitPlugins()
Source Code: /engine/classes/Engine.class.php#483 (show)
protected function InitPlugins() {
    foreach ($this->aPlugins as $oPlugin) {
        $oPlugin->Init();
    }
}

Инициализация активированных(загруженных) плагинов

LoadConfig() method
protected void LoadConfig()
Source Code: /engine/classes/Engine.class.php#411 (show)
protected function LoadConfig() {
    $this->aConfigModule = Config::Get('module');
}

Выполняет загрузку конфигов

LoadModule() method
public Module LoadModule(string $sModuleClass, bool $bInit=false)
$sModuleClass string Класс модуля
$bInit bool Инициализировать модуль или нет
{return} Module
Source Code: /engine/classes/Engine.class.php#371 (show)
public function LoadModule($sModuleClass,$bInit=false) {
    $tm1=microtime(true);

    if (!class_exists($sModuleClass))
    {
        throw new RuntimeException(sprintf('Class "%s" not found!', $sModuleClass));
    }
    /**
     * Создаем объект модуля
     */
    $oModule=new $sModuleClass($this);
    $this->aModules[$sModuleClass]=$oModule;
    if ($bInit or $sModuleClass=='ModuleCache') {
        $this->InitModule($oModule);
    }
    $tm2=microtime(true);
    $this->iTimeLoadModule+=$tm2-$tm1;
    dump("load $sModuleClass - \t\t".($tm2-$tm1)."");
    return $oModule;
}

Выполняет загрузку модуля по его названию

LoadModules() method
protected void LoadModules()
Source Code: /engine/classes/Engine.class.php#396 (show)
protected function LoadModules() {
    $this->LoadConfig();
    foreach ($this->aConfigModule['autoLoad'] as $sModuleName) {
        $sModuleClass='Module'.$sModuleName;
        if(!in_array($sModuleName,array('Plugin','Hook'))) $sModuleClass=$this->Plugin_GetDelegate('module',$sModuleClass);

        if (!isset($this->aModules[$sModuleClass])) {
            $this->LoadModule($sModuleClass);
        }
    }
}

Загружает модули из авто-загрузки и передает им в конструктор ядро

LoadPlugins() method
protected void LoadPlugins()
Source Code: /engine/classes/Engine.class.php#468 (show)
protected function LoadPlugins() {
    if($aPluginList = func_list_plugins()) {
        foreach ($aPluginList as $sPluginName) {
            $sClassName='Plugin'.func_camelize($sPluginName);
            $oPlugin=new $sClassName;
            $oPlugin->Delegate();
            $this->aPlugins[$sPluginName]=$oPlugin;
        }
    }
}

Загрузка плагинов и делегирование

Shutdown() method
public void Shutdown()
Source Code: /engine/classes/Engine.class.php#265 (show)
public function Shutdown() {
    $this->ShutdownModules();
}

Завершение работы движка Завершает все модули.

ShutdownModules() method
protected void ShutdownModules()
Source Code: /engine/classes/Engine.class.php#347 (show)
protected function ShutdownModules() {
    foreach ($this->aModules as $sKey => $oModule) {
        /**
         * Замеряем время shutdown`a модуля
         */
        $oProfiler=ProfilerSimple::getInstance();
        $iTimeId=$oProfiler->Start('ShutdownModule',get_class($oModule));

        $oModule->Shutdown();

        $oProfiler->Stop($iTimeId);
    }
}

Завершаем работу всех модулей

_CallModule() method
public mixed _CallModule(string $sName, array $aArgs)
$sName string Название метода в полном виде. Например 
Module_Method
$aArgs array Список аргументов
{return} mixed
Source Code: /engine/classes/Engine.class.php#530 (show)
public function _CallModule($sName,$aArgs) {
    list($oModule,$sModuleName,$sMethod)=$this->GetModule($sName);

    if (!method_exists($oModule,$sMethod)) {
        // comment for ORM testing
        //throw new Exception("The module has no required method: ".$sModuleName.'->'.$sMethod.'()');
    }
    /**
     * Замеряем время выполнения метода
     */
    $oProfiler=ProfilerSimple::getInstance();
    $iTimeId=$oProfiler->Start('callModule',$sModuleName.'->'.$sMethod.'()');

    $sModuleName=strtolower($sModuleName);
    $aResultHook=array();
    if (!in_array($sModuleName,array('plugin','hook'))) {
        $aResultHook=$this->_CallModule('Hook_Run',array('module_'.$sModuleName.'_'.strtolower($sMethod).'_before',&$aArgs));
    }
    /**
     * Хук может делегировать результат выполнения метода модуля, сам метод при этом не выполняется, происходит только подмена результата
     */
    if (array_key_exists('delegate_result',$aResultHook)) {
        $result=$aResultHook['delegate_result'];
    } else {
        $aArgsRef=array();
        foreach ($aArgs as $key=>$v) {
            $aArgsRef[]=&$aArgs[$key];
        }
        $result=call_user_func_array(array($oModule,$sMethod),$aArgsRef);
    }

    if (!in_array($sModuleName,array('plugin','hook'))) {
        $this->Hook_Run('module_'.$sModuleName.'_'.strtolower($sMethod).'_after',array('result'=>&$result,'params'=>$aArgs));
    }

    $oProfiler->Stop($iTimeId);
    return $result;
}

Вызывает метод нужного модуля

__call() method
public mixed __call(string $sName, array $aArgs)
$sName string Имя метода
$aArgs array Аргументы
{return} mixed
Source Code: /engine/classes/Engine.class.php#666 (show)
public function __call($sName,$aArgs) {
    return $this->_CallModule($sName,$aArgs);
}

Ставим хук на вызов неизвестного метода и считаем что хотели вызвать метод какого либо модуля

__clone() method
protected void __clone()
Source Code: /engine/classes/Engine.class.php#674 (show)
protected function __clone() {

}

Блокируем копирование/клонирование объекта ядра

__construct() method
protected void __construct()
Source Code: /engine/classes/Engine.class.php#200 (show)
protected function __construct() {
    $this->iTimeInit=microtime(true);
    if (get_magic_quotes_gpc()) {
        func_stripslashes($_REQUEST);
        func_stripslashes($_GET);
        func_stripslashes($_POST);
        func_stripslashes($_COOKIE);
    }
}

Вызывается при создании объекта ядра. Устанавливает время старта инициализации и обрабатывает входные параметры PHP

autoload() method
public static bool autoload(string $sClassName)
$sClassName string Название класса
{return} bool
Source Code: /engine/classes/Engine.class.php#1104 (show)
public static function autoload($sClassName) {
    $aInfo = Engine::GetClassInfo(
        $sClassName,
        Engine::CI_CLASSPATH|Engine::CI_INHERIT
    );
    if($aInfo[Engine::CI_INHERIT]){
        $sInheritClass = $aInfo[Engine::CI_INHERIT];
        $sParentClass = Engine::getInstance()->Plugin_GetParentInherit($sInheritClass);
        if(!class_alias($sParentClass,$sClassName)){
            dump("(autoload $sParentClass) Can not load CLASS-file");
        } else {
            return true;
        }
    }elseif($aInfo[Engine::CI_CLASSPATH]){
        require_once $aInfo[Engine::CI_CLASSPATH];
        return true;
    }elseif(!class_exists($sClassName)){
        dump("(autoload $sClassName) Can not load CLASS-file");
        dump($aInfo);
        //throw new Exception("(autoload '$sClassName') Can not load CLASS-file");
    }
    return false;
}

Автозагрузка классов

getInstance() method
public static Engine getInstance()
{return} Engine
Source Code: /engine/classes/Engine.class.php#221 (show)
static public function getInstance() {
    if (isset(self::$oInstance) and (self::$oInstance instanceof self)) {
        return self::$oInstance;
    } else {
        self::$oInstance= new self();
        return self::$oInstance;
    }
}

Ограничиваем объект только одним экземпляром. Функционал синглтона.

Используется так: 

Engine::getInstance()->Module_Method();

getStats() method
public array getStats()
{return} array
Source Code: /engine/classes/Engine.class.php#646 (show)
public function getStats() {
    return array('sql'=>$this->Database_GetStats(),'cache'=>$this->Cache_GetStats(),'engine'=>array('time_load_module'=>round($this->iTimeLoadModule,3)));
}

Возвращает статистику выполнения

isFileExists() method
public bool isFileExists(string $sFile, int $iTime=3600)
$sFile string Полный путь до файла
$iTime int Время жизни кеша
{return} bool
Source Code: /engine/classes/Engine.class.php#505 (show)
public function isFileExists($sFile,$iTime=3600) {
    // пока так
    return file_exists($sFile);

    if(
        !$this->isInit('cache')
        || !Config::Get('sys.cache.use')
        || Config::Get('sys.cache.type') != 'memory'
    ){
        return file_exists($sFile);
    }
    if (false === ($data = $this->Cache_Get("file_exists_{$sFile}"))) {
        $data=file_exists($sFile);
        $this->Cache_Set((int)$data, "file_exists_{$sFile}", array(), $iTime);
    }
    return $data;
}

Проверяет файл на существование, если используется кеширование memcache то кеширует результат работы

isInitModule() method
public bool isInitModule(string $sModuleClass)
$sModuleClass string Класс модуля
{return} bool
Source Code: /engine/classes/Engine.class.php#333 (show)
public function isInitModule($sModuleClass) {
    if(!in_array($sModuleClass,array('ModulePlugin','ModuleHook'))) {
        $sModuleClass=$this->Plugin_GetDelegate('module',$sModuleClass);
    }
    if(isset($this->aModules[$sModuleClass]) and $this->aModules[$sModuleClass]->isInit()){
        return true;
    }
    return false;
}

Проверяет модуль на инициализацию