PHP Autoload::inst方法代码示例

 /**
  * Метод возвращает экземпляр класса-хранилища маппингов.
  * Может быть переопределён в config.ini
  */
 private static final function inst()
 {
     if (isset(self::$inst)) {
         return self::$inst;
         //----
     }
     /*
      * Получим название класса
      */
     $class = ConfigIni::mappingStorage();
     /*
      * Класс совпадает с базовым?
      */
     if (__CLASS__ == $class) {
         return self::$inst = new MappingStorage();
     }
     /*
      * Нам передан класс, который отличается от SDK
      */
     $classPath = Autoload::inst()->getClassPath($class);
     if (!PsCheck::isNotEmptyString($classPath)) {
         return PsUtil::raise('Не удалось найти класс хранилища маппингов [{}]', $class);
     }
     /*
      * Указанный класс должен быть наследником данного
      */
     if (!PsUtil::isInstanceOf($class, __CLASS__)) {
         return PsUtil::raise('Указанное хранилище маппингов [{}] не является наследником класса [{}]', $class, __CLASS__);
     }
     return self::$inst = new $class();
 }

 /**
  * @covers AutoloadDir::isRebuilded
  */
 public function testIsRebuilded()
 {
     //Запросим путь к тестовому классу, чтобы он уже наверняка был найден на момент запроса.
     $this->assertNotNull(Autoload::inst()->getClassPath(ClassA::get__CLASS__()));
     //Мы должны найти нагш класс без перезагрузки, так как уже нашли его ранее
     $cpDir = new AutoloadDir(DirItem::inst(Autoload::DIR_TESTS));
     $this->assertNotNull($cpDir->getClassPath(ClassA::get__CLASS__()));
     $this->assertFalse($cpDir->isRebuilded());
 }

 public static function format($__CLASS__, $__FUNCTION__, array $arguments)
 {
     if (!array_key_exists($__CLASS__, self::$MESSAGES)) {
         /*
          * Защита от зацикливания
          */
         self::$MESSAGES[$__CLASS__] = null;
         /*
          * Определим, где расположен класс с сообщениями
          */
         $classPath = Autoload::inst()->getClassPath($__CLASS__);
         if (!$classPath) {
             return PsUtil::raise('Группа сообщений {} не зарегистрирована', $__CLASS__);
         }
         /*
          * Получим DirItem сообщений для этого класса
          */
         $messagesDi = DirItem::inst(dirname($classPath), $__CLASS__, PsConst::EXT_MSGS);
         if (!$messagesDi->isFile()) {
             return PsUtil::raise('Файл с сообщениями {} не существует', $messagesDi->getName());
         }
         /*
          * Распарсим сообщения из файла
          */
         self::$MESSAGES[$__CLASS__] = $messagesDi->getFileAsProps();
     }
     /*
      * Проверим на зацикливание
      */
     if (self::$MESSAGES[$__CLASS__] === null) {
         PsUtil::raise('Зацикливание при попытке получить сообещние {}::{}', $__CLASS__, $__FUNCTION__);
     }
     /*
      * Проверим на существование самого сообщения
      */
     if (!array_key_exists($__FUNCTION__, self::$MESSAGES[$__CLASS__])) {
         return PsUtil::raise('Сообщение {}::{} не существует', $__CLASS__, $__FUNCTION__);
     }
     /*
      * Заменим макросы {} и вернём сообщение
      */
     return PsStrings::replaceMapBracedKeys(self::$MESSAGES[$__CLASS__][$__FUNCTION__], $arguments);
 }

 /** @return Autoload */
 public static function inst()
 {
     return self::$inst ? self::$inst : (self::$inst = new Autoload());
 }

 /**
  * Метод возвращает экземпляр класса-плагина Smarty.
  * Для переопределения этого класса, на уровне проектного config.ini
  * должен быть задан другой класс.
  * 
  * Это позволит использовать стандартизованный метод подключения плагинов
  */
 public static final function inst()
 {
     if (isset(self::$inst)) {
         return self::$inst;
         //----
     }
     /*
      * Получим название класса
      */
     $class = ConfigIni::smartyPlugin();
     /*
      * Класс подключения библиотек совпадает с базовым
      */
     if (__CLASS__ == $class) {
         return self::$inst = new PSSmartyPlugin();
     }
     /*
      * Нам передан класс, который отличается от SDK
      */
     $classPath = Autoload::inst()->getClassPath($class);
     if (!PsCheck::isNotEmptyString($classPath)) {
         return PsUtil::raise('Не удалось найти класс плагинов Smarty [{}]', $class);
     }
     /*
      * Указанный класс должен быть наследником данного
      */
     if (!PsUtil::isInstanceOf($class, __CLASS__)) {
         return PsUtil::raise('Указанный плагин Smarty [{}] не является наследником класса [{}]', $class, __CLASS__);
     }
     return self::$inst = new $class();
 }

define('PROCESS_FUNCTION_NAME', 'executeProcess');
//Включаем логирование, перенаправляем его в консоль и устанавливаем логгеры
$LOGGING_ENABLED = true;
$LOGGING_STREAM = 2;
$LOGGERS_LIST[] = 'PROCESS';
$LOGGERS_LIST[] = 'PsLogger';
//Запускаем профилирование
$PROFILING_ENABLED = true;
//Установим глобальный массив, чтобы не получать ошибку в момент попытки стартовать сессию
$_SESSION = array();
require_once 'MainImportAdmin.php';
check_condition($CALLED_FILE, 'Global property $CALLED_FILE is not set');
check_condition(is_callable(PROCESS_FUNCTION_NAME), PROCESS_FUNCTION_NAME . ' is not callable');
//В необязательном режиме подключим папку classes нашего процесса
Autoload::inst()->registerBaseDir(array(dirname($CALLED_FILE), 'classes'), false);
function dolog($info = '')
{
    call_user_func_array(array(PsLogger::inst('PROCESS'), 'info'), func_get_args());
}
$__logBoxNum = 0;
function LOGBOX_INIT($num = 0)
{
    global $__logBoxNum;
    $__logBoxNum = $num;
}
function LOGBOX($msg)
{
    $args = func_get_args();
    global $__logBoxNum;
    ++$__logBoxNum;

 /**
  * Метод возвращает экземпляр класса-хранилища экземпляров фолдинов.
  * Для переопределения этого класса, на уровне проектного config.ini
  * должен быть задан другой класс.
  * 
  * @return FoldedStorageInsts
  */
 protected static final function inst()
 {
     if (isset(self::$inst)) {
         return self::$inst;
         //----
     }
     /*
      * Получим название класса
      */
     $class = FoldingsIni::foldingsStore();
     /*
      * Класс совпадает с базовым
      */
     if (__CLASS__ == $class) {
         return self::$inst = new FoldedStorageInsts();
     }
     /*
      * Нам передан класс, который отличается от SDK
      */
     $classPath = Autoload::inst()->getClassPath($class);
     if (!PsCheck::isNotEmptyString($classPath)) {
         return PsUtil::raise('Не удалось найти класс регистрации экземпляров фолдингов [{}]', $class);
     }
     /*
      * Указанный класс должен быть наследником данного
      */
     if (!PsUtil::isInstanceOf($class, __CLASS__)) {
         return PsUtil::raise('Указанный класс регистрации экземпляров фолдингов [{}] не является наследником класса [{}]', $class, __CLASS__);
     }
     return self::$inst = new $class();
 }

 /**
  * Метод возвращает экземпляр класса, подключающего библиотеки.
  * Для переопределения этого класса, на уровне проектного config.ini
  * должен быть задан другой класс, отвечающий за подключение библиотек.
  * 
  * Это позволит:
  * 1. Использовать стандартизованный метод подключения внешних библиотек
  * 2. Переопределить подключение библиотек из SDK
  */
 public static final function inst()
 {
     if (isset(self::$inst)) {
         return self::$inst;
         //----
     }
     /*
      * Получим название класса, отвечающего за подключение библиотек
      */
     $class = ConfigIni::libsIncluder();
     /*
      * Подготовим директории
      */
     $SDK_LIB_DIR = DirManager::inst(PS_DIR_INCLUDES, DirManager::DIR_LIB)->absDirPath();
     $PROJ_LIB_DIR = DirManager::inst(PS_DIR_ADDON, DirManager::DIR_LIB)->absDirPath();
     /*
      * Класс подключения библиотек совпадает с базовым
      */
     if (__CLASS__ == $class) {
         self::$inst = new PsLibs();
         self::$inst->SDK_LIB_DIR = $SDK_LIB_DIR;
         self::$inst->LOGGER = PsLogger::inst($class);
         self::$inst->LOGGER->info('Libs includer  SDK: [{}]', __FILE__);
         self::$inst->LOGGER->info('Libs directory SDK: [{}]', $SDK_LIB_DIR);
         return self::$inst;
         //---
     }
     /*
      * Нам передан класс, который отличается от SDK
      */
     $classPath = Autoload::inst()->getClassPath($class);
     if (!PsCheck::isNotEmptyString($classPath)) {
         return PsUtil::raise('Не удалось найти класс загрузчика библиотек [{}]', $class);
     }
     /*
      * Указанный класс должен быть наследником данного
      */
     if (!PsUtil::isInstanceOf($class, __CLASS__)) {
         return PsUtil::raise('Указанный загрузчик библиотек [{}] не является наследником класса [{}]', $class, __CLASS__);
     }
     self::$inst = new $class();
     self::$inst->SDK_LIB_DIR = $SDK_LIB_DIR;
     self::$inst->PROJ_LIB_DIR = $PROJ_LIB_DIR;
     self::$inst->LOGGER = PsLogger::inst($class);
     self::$inst->LOGGER->info('Libs includer  CUSTOM: [{}]', $classPath);
     self::$inst->LOGGER->info('Libs directory    SDK: [{}]', $SDK_LIB_DIR);
     self::$inst->LOGGER->info('Libs directory CUSTOM: [{}]', $PROJ_LIB_DIR);
     return self::$inst;
     //---
 }

        dolog(pad_left('', $num, ' ') . $str);
    }
    dolog('');
    die(1);
}
restore_exception_handler();
set_exception_handler('print_stack');
//Параметр $CALLED_FILE должен установлен запущенным процессом
check_condition($CALLED_FILE, 'Global variable $CALLED_FILE is not set');
check_condition(is_file($CALLED_FILE), "Programm file {$CALLED_FILE} is not found");
//Функция должна быть определена запущенным процессом
check_condition(is_callable(PS_PROCESS_FUNCTION_NAME), PS_PROCESS_FUNCTION_NAME . ' is not callable');
//Проверим, что программа вызвана из командной строки
check_condition(is_array($argv) && PsContext::isCmd(), "Programm {$CALLED_FILE} can be runned only from console");
//В необязательном режиме подключим папку src нашего процесса
Autoload::inst()->registerBaseDir(array(dirname($CALLED_FILE), DirManager::DIR_SRC), false);
//Определим вспомогательную функцию логирования
function dolog($info = '')
{
    call_user_func_array(array(PsLogger::inst('PROCESS'), 'info'), func_get_args());
}
//Заругистрируем функцию, которая после окончания процесса запишет лог в файл
function dimpConsoleLog()
{
    global $CALLED_FILE;
    if ($CALLED_FILE) {
        $log = file_path(dirname($CALLED_FILE), get_file_name($CALLED_FILE), 'log');
        $FULL_LOG = PsLogger::controller()->getFullLog();
        $FULL_LOG = mb_convert_encoding($FULL_LOG, 'UTF-8', 'cp866');
        file_put_contents($log, $FULL_LOG);
    }

 /**
  * Метод вызывается для инициализации окружения:
  * 1. Директория ресурсов окружения будет подключена в Autoload
  * 2. Файл, включающий окружение, будет выполнен
  */
 public static function init()
 {
     if (self::$inited) {
         return;
         //---
     }
     self::$inited = true;
     //---
     /*
      * Проверим, нужно ли подключать окружение
      */
     if (self::isSkipInclude()) {
         return;
         //---
     }
     $env = self::env();
     if (!$env) {
         return;
         //---
     }
     $envDir = array_get_value($env, ConfigIni::environments());
     if (!$envDir) {
         return PsUtil::raise('Environment [{}] not found', $env);
     }
     if (!is_dir($envDir)) {
         return PsUtil::raise('Environment dir for [{}] not found', $env);
     }
     $envSrcDir = next_level_dir($envDir, DirManager::DIR_SRC);
     $envIncFile = file_path($envDir, $env, PsConst::EXT_PHP);
     if (!is_file($envIncFile)) {
         return PsUtil::raise('Environment include file for [{}] not found', $env);
     }
     $LOGGER = PsLogger::inst(__CLASS__);
     if ($LOGGER->isEnabled()) {
         $LOGGER->info('Including \'{}\' environment for context \'{}\'', $env, PsContext::describe());
         $LOGGER->info('Env dir:  {}', $envDir);
         $LOGGER->info('Src dir:  {}', $envSrcDir);
         $LOGGER->info('Inc file: {}', $envIncFile);
     }
     //Проинициализировано окружение
     self::$included = true;
     //Регистрируем директорию с классами, специфичными только для данного окружения
     Autoload::inst()->registerBaseDir($envSrcDir, false);
     //Выполним необходимое действие
     $PROFILER = PsProfiler::inst(__CLASS__);
     try {
         $LOGGER->info('{');
         $PROFILER->start($env);
         self::initImpl($LOGGER, $envIncFile);
         $secundomer = $PROFILER->stop();
         $LOGGER->info('}');
         $LOGGER->info('Inc file included for {} sec', $secundomer->getTime());
     } catch (Exception $ex) {
         $PROFILER->stop(false);
         $LOGGER->info('Inc file execution error: [{}]', $ex->getMessage());
         throw $ex;
         //---
     }
 }

 /**
  * Конструктор класса для работы с кешем.
  * Кеширование идёт в два этапа:
  * 1. Кеширование на уровне класса для максимально быстрого доступа
  * 2. Кеширование в долгосрочном хранилище, которое реализуется отдельным классом - "движком" кеширования
  * 
  * Движок кеширования должен быть задан на уровне config.ini
  * 
  * @return PSCache
  */
 protected function __construct()
 {
     $this->LOGGER = PsLogger::inst(__CLASS__);
     /*
      * Получим название класса "движка" кеширования
      */
     $class = ConfigIni::cacheEngine();
     /*
      * Проверим наличие класса
      */
     $classPath = Autoload::inst()->getClassPath($class);
     if (!PsCheck::isNotEmptyString($classPath)) {
         return PsUtil::raise('Не удалось найти класс для кеширования [{}]', $class);
     }
     /*
      * Правильный ли класс указан?
      */
     if (!PsUtil::isInstanceOf($class, 'PSCacheEngine')) {
         return PsUtil::raise('Указанный класс кеширования [{}] не является наследником класса [{}]', $class, 'PSCacheEngine');
     }
     $this->LOGGER->info('Используем движок кеширования: {}', $class);
     $this->CACHE_ENGINE = new $class();
 }

function ps_admin_on($force = false)
{
    if ($force || AuthManager::isAuthorizedAsAdmin()) {
        Autoload::inst()->registerAdminBaseDir();
    }
}

<?php

/*
 * Ресурсы для тестов. Подключаем также и ресурсы админа. 
 */
include_once 'MainImportAdmin.php';
Autoload::inst()->registerTestsBaseDir();

 public function __construct($class)
 {
     $this->rc = PsUtil::newReflectionClass($class);
     $this->di = DirItem::inst(Autoload::inst()->getClassPath($this->rc->name));
 }