Index: branches/5.3.x/core/kernel/application.php
===================================================================
--- branches/5.3.x/core/kernel/application.php (revision 16162)
+++ branches/5.3.x/core/kernel/application.php (revision 16163)
@@ -1,3052 +1,3065 @@
* The class encapsulates the main run-cycle of the script, provide access to all other objects in the framework.
*
* The class is a singleton, which means that there could be only one instance of kApplication in the script.
* This could be guaranteed by NOT calling the class constructor directly, but rather calling kApplication::Instance() method,
* which returns an instance of the application. The method guarantees that it will return exactly the same instance for any call.
* See singleton pattern by GOF.
*/
class kApplication implements kiCacheable {
/**
* Location of module helper class (used in installator too)
*/
const MODULE_HELPER_PATH = '/../units/helpers/modules_helper.php';
/**
* Is true, when Init method was called already, prevents double initialization
*
* @var bool
*/
public $InitDone = false;
/**
* Holds internal NParser object
*
* @var NParser
* @access public
*/
public $Parser;
/**
* Holds parser output buffer
*
* @var string
* @access protected
*/
protected $HTML = '';
/**
* The main Factory used to create
* almost any class of kernel and
* modules
*
* @var kFactory
* @access protected
*/
protected $Factory;
/**
* Template names, that will be used instead of regular templates
*
* @var Array
* @access public
*/
public $ReplacementTemplates = Array ();
/**
* Mod-Rewrite listeners used during url building and parsing
*
* @var Array
* @access public
*/
public $RewriteListeners = Array ();
/**
* Reference to debugger
*
* @var Debugger
* @access public
*/
public $Debugger = null;
/**
* Holds all phrases used
* in code and template
*
* @var kPhraseCache
* @access public
*/
public $Phrases;
/**
* Modules table content, key - module name
*
* @var Array
* @access public
*/
public $ModuleInfo = Array ();
/**
* Holds DBConnection
*
* @var IDBConnection
* @access public
*/
public $Conn = null;
/**
* Reference to event log
*
* @var Array|kLogger
* @access public
*/
protected $_logger = Array ();
// performance needs:
/**
* Holds a reference to httpquery
*
* @var kHttpQuery
* @access public
*/
public $HttpQuery = null;
/**
* Holds a reference to UnitConfigReader
*
* @var kUnitConfigReader
* @access public
*/
public $UnitConfigReader = null;
/**
* Holds a reference to Session
*
* @var Session
* @access public
*/
public $Session = null;
/**
* Holds a ref to kEventManager
*
* @var kEventManager
* @access public
*/
public $EventManager = null;
/**
* Holds a ref to kUrlManager
*
* @var kUrlManager
* @access public
*/
public $UrlManager = null;
/**
* Ref for TemplatesCache
*
* @var TemplatesCache
* @access public
*/
public $TemplatesCache = null;
/**
* Holds current NParser tag while parsing, can be used in error messages to display template file and line
*
* @var _BlockTag
* @access public
*/
public $CurrentNTag = null;
/**
* Object of unit caching class
*
* @var kCacheManager
* @access public
*/
public $cacheManager = null;
/**
* Tells, that administrator has authenticated in administrative console
* Should be used to manipulate data change OR data restrictions!
*
* @var bool
* @access public
*/
public $isAdminUser = false;
/**
* Tells, that admin version of "index.php" was used, nothing more!
* Should be used to manipulate data display!
*
* @var bool
* @access public
*/
public $isAdmin = false;
/**
* Instance of site domain object
*
* @var kDBItem
* @access public
* @todo move away into separate module
*/
public $siteDomain = null;
/**
* Prevent kApplication class to be created directly, only via Instance method
*
* @access private
*/
private function __construct()
{
}
final private function __clone() {}
/**
* Returns kApplication instance anywhere in the script.
*
* This method should be used to get single kApplication object instance anywhere in the
* Kernel-based application. The method is guaranteed to return the SAME instance of kApplication.
* Anywhere in the script you could write:
*
* $application =& kApplication::Instance();
*
* or in an object:
*
* $this->Application =& kApplication::Instance();
*
* to get the instance of kApplication. Note that we call the Instance method as STATIC - directly from the class.
* To use descendant of standard kApplication class in your project you would need to define APPLICATION_CLASS constant
* BEFORE calling kApplication::Instance() for the first time. If APPLICATION_CLASS is not defined the method would
* create and return default KernelApplication instance.
*
* Pattern: Singleton
*
* @static
* @return kApplication
* @access public
*/
public static function &Instance()
{
static $instance = false;
if ( !$instance ) {
$class = defined('APPLICATION_CLASS') ? APPLICATION_CLASS : 'kApplication';
$instance = new $class();
}
return $instance;
}
/**
* Initializes the Application
*
* @param string $factory_class
* @return bool Was Init actually made now or before
* @access public
* @see kHTTPQuery
* @see Session
* @see TemplatesCache
*/
public function Init($factory_class = 'kFactory')
{
if ( $this->InitDone ) {
return false;
}
if ( preg_match('/utf-8/i', CHARSET) ) {
setlocale(LC_ALL, 'en_US.UTF-8');
mb_internal_encoding('UTF-8');
}
$this->isAdmin = kUtil::constOn('ADMIN');
if ( !kUtil::constOn('SKIP_OUT_COMPRESSION') ) {
ob_start(); // collect any output from method (other then tags) into buffer
}
if ( defined('DEBUG_MODE') && $this->isDebugMode() && kUtil::constOn('DBG_PROFILE_MEMORY') ) {
$this->Debugger->appendMemoryUsage('Application before Init:');
}
$this->_logger = new kLogger($this->_logger);
$this->Factory = new $factory_class();
$this->registerDefaultClasses();
$system_config = new kSystemConfig(true);
$vars = $system_config->getData();
$db_class = isset($vars['Databases']) ? 'kDBLoadBalancer' : ($this->isDebugMode() ? 'kDBConnectionDebug' : 'kDBConnection');
$this->Conn = $this->Factory->makeClass($db_class, Array (SQL_TYPE, Array ($this->_logger, 'handleSQLError')));
$this->Conn->setup($vars);
$this->cacheManager = $this->makeClass('kCacheManager');
$this->cacheManager->InitCache();
if ( defined('DEBUG_MODE') && $this->isDebugMode() ) {
$this->Debugger->appendTimestamp('Before UnitConfigReader');
}
// init config reader and all managers
$this->UnitConfigReader = $this->makeClass('kUnitConfigReader');
$this->UnitConfigReader->scanModules(MODULES_PATH); // will also set RewriteListeners when existing cache is read
$this->registerModuleConstants();
if ( defined('DEBUG_MODE') && $this->isDebugMode() ) {
$this->Debugger->appendTimestamp('After UnitConfigReader');
}
define('MOD_REWRITE', $this->ConfigValue('UseModRewrite') && !$this->isAdmin ? 1 : 0);
// start processing request
$this->HttpQuery = $this->recallObject('kHTTPQuery');
$this->HttpQuery->process();
if ( defined('DEBUG_MODE') && $this->isDebugMode() ) {
$this->Debugger->appendTimestamp('Processed HTTPQuery initial');
}
$this->Session = $this->recallObject('Session');
if ( defined('DEBUG_MODE') && $this->isDebugMode() ) {
$this->Debugger->appendTimestamp('Processed Session');
}
$this->Session->ValidateExpired(); // needs mod_rewrite url already parsed to keep user at proper template after session expiration
if ( defined('DEBUG_MODE') && $this->isDebugMode() ) {
$this->Debugger->appendTimestamp('Processed HTTPQuery AfterInit');
}
$this->cacheManager->LoadApplicationCache();
$site_timezone = $this->ConfigValue('Config_Site_Time');
if ( $site_timezone ) {
date_default_timezone_set($site_timezone);
}
if ( defined('DEBUG_MODE') && $this->isDebugMode() ) {
$this->Debugger->appendTimestamp('Loaded cache and phrases');
}
$this->ValidateLogin(); // must be called before AfterConfigRead, because current user should be available there
$this->UnitConfigReader->AfterConfigRead(); // will set RewriteListeners when missing cache is built first time
if ( defined('DEBUG_MODE') && $this->isDebugMode() ) {
$this->Debugger->appendTimestamp('Processed AfterConfigRead');
}
if ( $this->GetVar('m_cat_id') === false ) {
$this->SetVar('m_cat_id', 0);
}
if ( !$this->RecallVar('curr_iso') ) {
$this->StoreVar('curr_iso', $this->GetPrimaryCurrency(), true); // true for optional
}
$visit_id = $this->RecallVar('visit_id');
if ( $visit_id !== false ) {
$this->SetVar('visits_id', $visit_id);
}
if ( defined('DEBUG_MODE') && $this->isDebugMode() ) {
$this->Debugger->profileFinish('kernel4_startup');
}
$this->InitDone = true;
$this->HandleEvent(new kEvent('adm:OnStartup'));
return true;
}
/**
* Performs initialization of manager classes, that can be overridden from unit configs
*
* @return void
* @access public
* @throws Exception
*/
public function InitManagers()
{
if ( $this->InitDone ) {
throw new Exception('Duplicate call of ' . __METHOD__, E_USER_ERROR);
}
$this->UrlManager = $this->makeClass('kUrlManager');
$this->EventManager = $this->makeClass('kEventManager');
$this->Phrases = $this->makeClass('kPhraseCache');
$this->RegisterDefaultBuildEvents();
}
/**
* Returns module information. Searches module by requested field
*
* @param string $field
* @param mixed $value
* @param string $return_field field value to returns, if not specified, then return all fields
* @return Array
*/
public function findModule($field, $value, $return_field = null)
{
$found = $module_info = false;
foreach ($this->ModuleInfo as $module_info) {
if ( strtolower($module_info[$field]) == strtolower($value) ) {
$found = true;
break;
}
}
if ( $found ) {
return isset($return_field) ? $module_info[$return_field] : $module_info;
}
return false;
}
/**
* Refreshes information about loaded modules
*
* @return void
* @access public
*/
public function refreshModuleInfo()
{
if ( defined('IS_INSTALL') && IS_INSTALL && !$this->TableFound('Modules', true) ) {
$this->registerModuleConstants();
$this->Factory->configureAutoloader();
return;
}
// use makeClass over recallObject, since used before kApplication initialization during installation
$modules_helper = $this->makeClass('kModulesHelper');
/* @var $modules_helper kModulesHelper */
$this->Conn->nextQueryCachable = true;
$sql = 'SELECT *
FROM ' . TABLE_PREFIX . 'Modules
WHERE ' . $modules_helper->getWhereClause() . '
ORDER BY LoadOrder';
$this->ModuleInfo = $this->Conn->Query($sql, 'Name');
$this->registerModuleConstants();
$this->Factory->configureAutoloader();
}
/**
* Checks if passed language id if valid and sets it to primary otherwise
*
* @return void
* @access public
*/
public function VerifyLanguageId()
{
/** @var LanguagesItem $lang */
$lang = $this->recallObject('lang.current');
if ( !$lang->isLoaded() || (!$this->isAdmin && !$lang->GetDBField('Enabled')) ) {
if ( !defined('IS_INSTALL') ) {
$this->ApplicationDie('Unknown or disabled language');
}
}
}
/**
* Checks if passed theme id if valid and sets it to primary otherwise
*
* @return void
* @access public
*/
public function VerifyThemeId()
{
if ( $this->isAdmin ) {
kUtil::safeDefine('THEMES_PATH', '/core/admin_templates');
return;
}
$path = $this->GetFrontThemePath();
if ( $path === false ) {
$this->ApplicationDie('No Primary Theme Selected or Current Theme is Unknown or Disabled');
}
kUtil::safeDefine('THEMES_PATH', $path);
}
/**
* Returns relative path to current front-end theme
*
* @param bool $force
* @return string
* @access public
*/
public function GetFrontThemePath($force = false)
{
static $path = null;
if ( !$force && isset($path) ) {
return $path;
}
/** @var ThemeItem $theme */
$theme = $this->recallObject('theme.current');
if ( !$theme->isLoaded() || !$theme->GetDBField('Enabled') ) {
return false;
}
// assign & then return, since it's static variable
$path = '/themes/' . $theme->GetDBField('Name');
return $path;
}
/**
* Returns primary front/admin language id
*
* @param bool $init
* @return int
* @access public
*/
public function GetDefaultLanguageId($init = false)
{
$cache_key = 'primary_language_info[%LangSerial%]';
$language_info = $this->getCache($cache_key);
if ( $language_info === false ) {
// cache primary language info first
$language_config = $this->getUnitConfig('lang');
$table = $language_config->getTableName();
$id_field = $language_config->getIDField();
$this->Conn->nextQueryCachable = true;
$sql = 'SELECT ' . $id_field . ', IF(AdminInterfaceLang, "Admin", "Front") AS LanguageKey
FROM ' . $table . '
WHERE (AdminInterfaceLang = 1 OR PrimaryLang = 1) AND (Enabled = 1)';
$language_info = $this->Conn->GetCol($sql, 'LanguageKey');
if ( $language_info !== false ) {
$this->setCache($cache_key, $language_info);
}
}
$language_key = ($this->isAdmin && $init) || count($language_info) == 1 ? 'Admin' : 'Front';
if ( array_key_exists($language_key, $language_info) && $language_info[$language_key] > 0 ) {
// get from cache
return $language_info[$language_key];
}
$language_id = $language_info && array_key_exists($language_key, $language_info) ? $language_info[$language_key] : false;
if ( !$language_id && defined('IS_INSTALL') && IS_INSTALL ) {
$language_id = 1;
}
return $language_id;
}
/**
* Returns front-end primary theme id (even, when called from admin console)
*
* @param bool $force_front
* @return int
* @access public
*/
public function GetDefaultThemeId($force_front = false)
{
static $theme_id = 0;
if ( $theme_id > 0 ) {
return $theme_id;
}
if ( kUtil::constOn('DBG_FORCE_THEME') ) {
$theme_id = DBG_FORCE_THEME;
}
elseif ( !$force_front && $this->isAdmin ) {
$theme_id = 999;
}
else {
$cache_key = 'primary_theme[%ThemeSerial%]';
$theme_id = $this->getCache($cache_key);
if ( $theme_id === false ) {
$this->Conn->nextQueryCachable = true;
$theme_config = $this->getUnitConfig('theme');
$sql = 'SELECT ' . $theme_config->getIDField() . '
FROM ' . $theme_config->getTableName() . '
WHERE (PrimaryTheme = 1) AND (Enabled = 1)';
$theme_id = $this->Conn->GetOne($sql);
if ( $theme_id !== false ) {
$this->setCache($cache_key, $theme_id);
}
}
}
return $theme_id;
}
/**
* Returns site primary currency ISO code
*
* @return string
* @access public
* @todo Move into In-Commerce
*/
public function GetPrimaryCurrency()
{
$cache_key = 'primary_currency[%CurrSerial%][%SiteDomainSerial%]:' . $this->siteDomainField('DomainId');
$currency_iso = $this->getCache($cache_key);
if ( $currency_iso === false ) {
if ( $this->prefixRegistred('curr') ) {
$this->Conn->nextQueryCachable = true;
$currency_id = $this->siteDomainField('PrimaryCurrencyId');
$sql = 'SELECT ISO
FROM ' . $this->getUnitConfig('curr')->getTableName() . '
WHERE ' . ($currency_id > 0 ? 'CurrencyId = ' . $currency_id : 'IsPrimary = 1');
$currency_iso = $this->Conn->GetOne($sql);
}
else {
$currency_iso = 'USD';
}
$this->setCache($cache_key, $currency_iso);
}
return $currency_iso;
}
/**
* Returns site domain field. When none of site domains are found false is returned.
*
* @param string $field
* @param bool $formatted
* @param string $format
* @return mixed
* @todo Move into separate module
*/
public function siteDomainField($field, $formatted = false, $format = null)
{
if ( $this->isAdmin ) {
// don't apply any filtering in administrative console
return false;
}
if ( !$this->siteDomain ) {
$this->siteDomain = $this->recallObject('site-domain.current', null, Array ('live_table' => true));
/* @var $site_domain kDBItem */
}
if ( $this->siteDomain->isLoaded() ) {
return $formatted ? $this->siteDomain->GetField($field, $format) : $this->siteDomain->GetDBField($field);
}
return false;
}
/**
* Registers classes, that are used before unit configs (where class registration usually is done) are read.
*
* Called automatically while initializing kApplication.
*
* @return void
* @access public
*/
public function RegisterDefaultClasses()
{
// Database.
$this->registerClass('IDBConnection', KERNEL_PATH . '/db/i_db_connection.php');
$this->registerClass('kDBConnection', KERNEL_PATH . '/db/db_connection.php');
$this->registerClass('kDBConnectionDebug', KERNEL_PATH . '/db/db_connection.php');
$this->registerClass('kDBLoadBalancer', KERNEL_PATH . '/db/db_load_balancer.php');
// Cache.
$this->registerClass('kCacheManager', KERNEL_PATH . '/managers/cache_manager.php');
$this->registerClass('kCache', KERNEL_PATH . '/utility/cache.php');
// Unit configs.
$this->registerClass('kUnitConfigReader', KERNEL_PATH . '/utility/unit_config_reader.php');
$this->registerClass('kUnitConfigCloner', KERNEL_PATH . '/utility/unit_config_cloner.php');
// Urls.
$this->registerClass('kUrlManager', KERNEL_PATH . '/managers/url_manager.php');
$this->registerClass('kUrlProcessor', KERNEL_PATH . '/managers/url_processor.php');
$this->registerClass('kPlainUrlProcessor', KERNEL_PATH . '/managers/plain_url_processor.php');
// $this->registerClass('kRewriteUrlProcessor', KERNEL_PATH . '/managers/rewrite_url_processor.php');
// Events.
$this->registerClass('kEventManager', KERNEL_PATH . '/event_manager.php');
$this->registerClass('kHookManager', KERNEL_PATH . '/managers/hook_manager.php');
$this->registerClass('kScheduledTaskManager', KERNEL_PATH . '/managers/scheduled_task_manager.php');
$this->registerClass('kRequestManager', KERNEL_PATH . '/managers/request_manager.php');
// Misc.
$this->registerClass('kPhraseCache', KERNEL_PATH . '/languages/phrases_cache.php');
$this->registerClass('kModulesHelper', KERNEL_PATH . self::MODULE_HELPER_PATH);
// Aliased.
$this->registerClass('Params', KERNEL_PATH . '/utility/params.php', 'kActions');
$this->registerClass('kMainTagProcessor', KERNEL_PATH . '/processors/main_processor.php', 'm_TagProcessor');
$this->registerClass('kEmailSendingHelper', KERNEL_PATH . '/utility/email_send.php', 'EmailSender');
}
/**
* Registers default build events
*
* @return void
* @access protected
*/
protected function RegisterDefaultBuildEvents()
{
$this->EventManager->registerBuildEvent('kTempTablesHandler', 'OnTempHandlerBuild');
}
/**
* Returns cached category information by given cache name. All given category
* information is recached, when at least one of 4 caches is missing.
*
* @param int $category_id
* @param string $name cache name = {filenames, category_designs, category_tree}
* @return string
* @access public
*/
public function getCategoryCache($category_id, $name)
{
return $this->cacheManager->getCategoryCache($category_id, $name);
}
/**
* Returns caching type (none, memory, temporary)
*
* @param int $caching_type
* @return bool
* @access public
*/
public function isCachingType($caching_type)
{
return $this->cacheManager->isCachingType($caching_type);
}
/**
* Increments serial based on prefix and it's ID (optional)
*
* @param string $prefix
* @param int $id ID (value of IDField) or ForeignKeyField:ID
* @param bool $increment
* @return string
* @access public
*/
public function incrementCacheSerial($prefix, $id = null, $increment = true)
{
return $this->cacheManager->incrementCacheSerial($prefix, $id, $increment);
}
/**
* Returns cached $key value from cache named $cache_name
*
* @param int $key key name from cache
* @param bool $store_locally store data locally after retrieved
* @param int $max_rebuild_seconds
* @return mixed
* @access public
*/
public function getCache($key, $store_locally = true, $max_rebuild_seconds = 0)
{
return $this->cacheManager->getCache($key, $store_locally, $max_rebuild_seconds);
}
/**
* Stores new $value in cache with $key name
*
* @param int $key key name to add to cache
* @param mixed $value value of cached record
* @param int $expiration when value expires (0 - doesn't expire)
* @return bool
* @access public
*/
public function setCache($key, $value, $expiration = 0)
{
return $this->cacheManager->setCache($key, $value, $expiration);
}
/**
* Stores new $value in cache with $key name (only if it's not there)
*
* @param int $key key name to add to cache
* @param mixed $value value of cached record
* @param int $expiration when value expires (0 - doesn't expire)
* @return bool
* @access public
*/
public function addCache($key, $value, $expiration = 0)
{
return $this->cacheManager->addCache($key, $value, $expiration);
}
/**
* Sets rebuilding mode for given cache
*
* @param string $name
* @param int $mode
* @param int $max_rebuilding_time
* @return bool
* @access public
*/
public function rebuildCache($name, $mode = null, $max_rebuilding_time = 0)
{
return $this->cacheManager->rebuildCache($name, $mode, $max_rebuilding_time);
}
/**
* Deletes key from cache
*
* @param string $key
* @return void
* @access public
*/
public function deleteCache($key)
{
$this->cacheManager->deleteCache($key);
}
/**
* Reset's all memory cache at once
*
* @return void
* @access public
*/
public function resetCache()
{
$this->cacheManager->resetCache();
}
/**
* Returns value from database cache
*
* @param string $name key name
* @param int $max_rebuild_seconds
* @return mixed
* @access public
*/
public function getDBCache($name, $max_rebuild_seconds = 0)
{
return $this->cacheManager->getDBCache($name, $max_rebuild_seconds);
}
/**
* Sets value to database cache
*
* @param string $name
* @param mixed $value
* @param int|bool $expiration
* @return void
* @access public
*/
public function setDBCache($name, $value, $expiration = false)
{
$this->cacheManager->setDBCache($name, $value, $expiration);
}
/**
* Sets rebuilding mode for given cache
*
* @param string $name
* @param int $mode
* @param int $max_rebuilding_time
* @return bool
* @access public
*/
public function rebuildDBCache($name, $mode = null, $max_rebuilding_time = 0)
{
return $this->cacheManager->rebuildDBCache($name, $mode, $max_rebuilding_time);
}
/**
* Deletes key from database cache
*
* @param string $name
* @return void
* @access public
*/
public function deleteDBCache($name)
{
$this->cacheManager->deleteDBCache($name);
}
/**
* Registers each module specific constants if any found
*
* @return bool
* @access protected
*/
protected function registerModuleConstants()
{
if ( file_exists(KERNEL_PATH . '/constants.php') ) {
kUtil::includeOnce(KERNEL_PATH . '/constants.php');
}
if ( !$this->ModuleInfo ) {
return false;
}
foreach ($this->ModuleInfo as $module_info) {
$constants_file = FULL_PATH . '/' . $module_info['Path'] . 'constants.php';
if ( file_exists($constants_file) ) {
kUtil::includeOnce($constants_file);
}
}
return true;
}
/**
* Performs redirect to hard maintenance template
*
* @return void
* @access public
*/
public function redirectToMaintenance()
{
$maintenance_page = WRITEBALE_BASE . '/maintenance.html';
$query_string = ''; // $this->isAdmin ? '' : '?next_template=' . kUtil::escape($_SERVER['REQUEST_URI'], kUtil::ESCAPE_URL);
if ( file_exists(FULL_PATH . $maintenance_page) ) {
header('Location: ' . BASE_PATH . $maintenance_page . $query_string);
exit;
}
}
/**
* Actually runs the parser against current template and stores parsing result
*
* This method gets 't' variable passed to the script, loads the template given in 't' variable and
* parses it. The result is store in {@link $this->HTML} property.
*
* @return void
* @access public
*/
public function Run()
{
// process maintenance mode redirect: begin
$maintenance_mode = $this->getMaintenanceMode();
if ( $maintenance_mode == MaintenanceMode::HARD ) {
$this->redirectToMaintenance();
}
elseif ( $maintenance_mode == MaintenanceMode::SOFT ) {
$maintenance_template = $this->isAdmin ? 'login' : $this->ConfigValue('SoftMaintenanceTemplate');
if ( $this->GetVar('t') != $maintenance_template ) {
$redirect_params = Array ();
if ( !$this->isAdmin ) {
$redirect_params['next_template'] = $_SERVER['REQUEST_URI'];
}
$this->Redirect($maintenance_template, $redirect_params);
}
}
// process maintenance mode redirect: end
if ( defined('DEBUG_MODE') && $this->isDebugMode() && kUtil::constOn('DBG_PROFILE_MEMORY') ) {
$this->Debugger->appendMemoryUsage('Application before Run:');
}
if ( $this->isAdminUser ) {
// for permission checking in events & templates
$this->LinkVar('module'); // for common configuration templates
$this->LinkVar('module_key'); // for common search templates
$this->LinkVar('section'); // for common configuration templates
if ( $this->GetVar('m_opener') == 'p' ) {
$this->LinkVar('main_prefix'); // window prefix, that opened selector
$this->LinkVar('dst_field'); // field to set value choosed in selector
}
if ( $this->GetVar('ajax') == 'yes' && !$this->GetVar('debug_ajax') ) {
// hide debug output from ajax requests automatically
kUtil::safeDefine('DBG_SKIP_REPORTING', 1); // safeDefine, because debugger also defines it
}
}
elseif ( $this->GetVar('admin') ) {
$admin_session = $this->recallObject('Session.admin');
/* @var $admin_session Session */
// store Admin Console User's ID to Front-End's session for cross-session permission checks
$this->StoreVar('admin_user_id', (int)$admin_session->RecallVar('user_id'));
if ( $this->CheckAdminPermission('CATEGORY.MODIFY', 0, $this->getBaseCategory()) ) {
// user can edit cms blocks (when viewing front-end through admin's frame)
$editing_mode = $this->GetVar('editing_mode');
define('EDITING_MODE', $editing_mode ? $editing_mode : EDITING_MODE_BROWSE);
}
}
kUtil::safeDefine('EDITING_MODE', ''); // user can't edit anything
$this->Phrases->setPhraseEditing();
$this->EventManager->ProcessRequest();
$this->InitParser();
$t = $this->GetVar('render_template', $this->GetVar('t'));
if ( !$this->TemplatesCache->TemplateExists($t) && !$this->isAdmin ) {
$cms_handler = $this->recallObject('st_EventHandler');
/* @var $cms_handler CategoriesEventHandler */
$t = ltrim($cms_handler->GetDesignTemplate(), '/');
if ( defined('DEBUG_MODE') && $this->isDebugMode() ) {
$this->Debugger->appendHTML('Design Template: ' . $t . '; CategoryID: ' . $this->GetVar('m_cat_id'));
}
}
/*else {
$cms_handler->SetCatByTemplate();
}*/
if ( defined('DEBUG_MODE') && $this->isDebugMode() && kUtil::constOn('DBG_PROFILE_MEMORY') ) {
$this->Debugger->appendMemoryUsage('Application before Parsing:');
}
$this->HTML = $this->Parser->Run($t);
if ( defined('DEBUG_MODE') && $this->isDebugMode() && kUtil::constOn('DBG_PROFILE_MEMORY') ) {
$this->Debugger->appendMemoryUsage('Application after Parsing:');
}
}
/**
* Only renders template
*
* @see kDBEventHandler::_errorNotFound()
*/
public function QuickRun()
{
// discard any half-parsed content
ob_clean();
// replace current page content with 404
$this->InitParser();
$this->HTML = $this->Parser->Run($this->GetVar('t'));
}
/**
* Performs template parser/cache initialization
*
* @param bool|string $theme_name
* @return void
* @access public
*/
public function InitParser($theme_name = false)
{
if ( !is_object($this->Parser) ) {
$this->Parser = $this->recallObject('NParser');
$this->TemplatesCache = $this->recallObject('TemplatesCache');
}
$this->TemplatesCache->forceThemeName = $theme_name;
}
/**
* Send the parser results to browser
*
* Actually send everything stored in {@link $this->HTML}, to the browser by echoing it.
*
* @return void
* @access public
*/
public function Done()
{
$this->HandleEvent(new kEvent('adm:OnBeforeShutdown'));
$debug_mode = defined('DEBUG_MODE') && $this->isDebugMode();
if ( $debug_mode ) {
if ( kUtil::constOn('DBG_PROFILE_MEMORY') ) {
$this->Debugger->appendMemoryUsage('Application before Done:');
}
$this->Session->SaveData(); // adds session data to debugger report
$this->HTML = ob_get_clean() . $this->HTML . $this->Debugger->printReport(true);
}
else {
// send "Set-Cookie" header before any output is made
$this->Session->SetSession();
$this->HTML = ob_get_clean() . $this->HTML;
}
$this->_outputPage();
$this->cacheManager->UpdateApplicationCache();
if ( !$debug_mode ) {
$this->Session->SaveData();
}
$this->EventManager->runScheduledTasks();
if ( defined('DBG_CAPTURE_STATISTICS') && DBG_CAPTURE_STATISTICS && !$this->isAdmin ) {
$this->_storeStatistics();
}
}
/**
* Outputs generated page content to end-user
*
* @return void
* @access protected
*/
protected function _outputPage()
{
$this->setContentType();
ob_start();
if ( $this->UseOutputCompression() ) {
$compression_level = $this->ConfigValue('OutputCompressionLevel');
if ( !$compression_level || $compression_level < 0 || $compression_level > 9 ) {
$compression_level = 7;
}
header('Content-Encoding: gzip');
echo gzencode($this->HTML, $compression_level);
}
else {
// when gzip compression not used connection won't be closed early!
echo $this->HTML;
}
// send headers to tell the browser to close the connection
header('Content-Length: ' . ob_get_length());
header('Connection: close');
// flush all output
ob_end_flush();
if ( ob_get_level() ) {
ob_flush();
}
flush();
// close current session
if ( session_id() ) {
session_write_close();
}
}
/**
* Stores script execution statistics to database
*
* @return void
* @access protected
*/
protected function _storeStatistics()
{
global $start;
$script_time = microtime(true) - $start;
$query_statistics = $this->Conn->getQueryStatistics(); // time & count
$sql = 'SELECT *
FROM ' . TABLE_PREFIX . 'StatisticsCapture
WHERE TemplateName = ' . $this->Conn->qstr($this->GetVar('t'));
$data = $this->Conn->GetRow($sql);
if ( $data ) {
$this->_updateAverageStatistics($data, 'ScriptTime', $script_time);
$this->_updateAverageStatistics($data, 'SqlTime', $query_statistics['time']);
$this->_updateAverageStatistics($data, 'SqlCount', $query_statistics['count']);
$data['Hits']++;
$data['LastHit'] = time();
$this->Conn->doUpdate($data, TABLE_PREFIX . 'StatisticsCapture', 'StatisticsId = ' . $data['StatisticsId']);
}
else {
$data['ScriptTimeMin'] = $data['ScriptTimeAvg'] = $data['ScriptTimeMax'] = $script_time;
$data['SqlTimeMin'] = $data['SqlTimeAvg'] = $data['SqlTimeMax'] = $query_statistics['time'];
$data['SqlCountMin'] = $data['SqlCountAvg'] = $data['SqlCountMax'] = $query_statistics['count'];
$data['TemplateName'] = $this->GetVar('t');
$data['Hits'] = 1;
$data['LastHit'] = time();
$this->Conn->doInsert($data, TABLE_PREFIX . 'StatisticsCapture');
}
}
/**
* Calculates average time for statistics
*
* @param Array $data
* @param string $field_prefix
* @param float $current_value
* @return void
* @access protected
*/
protected function _updateAverageStatistics(&$data, $field_prefix, $current_value)
{
$data[$field_prefix . 'Avg'] = (($data['Hits'] * $data[$field_prefix . 'Avg']) + $current_value) / ($data['Hits'] + 1);
if ( $current_value < $data[$field_prefix . 'Min'] ) {
$data[$field_prefix . 'Min'] = $current_value;
}
if ( $current_value > $data[$field_prefix . 'Max'] ) {
$data[$field_prefix . 'Max'] = $current_value;
}
}
/**
* Remembers slow query SQL and execution time into log
*
* @param string $slow_sql
* @param int $time
* @return void
* @access public
*/
public function logSlowQuery($slow_sql, $time)
{
$query_crc = kUtil::crc32($slow_sql);
$sql = 'SELECT *
FROM ' . TABLE_PREFIX . 'SlowSqlCapture
WHERE QueryCrc = ' . $query_crc;
$data = $this->Conn->Query($sql, null, true);
if ( $data ) {
$this->_updateAverageStatistics($data, 'Time', $time);
$template_names = explode(',', $data['TemplateNames']);
array_push($template_names, $this->GetVar('t'));
$data['TemplateNames'] = implode(',', array_unique($template_names));
$data['Hits']++;
$data['LastHit'] = time();
$this->Conn->doUpdate($data, TABLE_PREFIX . 'SlowSqlCapture', 'CaptureId = ' . $data['CaptureId']);
}
else {
$data['TimeMin'] = $data['TimeAvg'] = $data['TimeMax'] = $time;
$data['SqlQuery'] = $slow_sql;
$data['QueryCrc'] = $query_crc;
$data['TemplateNames'] = $this->GetVar('t');
$data['Hits'] = 1;
$data['LastHit'] = time();
$this->Conn->doInsert($data, TABLE_PREFIX . 'SlowSqlCapture');
}
}
/**
* Checks if output compression options is available
*
* @return bool
* @access protected
*/
protected function UseOutputCompression()
{
if ( kUtil::constOn('IS_INSTALL') || kUtil::constOn('DBG_ZEND_PRESENT') || kUtil::constOn('SKIP_OUT_COMPRESSION') ) {
return false;
}
$accept_encoding = isset($_SERVER['HTTP_ACCEPT_ENCODING']) ? $_SERVER['HTTP_ACCEPT_ENCODING'] : '';
return $this->ConfigValue('UseOutputCompression') && function_exists('gzencode') && strstr($accept_encoding, 'gzip');
}
// Facade
/**
* Returns current session id (SID)
*
* @return int
* @access public
*/
public function GetSID()
{
$session = $this->recallObject('Session');
/* @var $session Session */
return $session->GetID();
}
/**
* Destroys current session
*
* @return void
* @access public
* @see UserHelper::logoutUser()
*/
public function DestroySession()
{
$session = $this->recallObject('Session');
/* @var $session Session */
$session->Destroy();
}
/**
* Returns variable passed to the script as GET/POST/COOKIE
*
* @param string $name Name of variable to retrieve
* @param mixed $default default value returned in case if variable not present
* @return mixed
* @access public
*/
public function GetVar($name, $default = false)
{
return isset($this->HttpQuery->_Params[$name]) ? $this->HttpQuery->_Params[$name] : $default;
}
/**
* Removes forceful escaping done to the variable upon Front-End submission.
*
* @param string|array $value Value.
*
* @return string|array
* @see kHttpQuery::StripSlashes
* @todo Temporary method for marking problematic places to take care of, when forceful escaping will be removed.
*/
public function unescapeRequestVariable($value)
{
return $this->HttpQuery->unescapeRequestVariable($value);
}
/**
* Returns variable passed to the script as $type
*
* @param string $name Name of variable to retrieve
* @param string $type Get/Post/Cookie
* @param mixed $default default value returned in case if variable not present
* @return mixed
* @access public
*/
public function GetVarDirect($name, $type, $default = false)
{
// $type = ucfirst($type);
$array = $this->HttpQuery->$type;
return isset($array[$name]) ? $array[$name] : $default;
}
/**
* Returns ALL variables passed to the script as GET/POST/COOKIE
*
* @return Array
* @access public
* @deprecated
*/
public function GetVars()
{
return $this->HttpQuery->GetParams();
}
/**
* Set the variable 'as it was passed to the script through GET/POST/COOKIE'
*
* This could be useful to set the variable when you know that
* other objects would relay on variable passed from GET/POST/COOKIE
* or you could use SetVar() / GetVar() pairs to pass the values between different objects.
*
* @param string $var Variable name to set
* @param mixed $val Variable value
* @return void
* @access public
*/
public function SetVar($var,$val)
{
$this->HttpQuery->Set($var, $val);
}
/**
* Deletes kHTTPQuery variable
*
* @param string $var
* @return void
* @todo Think about method name
*/
public function DeleteVar($var)
{
$this->HttpQuery->Remove($var);
}
/**
* Deletes Session variable
*
* @param string $var
* @return void
* @access public
*/
public function RemoveVar($var)
{
$this->Session->RemoveVar($var);
}
/**
* Removes variable from persistent session
*
* @param string $var
* @return void
* @access public
*/
public function RemovePersistentVar($var)
{
$this->Session->RemovePersistentVar($var);
}
/**
* Restores Session variable to it's db version
*
* @param string $var
* @return void
* @access public
*/
public function RestoreVar($var)
{
$this->Session->RestoreVar($var);
}
/**
* Returns session variable value
*
* Return value of $var variable stored in Session. An optional default value could be passed as second parameter.
*
* @param string $var Variable name
* @param mixed $default Default value to return if no $var variable found in session
* @return mixed
* @access public
* @see Session::RecallVar()
*/
public function RecallVar($var,$default=false)
{
return $this->Session->RecallVar($var,$default);
}
/**
* Returns variable value from persistent session
*
* @param string $var
* @param mixed $default
* @return mixed
* @access public
* @see Session::RecallPersistentVar()
*/
public function RecallPersistentVar($var, $default = false)
{
return $this->Session->RecallPersistentVar($var, $default);
}
/**
* Stores variable $val in session under name $var
*
* Use this method to store variable in session. Later this variable could be recalled.
*
* @param string $var Variable name
* @param mixed $val Variable value
* @param bool $optional
* @return void
* @access public
* @see kApplication::RecallVar()
*/
public function StoreVar($var, $val, $optional = false)
{
$session = $this->recallObject('Session');
/* @var $session Session */
$this->Session->StoreVar($var, $val, $optional);
}
/**
* Stores variable to persistent session
*
* @param string $var
* @param mixed $val
* @param bool $optional
* @return void
* @access public
*/
public function StorePersistentVar($var, $val, $optional = false)
{
$this->Session->StorePersistentVar($var, $val, $optional);
}
/**
* Stores default value for session variable
*
* @param string $var
* @param string $val
* @param bool $optional
* @return void
* @access public
* @see Session::RecallVar()
* @see Session::StoreVar()
*/
public function StoreVarDefault($var, $val, $optional = false)
{
$session = $this->recallObject('Session');
/* @var $session Session */
$this->Session->StoreVarDefault($var, $val, $optional);
}
/**
* Links HTTP Query variable with session variable
*
* If variable $var is passed in HTTP Query it is stored in session for later use. If it's not passed it's recalled from session.
* This method could be used for making sure that GetVar will return query or session value for given
* variable, when query variable should overwrite session (and be stored there for later use).
* This could be used for passing item's ID into popup with multiple tab -
* in popup script you just need to call LinkVar('id', 'current_id') before first use of GetVar('id').
* After that you can be sure that GetVar('id') will return passed id or id passed earlier and stored in session
*
* @param string $var HTTP Query (GPC) variable name
* @param mixed $ses_var Session variable name
* @param mixed $default Default variable value
* @param bool $optional
* @return void
* @access public
*/
public function LinkVar($var, $ses_var = null, $default = '', $optional = false)
{
if ( !isset($ses_var) ) {
$ses_var = $var;
}
if ( $this->GetVar($var) !== false ) {
$this->StoreVar($ses_var, $this->GetVar($var), $optional);
}
else {
$this->SetVar($var, $this->RecallVar($ses_var, $default));
}
}
/**
* Returns variable from HTTP Query, or from session if not passed in HTTP Query
*
* The same as LinkVar, but also returns the variable value taken from HTTP Query if passed, or from session if not passed.
* Returns the default value if variable does not exist in session and was not passed in HTTP Query
*
* @param string $var HTTP Query (GPC) variable name
* @param mixed $ses_var Session variable name
* @param mixed $default Default variable value
* @return mixed
* @access public
* @see LinkVar
*/
public function GetLinkedVar($var, $ses_var = null, $default = '')
{
$this->LinkVar($var, $ses_var, $default);
return $this->GetVar($var);
}
/**
* Renders given tag and returns it's output
*
* @param string $prefix
* @param string $tag
* @param Array $params
* @return mixed
* @access public
* @see kApplication::InitParser()
*/
public function ProcessParsedTag($prefix, $tag, $params)
{
$processor = $this->Parser->GetProcessor($prefix);
/* @var $processor kDBTagProcessor */
return $processor->ProcessParsedTag($tag, $params, $prefix);
}
/**
* Return object of IDBConnection interface
*
* Return object of IDBConnection interface already connected to the project database, configurable in config.php
*
* @return IDBConnection
* @access public
*/
public function &GetADODBConnection()
{
return $this->Conn;
}
/**
* Allows to parse given block name or include template
*
* @param Array $params Parameters to pass to block. Reserved parameter "name" used to specify block name.
* @param bool $pass_params Forces to pass current parser params to this block/template. Use with caution, because you can accidentally pass "block_no_data" parameter.
* @param bool $as_template
* @return string
* @access public
*/
public function ParseBlock($params, $pass_params = false, $as_template = false)
{
if ( substr($params['name'], 0, 5) == 'html:' ) {
return substr($params['name'], 5);
}
return $this->Parser->ParseBlock($params, $pass_params, $as_template);
}
/**
* Checks, that we have given block defined
*
* @param string $name
* @return bool
* @access public
*/
public function ParserBlockFound($name)
{
return $this->Parser->blockFound($name);
}
/**
* Allows to include template with a given name and given parameters
*
* @param Array $params Parameters to pass to template. Reserved parameter "name" used to specify template name.
* @return string
* @access public
*/
public function IncludeTemplate($params)
{
return $this->Parser->IncludeTemplate($params, isset($params['is_silent']) ? 1 : 0);
}
/**
* Return href for template
*
* @param string $t Template path
* @param string $prefix index.php prefix - could be blank, 'admin'
* @param Array $params
* @param string $index_file
* @return string
*/
public function HREF($t, $prefix = '', $params = Array (), $index_file = null)
{
return $this->UrlManager->HREF($t, $prefix, $params, $index_file);
}
/**
* Returns theme template filename and it's corresponding page_id based on given seo template
*
* @param string $seo_template
* @return string
* @access public
*/
public function getPhysicalTemplate($seo_template)
{
return $this->UrlManager->getPhysicalTemplate($seo_template);
}
/**
* Returns seo template by physical template
*
* @param string $physical_template
* @return string
* @access public
*/
public function getSeoTemplate($physical_template)
{
return $this->UrlManager->getSeoTemplate($physical_template);
}
/**
* Returns template name, that corresponds with given virtual (not physical) page id
*
* @param int $page_id
* @return string|bool
* @access public
*/
public function getVirtualPageTemplate($page_id)
{
return $this->UrlManager->getVirtualPageTemplate($page_id);
}
/**
* Returns section template for given physical/virtual template
*
* @param string $template
* @param int $theme_id
* @return string
* @access public
*/
public function getSectionTemplate($template, $theme_id = null)
{
return $this->UrlManager->getSectionTemplate($template, $theme_id);
}
/**
* Returns variables with values that should be passed through with this link + variable list
*
* @param Array $params
* @return Array
* @access public
*/
public function getPassThroughVariables(&$params)
{
return $this->UrlManager->getPassThroughVariables($params);
}
/**
* Builds url
*
* @param string $t
* @param Array $params
* @param string $pass
* @param bool $pass_events
* @param bool $env_var
* @return string
* @access public
*/
public function BuildEnv($t, $params, $pass = 'all', $pass_events = false, $env_var = true)
{
return $this->UrlManager->plain->build($t, $params, $pass, $pass_events, $env_var);
}
/**
* Process QueryString only, create
* events, ids, based on config
* set template name and sid in
* desired application variables.
*
* @param string $env_var environment string value
* @param string $pass_name
* @return Array
* @access public
*/
public function processQueryString($env_var, $pass_name = 'passed')
{
return $this->UrlManager->plain->parse($env_var, $pass_name);
}
/**
* Parses rewrite url and returns parsed variables
*
* @param string $url
* @param string $pass_name
* @return Array
* @access public
*/
public function parseRewriteUrl($url, $pass_name = 'passed')
{
return $this->UrlManager->rewrite->parse($url, $pass_name);
}
/**
* Returns base part of all urls, build on website
*
* @param string $domain Domain override.
* @param boolean $ssl_redirect Redirect to/from SSL.
*
* @return string
*/
public function BaseURL($domain = '', $ssl_redirect = null)
{
if ( $ssl_redirect === null ) {
// stay on same encryption level
return PROTOCOL . ($domain ? $domain : SERVER_NAME) . (defined('PORT') ? ':' . PORT : '') . BASE_PATH . '/';
}
if ( $ssl_redirect ) {
// going from http:// to https://
$protocol = 'https://';
$domain = $this->getSecureDomain();
}
else {
// going from https:// to http://
$protocol = 'http://';
$domain = $this->siteDomainField('DomainName');
if ( $domain === false ) {
$domain = DOMAIN; // not on site domain
}
}
return $protocol . $domain . (defined('PORT') ? ':' . PORT : '') . BASE_PATH . '/';
}
/**
* Returns secure domain.
*
* @return string
*/
public function getSecureDomain()
{
$ret = $this->isAdmin ? $this->ConfigValue('AdminSSLDomain') : false;
if ( !$ret ) {
$ssl_domain = $this->siteDomainField('SSLDomainName');
return strlen($ssl_domain) ? $ssl_domain : $this->ConfigValue('SSLDomain');
}
return $ret;
}
/**
* Redirects user to url, that's build based on given parameters
*
* @param string $t
* @param Array $params
* @param string $prefix
* @param string $index_file
* @return void
* @access public
*/
public function Redirect($t = '', $params = Array(), $prefix = '', $index_file = null)
{
$js_redirect = getArrayValue($params, 'js_redirect');
if ( $t == '' || $t === true ) {
$t = $this->GetVar('t');
}
// pass prefixes and special from previous url
if ( array_key_exists('js_redirect', $params) ) {
unset($params['js_redirect']);
}
// allows to send custom responce code along with redirect header
if ( array_key_exists('response_code', $params) ) {
$response_code = (int)$params['response_code'];
unset($params['response_code']);
}
else {
$response_code = 302; // Found
}
if ( !array_key_exists('pass', $params) ) {
$params['pass'] = 'all';
}
if ( $this->GetVar('ajax') == 'yes' && $t == $this->GetVar('t') ) {
// redirects to the same template as current
$params['ajax'] = 'yes';
}
$location = $this->HREF($t, $prefix, $params, $index_file);
if ( $this->isDebugMode() && (kUtil::constOn('DBG_REDIRECT') || (kUtil::constOn('DBG_RAISE_ON_WARNINGS') && $this->Debugger->WarningCount)) ) {
$this->Debugger->appendTrace();
echo 'Debug output above !!!
' . "\n";
if ( array_key_exists('HTTP_REFERER', $_SERVER) ) {
echo 'Referer: ' . $_SERVER['HTTP_REFERER'] . '
' . "\n";
}
echo "Proceed to redirect: {$location}
\n";
}
else {
if ( $js_redirect ) {
// show "redirect" template instead of redirecting,
// because "Set-Cookie" header won't work, when "Location"
// header is used later
$this->SetVar('t', 'redirect');
$this->SetVar('redirect_to', $location);
// make all additional parameters available on "redirect" template too
foreach ($params as $name => $value) {
$this->SetVar($name, $value);
}
return;
}
else {
if ( $this->GetVar('ajax') == 'yes' && ($t != $this->GetVar('t') || !$this->isSOPSafe($location, $t)) ) {
// redirection to other then current template during ajax request OR SOP violation
kUtil::safeDefine('DBG_SKIP_REPORTING', 1);
echo '#redirect#' . $location;
}
elseif ( headers_sent() != '' ) {
// some output occurred -> redirect using javascript
echo '';
}
else {
// no output before -> redirect using HTTP header
// header('HTTP/1.1 302 Found');
header('Location: ' . $location, true, $response_code);
}
}
}
// session expiration is called from session initialization,
// that's why $this->Session may be not defined here
$session = $this->recallObject('Session');
/* @var $session Session */
if ( $this->InitDone ) {
// if redirect happened in the middle of application initialization don't call event,
// that presumes that application was successfully initialized
$this->HandleEvent(new kEvent('adm:OnBeforeShutdown'));
}
$session->SaveData();
ob_end_flush();
exit;
}
/**
* Determines if real redirect should be made within AJAX request.
*
* @param string $url Location.
* @param string $template Template.
*
* @return boolean
* @link http://en.wikipedia.org/wiki/Same-origin_policy
*/
protected function isSOPSafe($url, $template)
{
$parsed_url = parse_url($url);
if ( $parsed_url['scheme'] . '://' != PROTOCOL ) {
return false;
}
if ( $parsed_url['host'] != SERVER_NAME ) {
return false;
}
if ( defined('PORT') && isset($parsed_url['port']) && $parsed_url['port'] != PORT ) {
return false;
}
return true;
}
/**
* Returns translation of given label
*
* @param string $label
* @param bool $allow_editing return translation link, when translation is missing on current language
* @param bool $use_admin use current Admin Console language to translate phrase
* @return string
* @access public
*/
public function Phrase($label, $allow_editing = true, $use_admin = false)
{
return $this->Phrases->GetPhrase($label, $allow_editing, $use_admin);
}
/**
* Replace language tags in exclamation marks found in text
*
* @param string $text
* @param bool $force_escape force escaping, not escaping of resulting string
* @return string
* @access public
*/
public function ReplaceLanguageTags($text, $force_escape = null)
{
return $this->Phrases->ReplaceLanguageTags($text, $force_escape);
}
/**
* Checks if user is logged in, and creates
* user object if so. User object can be recalled
* later using "u.current" prefix_special. Also you may
* get user id by getting "u.current_id" variable.
*
* @return void
* @access protected
*/
protected function ValidateLogin()
{
$session = $this->recallObject('Session');
/* @var $session Session */
$user_id = $session->GetField('PortalUserId');
if ( !$user_id && $user_id != USER_ROOT ) {
$user_id = USER_GUEST;
}
$this->SetVar('u.current_id', $user_id);
if ( !$this->isAdmin ) {
// needed for "profile edit", "registration" forms ON FRONT ONLY
$this->SetVar('u_id', $user_id);
}
$this->StoreVar('user_id', $user_id, $user_id == USER_GUEST); // storing Guest user_id (-2) is optional
$this->isAdminUser = $this->isAdmin && $this->LoggedIn();
if ( $this->GetVar('expired') == 1 ) {
// this parameter is set only from admin
$user = $this->recallObject('u.login-admin', null, Array ('form_name' => 'login'));
/* @var $user UsersItem */
$user->SetError('UserLogin', 'session_expired', 'la_text_sess_expired');
}
$this->HandleEvent(new kEvent('adm:OnLogHttpRequest'));
if ( $user_id != USER_GUEST ) {
// normal users + root
$this->LoadPersistentVars();
}
$user_timezone = $this->Session->GetField('TimeZone');
if ( $user_timezone ) {
date_default_timezone_set($user_timezone);
}
}
/**
* Loads current user persistent session data
*
* @return void
* @access public
*/
public function LoadPersistentVars()
{
$this->Session->LoadPersistentVars();
}
/**
* Returns configuration option value by name
*
* @param string $name
* @return string
* @access public
*/
public function ConfigValue($name)
{
return $this->cacheManager->ConfigValue($name);
}
/**
* Changes value of individual configuration variable (+resets cache, when needed)
*
* @param string $name
* @param string $value
* @param bool $local_cache_only
* @return string
* @access public
*/
public function SetConfigValue($name, $value, $local_cache_only = false)
{
return $this->cacheManager->SetConfigValue($name, $value, $local_cache_only);
}
/**
* Allows to process any type of event
*
* @param kEvent $event
* @param Array $params
* @param Array $specific_params
* @return void
* @access public
*/
public function HandleEvent($event, $params = null, $specific_params = null)
{
if ( isset($params) ) {
$event = new kEvent($params, $specific_params);
}
$this->EventManager->HandleEvent($event);
}
/**
* Notifies event subscribers, that event has occured
*
* @param kEvent $event
* @return void
*/
public function notifyEventSubscribers(kEvent $event)
{
$this->EventManager->notifySubscribers($event);
}
/**
* Allows to process any type of event
*
* @param kEvent $event
* @return bool
* @access public
*/
public function eventImplemented(kEvent $event)
{
return $this->EventManager->eventImplemented($event);
}
/**
* Registers new class in the factory
*
* @param string $real_class Real name of class as in class declaration
* @param string $file Filename in what $real_class is declared
* @param string $pseudo_class Name under this class object will be accessed using getObject method
* @return void
* @access public
*/
public function registerClass($real_class, $file, $pseudo_class = null)
{
$this->Factory->registerClass($real_class, $file, $pseudo_class);
}
/**
* Unregisters existing class from factory
*
* @param string $real_class Real name of class as in class declaration
* @param string $pseudo_class Name under this class object is accessed using getObject method
* @return void
* @access public
*/
public function unregisterClass($real_class, $pseudo_class = null)
{
$this->Factory->unregisterClass($real_class, $pseudo_class);
}
/**
* Add new scheduled task
*
* @param string $short_name name to be used to store last maintenance run info
* @param string $event_string
* @param int $run_schedule run schedule like for Cron
* @param string $module
* @param int $status
* @access public
*/
public function registerScheduledTask($short_name, $event_string, $run_schedule, $module, $status = STATUS_ACTIVE)
{
$this->EventManager->registerScheduledTask($short_name, $event_string, $run_schedule, $module, $status);
}
/**
* Registers Hook from subprefix event to master prefix event
*
* Pattern: Observer
*
* @param string $hook_event
* @param string $do_event
* @param int $mode
* @param bool $conditional
* @access public
*/
public function registerHook($hook_event, $do_event, $mode = hAFTER, $conditional = false)
{
$this->EventManager->registerHook($hook_event, $do_event, $mode, $conditional);
}
/**
* Registers build event for given pseudo class
*
* @param string $pseudo_class
* @param string $event_name
* @access public
*/
public function registerBuildEvent($pseudo_class, $event_name)
{
$this->EventManager->registerBuildEvent($pseudo_class, $event_name);
}
/**
* Allows one TagProcessor tag act as other TagProcessor tag
*
* @param Array $tag_info
* @return void
* @access public
*/
public function registerAggregateTag($tag_info)
{
$aggregator = $this->recallObject('TagsAggregator', 'kArray');
/* @var $aggregator kArray */
$tag_data = Array (
$tag_info['LocalPrefix'],
$tag_info['LocalTagName'],
getArrayValue($tag_info, 'LocalSpecial')
);
$aggregator->SetArrayValue($tag_info['AggregateTo'], $tag_info['AggregatedTagName'], $tag_data);
}
/**
* Returns object using params specified, creates it if is required
*
* @param string $name
* @param string $pseudo_class
* @param Array $event_params
* @param Array $arguments
* @return kBase
*/
public function recallObject($name, $pseudo_class = null, $event_params = Array(), $arguments = Array ())
{
/*if ( !$this->hasObject($name) && $this->isDebugMode() && ($name == '_prefix_here_') ) {
// first time, when object with "_prefix_here_" prefix is accessed
$this->Debugger->appendTrace();
}*/
return $this->Factory->getObject($name, $pseudo_class, $event_params, $arguments);
}
/**
* Returns tag processor for prefix specified
*
* @param string $prefix
* @return kDBTagProcessor
* @access public
*/
public function recallTagProcessor($prefix)
{
$this->InitParser(); // because kDBTagProcesor is in NParser dependencies
return $this->recallObject($prefix . '_TagProcessor');
}
/**
* Checks if object with prefix passes was already created in factory
*
* @param string $name object pseudo_class, prefix
* @return bool
* @access public
*/
public function hasObject($name)
{
return $this->Factory->hasObject($name);
}
/**
* Removes object from storage by given name
*
* @param string $name Object's name in the Storage
* @return void
* @access public
*/
public function removeObject($name)
{
$this->Factory->DestroyObject($name);
}
/**
* Get's real class name for pseudo class, includes class file and creates class instance
*
* Pattern: Factory Method
*
* @param string $pseudo_class
* @param Array $arguments
* @return kBase
* @access public
*/
public function makeClass($pseudo_class, $arguments = Array ())
{
return $this->Factory->makeClass($pseudo_class, $arguments);
}
/**
+ * Returns sub-classes of given ancestor class.
+ *
+ * @param string $ancestor_class Ancestor class.
+ * @param boolean $concrete_only Return only non-abstract classes.
+ *
+ * @return array
+ */
+ public function getSubClasses($ancestor_class, $concrete_only = true)
+ {
+ return $this->Factory->getSubClasses($ancestor_class, $concrete_only);
+ }
+
+ /**
* Checks if application is in debug mode
*
* @param bool $check_debugger check if kApplication debugger is initialized too, not only for defined DEBUG_MODE constant
* @return bool
* @author Alex
* @access public
*/
public function isDebugMode($check_debugger = true)
{
$debug_mode = defined('DEBUG_MODE') && DEBUG_MODE;
if ($check_debugger) {
$debug_mode = $debug_mode && is_object($this->Debugger);
}
return $debug_mode;
}
/**
* Apply url rewriting used by mod_rewrite or not
*
* @param bool|null $ssl Force ssl link to be build
* @return bool
* @access public
*/
public function RewriteURLs($ssl = false)
{
// case #1,#4:
// we want to create https link from http mode
// we want to create https link from https mode
// conditions: ($ssl || PROTOCOL == 'https://') && $this->ConfigValue('UseModRewriteWithSSL')
// case #2,#3:
// we want to create http link from https mode
// we want to create http link from http mode
// conditions: !$ssl && (PROTOCOL == 'https://' || PROTOCOL == 'http://')
$allow_rewriting =
(!$ssl && (PROTOCOL == 'https://' || PROTOCOL == 'http://')) // always allow mod_rewrite for http
|| // or allow rewriting for redirect TO httpS or when already in httpS
(($ssl || PROTOCOL == 'https://') && $this->ConfigValue('UseModRewriteWithSSL')); // but only if it's allowed in config!
return kUtil::constOn('MOD_REWRITE') && $allow_rewriting;
}
/**
* Returns unit config for given prefix
*
* @param string $prefix
* @return kUnitConfig
* @access public
*/
public function getUnitConfig($prefix)
{
return $this->UnitConfigReader->getUnitConfig($prefix);
}
/**
* Returns true if config exists and is allowed for reading
*
* @param string $prefix
* @return bool
*/
public function prefixRegistred($prefix)
{
return $this->UnitConfigReader->prefixRegistered($prefix);
}
/**
* Splits any mixing of prefix and
* special into correct ones
*
* @param string $prefix_special
* @return Array
* @access public
*/
public function processPrefix($prefix_special)
{
return $this->Factory->processPrefix($prefix_special);
}
/**
* Set's new event for $prefix_special
* passed
*
* @param string $prefix_special
* @param string $event_name
* @return void
* @access public
*/
public function setEvent($prefix_special, $event_name)
{
$this->EventManager->setEvent($prefix_special, $event_name);
}
/**
* SQL Error Handler
*
* @param int $code
* @param string $msg
* @param string $sql
* @return bool
* @access public
* @throws Exception
* @deprecated
*/
public function handleSQLError($code, $msg, $sql)
{
return $this->_logger->handleSQLError($code, $msg, $sql);
}
/**
* Returns & blocks next ResourceId available in system
*
* @return int
* @access public
*/
public function NextResourceId()
{
$table_name = TABLE_PREFIX . 'IdGenerator';
$this->Conn->Query('LOCK TABLES ' . $table_name . ' WRITE');
$this->Conn->Query('UPDATE ' . $table_name . ' SET lastid = lastid + 1');
$id = $this->Conn->GetOne('SELECT lastid FROM ' . $table_name);
if ( $id === false ) {
$this->Conn->Query('INSERT INTO ' . $table_name . ' (lastid) VALUES (2)');
$id = 2;
}
$this->Conn->Query('UNLOCK TABLES');
return $id - 1;
}
/**
* Returns genealogical main prefix for sub-table prefix passes
* OR prefix, that has been found in REQUEST and some how is parent of passed sub-table prefix
*
* @param string $current_prefix
* @param bool $real_top if set to true will return real topmost prefix, regardless of its id is passed or not
* @return string
* @access public
*/
public function GetTopmostPrefix($current_prefix, $real_top = false)
{
// 1. get genealogical tree of $current_prefix
$prefixes = Array ($current_prefix);
while ($parent_prefix = $this->getUnitConfig($current_prefix)->getParentPrefix()) {
if ( !$this->prefixRegistred($parent_prefix) ) {
// stop searching, when parent prefix is not registered
break;
}
$current_prefix = $parent_prefix;
array_unshift($prefixes, $current_prefix);
}
if ( $real_top ) {
return $current_prefix;
}
// 2. find what if parent is passed
$passed = explode(',', $this->GetVar('all_passed'));
foreach ($prefixes as $a_prefix) {
if ( in_array($a_prefix, $passed) ) {
return $a_prefix;
}
}
return $current_prefix;
}
/**
* Triggers email event of type Admin
*
* @param string $email_template_name
* @param int $to_user_id
* @param array $send_params associative array of direct send params, possible keys: to_email, to_name, from_email, from_name, message, message_text
* @return kEvent
* @access public
*/
public function emailAdmin($email_template_name, $to_user_id = null, $send_params = Array ())
{
return $this->_email($email_template_name, EmailTemplate::TEMPLATE_TYPE_ADMIN, $to_user_id, $send_params);
}
/**
* Triggers email event of type User
*
* @param string $email_template_name
* @param int $to_user_id
* @param array $send_params associative array of direct send params, possible keys: to_email, to_name, from_email, from_name, message, message_text
* @return kEvent
* @access public
*/
public function emailUser($email_template_name, $to_user_id = null, $send_params = Array ())
{
return $this->_email($email_template_name, EmailTemplate::TEMPLATE_TYPE_FRONTEND, $to_user_id, $send_params);
}
/**
* Triggers general email event
*
* @param string $email_template_name
* @param int $email_template_type (0 for User, 1 for Admin)
* @param int $to_user_id
* @param array $send_params associative array of direct send params,
* possible keys: to_email, to_name, from_email, from_name, message, message_text
* @return kEvent
* @access protected
*/
protected function _email($email_template_name, $email_template_type, $to_user_id = null, $send_params = Array ())
{
$email = $this->makeClass('kEmail');
/* @var $email kEmail */
if ( !$email->findTemplate($email_template_name, $email_template_type) ) {
return false;
}
$email->setParams($send_params);
return $email->send($to_user_id);
}
/**
* Allows to check if user in this session is logged in or not
*
* @return bool
* @access public
*/
public function LoggedIn()
{
// no session during expiration process
return is_null($this->Session) ? false : $this->Session->LoggedIn();
}
/**
* Check current user permissions based on it's group permissions in specified category
*
* @param string $name permission name
* @param int $cat_id category id, current used if not specified
* @param int $type permission type {1 - system, 0 - per category}
* @return int
* @access public
*/
public function CheckPermission($name, $type = 1, $cat_id = null)
{
$perm_helper = $this->recallObject('PermissionsHelper');
/* @var $perm_helper kPermissionsHelper */
return $perm_helper->CheckPermission($name, $type, $cat_id);
}
/**
* Check current admin permissions based on it's group permissions in specified category
*
* @param string $name permission name
* @param int $cat_id category id, current used if not specified
* @param int $type permission type {1 - system, 0 - per category}
* @return int
* @access public
*/
public function CheckAdminPermission($name, $type = 1, $cat_id = null)
{
$perm_helper = $this->recallObject('PermissionsHelper');
/* @var $perm_helper kPermissionsHelper */
return $perm_helper->CheckAdminPermission($name, $type, $cat_id);
}
/**
* Set's any field of current visit
*
* @param string $field
* @param mixed $value
* @return void
* @access public
* @todo move to separate module
*/
public function setVisitField($field, $value)
{
if ( $this->isAdmin || !$this->ConfigValue('UseVisitorTracking') ) {
// admin logins are not registered in visits list
return;
}
$visit = $this->recallObject('visits', null, Array ('raise_warnings' => 0));
/* @var $visit kDBItem */
if ( $visit->isLoaded() ) {
$visit->SetDBField($field, $value);
$visit->Update();
}
}
/**
* Allows to check if in-portal is installed
*
* @return bool
* @access public
*/
public function isInstalled()
{
return $this->InitDone && (count($this->ModuleInfo) > 0);
}
/**
* Allows to determine if module is installed & enabled
*
* @param string $module_name
* @return bool
* @access public
*/
public function isModuleEnabled($module_name)
{
return $this->findModule('Name', $module_name) !== false;
}
/**
* Returns Window ID of passed prefix main prefix (in edit mode)
*
* @param string $prefix
* @return int
* @access public
*/
public function GetTopmostWid($prefix)
{
$top_prefix = $this->GetTopmostPrefix($prefix);
$mode = $this->GetVar($top_prefix . '_mode');
return $mode != '' ? substr($mode, 1) : '';
}
/**
* Get temp table name
*
* @param string $table
* @param mixed $wid
* @return string
* @access public
*/
public function GetTempName($table, $wid = '')
{
return $this->GetTempTablePrefix($wid) . $table;
}
/**
* Builds temporary table prefix based on given window id
*
* @param string $wid
* @return string
* @access public
*/
public function GetTempTablePrefix($wid = '')
{
if ( preg_match('/prefix:(.*)/', $wid, $regs) ) {
$wid = $this->GetTopmostWid($regs[1]);
}
return TABLE_PREFIX . 'ses_' . $this->GetSID() . ($wid ? '_' . $wid : '') . '_edit_';
}
/**
* Checks if given table is a temporary table
*
* @param string $table
* @return bool
* @access public
*/
public function IsTempTable($table)
{
static $cache = Array ();
if ( !array_key_exists($table, $cache) ) {
$cache[$table] = preg_match('/' . TABLE_PREFIX . 'ses_' . $this->GetSID() . '(_[\d]+){0,1}_edit_(.*)/', $table);
}
return (bool)$cache[$table];
}
/**
* Checks, that given prefix is in temp mode
*
* @param string $prefix
* @param string $special
* @return bool
* @access public
*/
public function IsTempMode($prefix, $special = '')
{
$top_prefix = $this->GetTopmostPrefix($prefix);
$var_names = Array (
$top_prefix,
rtrim($top_prefix . '_' . $special, '_'), // from post
rtrim($top_prefix . '.' . $special, '.'), // assembled locally
);
$var_names = array_unique($var_names);
$temp_mode = false;
foreach ($var_names as $var_name) {
$value = $this->GetVar($var_name . '_mode');
if ( $value && (substr($value, 0, 1) == 't') ) {
$temp_mode = true;
break;
}
}
return $temp_mode;
}
/**
* Return live table name based on temp table name
*
* @param string $temp_table
* @return string
*/
public function GetLiveName($temp_table)
{
if ( preg_match('/' . TABLE_PREFIX . 'ses_' . $this->GetSID() . '(_[\d]+){0,1}_edit_(.*)/', $temp_table, $rets) ) {
// cut wid from table end if any
return $rets[2];
}
else {
return $temp_table;
}
}
/**
* Stops processing of user request and displays given message
*
* @param string $message
* @access public
*/
public function ApplicationDie($message = '')
{
while ( ob_get_level() ) {
ob_end_clean();
}
if ( $this->isDebugMode() ) {
$message .= $this->Debugger->printReport(true);
}
$this->HTML = $message;
$this->_outputPage();
}
/**
* Returns comma-separated list of groups from given user
*
* @param int $user_id
* @return string
*/
public function getUserGroups($user_id)
{
switch ($user_id) {
case USER_ROOT:
$user_groups = $this->ConfigValue('User_LoggedInGroup');
break;
case USER_GUEST:
$user_groups = $this->ConfigValue('User_LoggedInGroup') . ',' . $this->ConfigValue('User_GuestGroup');
break;
default:
$sql = 'SELECT GroupId
FROM ' . TABLE_PREFIX . 'UserGroupRelations
WHERE PortalUserId = ' . (int)$user_id;
$res = $this->Conn->GetCol($sql);
$user_groups = Array ($this->ConfigValue('User_LoggedInGroup'));
if ( $res ) {
$user_groups = array_merge($user_groups, $res);
}
$user_groups = implode(',', $user_groups);
}
return $user_groups;
}
/**
* Allows to detect if page is browsed by spider (293 scheduled_tasks supported)
*
* @return bool
* @access public
*/
/*public function IsSpider()
{
static $is_spider = null;
if ( !isset($is_spider) ) {
$user_agent = trim($_SERVER['HTTP_USER_AGENT']);
$robots = file(FULL_PATH . '/core/robots_list.txt');
foreach ($robots as $robot_info) {
$robot_info = explode("\t", $robot_info, 3);
if ( $user_agent == trim($robot_info[2]) ) {
$is_spider = true;
break;
}
}
}
return $is_spider;
}*/
/**
* Allows to detect table's presence in database
*
* @param string $table_name
* @param bool $force
* @return bool
* @access public
*/
public function TableFound($table_name, $force = false)
{
return $this->Conn->TableFound($table_name, $force);
}
/**
* Returns counter value
*
* @param string $name counter name
* @param Array $params counter parameters
* @param string $query_name specify query name directly (don't generate from parameters)
* @param bool $multiple_results
* @return mixed
* @access public
*/
public function getCounter($name, $params = Array (), $query_name = null, $multiple_results = false)
{
$count_helper = $this->recallObject('CountHelper');
/* @var $count_helper kCountHelper */
return $count_helper->getCounter($name, $params, $query_name, $multiple_results);
}
/**
* Resets counter, which are affected by one of specified tables
*
* @param string $tables comma separated tables list used in counting sqls
* @return void
* @access public
*/
public function resetCounters($tables)
{
if ( kUtil::constOn('IS_INSTALL') ) {
return;
}
$count_helper = $this->recallObject('CountHelper');
/* @var $count_helper kCountHelper */
$count_helper->resetCounters($tables);
}
/**
* Sends XML header + optionally displays xml heading
*
* @param string|bool $xml_version
* @return string
* @access public
* @author Alex
*/
public function XMLHeader($xml_version = false)
{
$this->setContentType('text/xml');
return $xml_version ? '' : '';
}
/**
* Returns category tree
*
* @param int $category_id
* @return Array
* @access public
*/
public function getTreeIndex($category_id)
{
$tree_index = $this->getCategoryCache($category_id, 'category_tree');
if ( $tree_index ) {
$ret = Array ();
list ($ret['TreeLeft'], $ret['TreeRight']) = explode(';', $tree_index);
return $ret;
}
return false;
}
/**
* Base category of all categories
* Usually replaced category, with ID = 0 in category-related operations.
*
* @return int
* @access public
*/
public function getBaseCategory()
{
// same, what $this->findModule('Name', 'Core', 'RootCat') does
// don't cache while IS_INSTALL, because of kInstallToolkit::createModuleCategory and upgrade
return $this->ModuleInfo['Core']['RootCat'];
}
/**
* Deletes all data, that was cached during unit config parsing (excluding unit config locations)
*
* @param Array $config_variables
* @access public
*/
public function DeleteUnitCache($config_variables = null)
{
$this->cacheManager->DeleteUnitCache($config_variables);
}
/**
* Deletes cached section tree, used during permission checking and admin console tree display
*
* @return void
* @access public
*/
public function DeleteSectionCache()
{
$this->cacheManager->DeleteSectionCache();
}
/**
* Sets data from cache to object
*
* @param Array $data
* @access public
*/
public function setFromCache(&$data)
{
$this->Factory->setFromCache($data);
$this->UnitConfigReader->setFromCache($data);
$this->EventManager->setFromCache($data);
$this->ReplacementTemplates = $data['Application.ReplacementTemplates'];
$this->RewriteListeners = $data['Application.RewriteListeners'];
$this->ModuleInfo = $data['Application.ModuleInfo'];
}
/**
* Gets object data for caching
* The following caches should be reset based on admin interaction (adjusting config, enabling modules etc)
*
* @access public
* @return Array
*/
public function getToCache()
{
return array_merge(
$this->Factory->getToCache(),
$this->UnitConfigReader->getToCache(),
$this->EventManager->getToCache(),
Array (
'Application.ReplacementTemplates' => $this->ReplacementTemplates,
'Application.RewriteListeners' => $this->RewriteListeners,
'Application.ModuleInfo' => $this->ModuleInfo,
)
);
}
public function delayUnitProcessing($method, $params)
{
$this->cacheManager->delayUnitProcessing($method, $params);
}
/**
* Returns current maintenance mode state
*
* @param bool $check_ips
* @return int
* @access public
*/
public function getMaintenanceMode($check_ips = true)
{
$exception_ips = defined('MAINTENANCE_MODE_IPS') ? MAINTENANCE_MODE_IPS : '';
$setting_name = $this->isAdmin ? 'MAINTENANCE_MODE_ADMIN' : 'MAINTENANCE_MODE_FRONT';
if ( defined($setting_name) && constant($setting_name) > MaintenanceMode::NONE ) {
$exception_ip = $check_ips ? kUtil::ipMatch($exception_ips) : false;
if ( !$exception_ip ) {
return constant($setting_name);
}
}
return MaintenanceMode::NONE;
}
/**
* Sets content type of the page
*
* @param string $content_type
* @param bool $include_charset
* @return void
* @access public
*/
public function setContentType($content_type = 'text/html', $include_charset = null)
{
static $already_set = false;
if ( $already_set ) {
return;
}
$header = 'Content-type: ' . $content_type;
if ( !isset($include_charset) ) {
$include_charset = $content_type = 'text/html' || $content_type == 'text/plain' || $content_type = 'text/xml';
}
if ( $include_charset ) {
$header .= '; charset=' . CHARSET;
}
$already_set = true;
header($header);
}
/**
* Posts message to event log
*
* @param string $message
* @param int $code
* @param bool $write_now Allows further customization of log record by returning kLog object
* @return bool|int|kLogger
* @access public
*/
public function log($message, $code = null, $write_now = false)
{
$log = $this->_logger->prepare($message, $code)->addSource($this->_logger->createTrace(null, 1));
if ( $write_now ) {
return $log->write();
}
return $log;
}
/**
* Deletes log with given id from database or disk, when database isn't available
*
* @param int $unique_id
* @param int $storage_medium
* @return void
* @access public
* @throws InvalidArgumentException
*/
public function deleteLog($unique_id, $storage_medium = kLogger::LS_AUTOMATIC)
{
$this->_logger->delete($unique_id, $storage_medium);
}
/**
* Returns the client IP address.
*
* @return string The client IP address
* @access public
*/
public function getClientIp()
{
return $this->HttpQuery->getClientIp();
}
}
Index: branches/5.3.x/core/kernel/managers/cache_manager.php
===================================================================
--- branches/5.3.x/core/kernel/managers/cache_manager.php (revision 16162)
+++ branches/5.3.x/core/kernel/managers/cache_manager.php (revision 16163)
@@ -1,852 +1,852 @@
Array (),
'registerScheduledTask' => Array (),
'registerHook' => Array (),
'registerBuildEvent' => Array (),
'registerAggregateTag' => Array (),
);
/**
* Name of database table, where configuration settings are stored
*
* @var string
* @access protected
*/
protected $settingTableName = '';
/**
* Set's references to kApplication and DBConnection interface class instances
*
* @access public
*/
public function __construct()
{
parent::__construct();
$this->settingTableName = TABLE_PREFIX . 'SystemSettings';
if ( defined('IS_INSTALL') && IS_INSTALL ) {
// table substitution required, so "root" can perform login to upgrade to 5.2.0, where setting table was renamed
if ( !$this->Application->TableFound(TABLE_PREFIX . 'SystemSettings') ) {
$this->settingTableName = TABLE_PREFIX . 'ConfigurationValues';
}
}
}
/**
* Creates caching manager instance
*
* @access public
*/
public function InitCache()
{
$this->cacheHandler = $this->Application->makeClass('kCache');
}
/**
* Returns cache key, used to cache phrase and configuration variable IDs used on current page
*
* @return string
* @access protected
*/
protected function getCacheKey()
{
// TODO: maybe language part isn't required, since same phrase from different languages have one ID now
return $this->Application->GetVar('t') . $this->Application->GetVar('m_theme') . $this->Application->GetVar('m_lang') . $this->Application->isAdmin;
}
/**
* Loads phrases and configuration variables, that were used on this template last time
*
* @access public
*/
public function LoadApplicationCache()
{
$phrase_ids = $config_ids = Array ();
$sql = 'SELECT PhraseList, ConfigVariables
FROM ' . TABLE_PREFIX . 'PhraseCache
WHERE Template = ' . $this->Conn->qstr( md5($this->getCacheKey()) );
$res = $this->Conn->GetRow($sql);
if ($res) {
if ( $res['PhraseList'] ) {
$phrase_ids = explode(',', $res['PhraseList']);
}
if ( $res['ConfigVariables'] ) {
$config_ids = array_diff( explode(',', $res['ConfigVariables']), $this->originalConfigIDs);
}
}
$this->Application->Phrases->Init('phrases', '', null, $phrase_ids);
$this->configIDs = $this->originalConfigIDs = $config_ids;
$this->InitConfig();
}
/**
* Updates phrases and configuration variables, that were used on this template
*
* @access public
*/
public function UpdateApplicationCache()
{
$update = false;
//something changed
$update = $update || $this->Application->Phrases->NeedsCacheUpdate();
$update = $update || (count($this->configIDs) && $this->configIDs != $this->originalConfigIDs);
if ($update) {
$fields_hash = Array (
'PhraseList' => implode(',', $this->Application->Phrases->Ids),
'CacheDate' => time(),
'Template' => md5( $this->getCacheKey() ),
'ConfigVariables' => implode(',', array_unique($this->configIDs)),
);
$this->Conn->doInsert($fields_hash, TABLE_PREFIX . 'PhraseCache', 'REPLACE');
}
}
/**
* Loads configuration variables, that were used on this template last time
*
* @access protected
*/
protected function InitConfig()
{
if (!$this->originalConfigIDs) {
return ;
}
$sql = 'SELECT VariableValue, VariableName
FROM ' . $this->settingTableName . '
WHERE VariableId IN (' . implode(',', $this->originalConfigIDs) . ')';
$config_variables = $this->Conn->GetCol($sql, 'VariableName');
$this->configVariables = array_merge($this->configVariables, $config_variables);
}
/**
* Returns configuration option value by name
*
* @param string $name
* @return string
* @access public
*/
public function ConfigValue($name)
{
$site_domain_override = Array (
'DefaultEmailSender' => 'AdminEmail',
'DefaultEmailRecipients' => 'DefaultEmailRecipients',
);
if ( isset($site_domain_override[$name]) ) {
$res = $this->Application->siteDomainField($site_domain_override[$name]);
if ( $res ) {
return $res;
}
}
if ( array_key_exists($name, $this->configVariables) ) {
return $this->configVariables[$name];
}
if ( defined('IS_INSTALL') && IS_INSTALL && !$this->Application->TableFound($this->settingTableName, true) ) {
return false;
}
$this->Conn->nextQueryCachable = true;
$sql = 'SELECT VariableId, VariableValue
FROM ' . $this->settingTableName . '
WHERE VariableName = ' . $this->Conn->qstr($name);
$res = $this->Conn->GetRow($sql);
if ( $res !== false ) {
$this->configIDs[] = $res['VariableId'];
$this->configVariables[$name] = $res['VariableValue'];
return $res['VariableValue'];
}
trigger_error('Usage of undefined configuration variable "' . $name . '"', E_USER_NOTICE);
return false;
}
/**
* Changes value of individual configuration variable (+resets cache, when needed)
*
* @param string $name
* @param string $value
* @param bool $local_cache_only
* @return string
* @access public
*/
public function SetConfigValue($name, $value, $local_cache_only = false)
{
$this->configVariables[$name] = $value;
if ( $local_cache_only ) {
return;
}
$fields_hash = Array ('VariableValue' => $value);
$this->Conn->doUpdate($fields_hash, $this->settingTableName, 'VariableName = ' . $this->Conn->qstr($name));
if ( array_key_exists($name, $this->originalConfigVariables) && $value != $this->originalConfigVariables[$name] ) {
$this->DeleteUnitCache();
}
}
/**
* Loads data, that was cached during unit config parsing
*
* @return bool
* @access public
*/
public function LoadUnitCache()
{
if ( $this->Application->isCachingType(CACHING_TYPE_MEMORY) ) {
$data = $this->Application->getCache('master:configs_parsed', false, CacheSettings::$unitCacheRebuildTime);
}
else {
$data = $this->Application->getDBCache('configs_parsed', CacheSettings::$unitCacheRebuildTime);
}
if ( $data ) {
$cache = unserialize($data); // 126 KB all modules
unset($data);
$this->Application->InitManagers();
$this->Application->setFromCache($cache);
$aggregator = $this->Application->recallObject('TagsAggregator', 'kArray');
/* @var $aggregator kArray */
$aggregator->setFromCache($cache);
$this->setFromCache($cache);
unset($cache);
return true;
}
return false;
}
/**
* Empties factory and event manager cache (without storing changes)
*/
public function EmptyUnitCache()
{
// maybe discover keys automatically from corresponding classes
$cache_keys = Array (
- 'Factory.Files', 'Factory.Namespaces', 'Factory.realClasses',
+ 'Factory.Files', 'Factory.ClassInfo', 'Factory.ClassTree', 'Factory.Namespaces', 'Factory.realClasses',
'ConfigReader.prefixFiles', 'ConfigCloner.clones',
'EventManager.beforeHooks', 'EventManager.afterHooks', 'EventManager.scheduledTasks', 'EventManager.buildEvents',
'Application.ReplacementTemplates', 'Application.RewriteListeners', 'Application.ModuleInfo',
'Application.ConfigHash', 'Application.ConfigCacheIds',
);
$empty_cache = Array ();
foreach ($cache_keys as $cache_key) {
$empty_cache[$cache_key] = Array ();
}
$this->Application->setFromCache($empty_cache);
$this->setFromCache($empty_cache);
// Otherwise kModulesHelper indirectly used from includeConfigFiles won't work.
$this->Application->RegisterDefaultClasses();
}
/**
* Updates data, that was parsed from unit configs this time
*
* @access public
*/
public function UpdateUnitCache()
{
$aggregator = $this->Application->recallObject('TagsAggregator', 'kArray');
/* @var $aggregator kArray */
$this->preloadConfigVars(); // preloading will put to cache
$cache = array_merge(
$this->Application->getToCache(),
$aggregator->getToCache(),
$this->getToCache()
);
$cache_rebuild_by = SERVER_NAME . ' (' . $this->Application->getClientIp() . ') - ' . date('d/m/Y H:i:s');
if ($this->Application->isCachingType(CACHING_TYPE_MEMORY)) {
$this->Application->setCache('master:configs_parsed', serialize($cache));
$this->Application->setCache('master:last_cache_rebuild', $cache_rebuild_by);
}
else {
$this->Application->setDBCache('configs_parsed', serialize($cache));
$this->Application->setDBCache('last_cache_rebuild', $cache_rebuild_by);
}
}
public function delayUnitProcessing($method, $params)
{
if ($this->Application->InitDone) {
// init already done -> call immediately (happens during installation)
$function = Array (&$this->Application, $method);
call_user_func_array($function, $params);
return ;
}
$this->temporaryCache[$method][] = $params;
}
public function applyDelayedUnitProcessing()
{
foreach ($this->temporaryCache as $method => $method_calls) {
$function = Array (&$this->Application, $method);
foreach ($method_calls as $method_call) {
call_user_func_array($function, $method_call);
}
$this->temporaryCache[$method] = Array ();
}
}
/**
* Deletes all data, that was cached during unit config parsing (excluding unit config locations)
*
* @param Array $config_variables
* @access public
*/
public function DeleteUnitCache($config_variables = null)
{
if ( isset($config_variables) && !array_intersect(array_keys($this->originalConfigVariables), $config_variables) ) {
// prevent cache reset, when given config variables are not in unit cache
return;
}
if ( $this->Application->isCachingType(CACHING_TYPE_MEMORY) ) {
$this->Application->rebuildCache('master:configs_parsed', kCache::REBUILD_LATER, CacheSettings::$unitCacheRebuildTime);
}
else {
$this->rebuildDBCache('configs_parsed', kCache::REBUILD_LATER, CacheSettings::$unitCacheRebuildTime);
}
}
/**
* Deletes cached section tree, used during permission checking and admin console tree display
*
* @return void
* @access public
*/
public function DeleteSectionCache()
{
if ( $this->Application->isCachingType(CACHING_TYPE_MEMORY) ) {
$this->Application->rebuildCache('master:sections_parsed', kCache::REBUILD_LATER, CacheSettings::$sectionsParsedRebuildTime);
}
else {
$this->rebuildDBCache('sections_parsed', kCache::REBUILD_LATER, CacheSettings::$sectionsParsedRebuildTime);
}
}
/**
* Preloads 21 widely used configuration variables, so they will get to cache for sure
*
* @access protected
*/
protected function preloadConfigVars()
{
$config_vars = Array (
// session related
'SessionTimeout', 'SessionCookieName', 'SessionCookieDomains', 'SessionBrowserSignatureCheck',
'SessionIPAddressCheck', 'CookieSessions', 'KeepSessionOnBrowserClose', 'User_GuestGroup',
'User_LoggedInGroup', 'RegistrationUsernameRequired',
// output related
'UseModRewrite', 'UseContentLanguageNegotiation', 'UseOutputCompression', 'OutputCompressionLevel',
'Config_Site_Time', 'SystemTagCache', 'DefaultGridPerPage',
// tracking related
'UseChangeLog', 'UseVisitorTracking', 'ModRewriteUrlEnding', 'ForceModRewriteUrlEnding',
'RunScheduledTasksFromCron',
);
$escaped_config_vars = $this->Conn->qstrArray($config_vars);
$sql = 'SELECT VariableId, VariableName, VariableValue
FROM ' . $this->settingTableName . '
WHERE VariableName IN (' . implode(',', $escaped_config_vars) . ')';
$data = $this->Conn->Query($sql, 'VariableId');
foreach ($data as $variable_id => $variable_info) {
$this->configIDs[] = $variable_id;
$this->configVariables[ $variable_info['VariableName'] ] = $variable_info['VariableValue'];
}
}
/**
* Sets data from cache to object
*
* Used for cases, when ConfigValue is called before LoadApplicationCache method (e.g. session init, url engine init)
*
* @param Array $data
* @access public
*/
public function setFromCache(&$data)
{
$this->configVariables = $this->originalConfigVariables = $data['Application.ConfigHash'];
$this->configIDs = $this->originalConfigIDs = $data['Application.ConfigCacheIds'];
}
/**
* Gets object data for caching
* The following caches should be reset based on admin interaction (adjusting config, enabling modules etc)
*
* @access public
* @return Array
*/
public function getToCache()
{
return Array (
'Application.ConfigHash' => $this->configVariables,
'Application.ConfigCacheIds' => $this->configIDs,
// not in use, since it only represents template specific values, not global ones
// 'Application.Caches.ConfigVariables' => $this->originalConfigIDs,
);
}
/**
* Returns caching type (none, memory, temporary)
*
* @param int $caching_type
* @return bool
* @access public
*/
public function isCachingType($caching_type)
{
return $this->cacheHandler->getCachingType() == $caching_type;
}
/**
* Returns cached $key value from cache named $cache_name
*
* @param int $key key name from cache
* @param bool $store_locally store data locally after retrieved
* @param int $max_rebuild_seconds
* @return mixed
* @access public
*/
public function getCache($key, $store_locally = true, $max_rebuild_seconds = 0)
{
return $this->cacheHandler->getCache($key, $store_locally, $max_rebuild_seconds);
}
/**
* Stores new $value in cache with $key name
*
* @param int $key key name to add to cache
* @param mixed $value value of cached record
* @param int $expiration when value expires (0 - doesn't expire)
* @return bool
* @access public
*/
public function setCache($key, $value, $expiration = 0)
{
return $this->cacheHandler->setCache($key, $value, $expiration);
}
/**
* Stores new $value in cache with $key name (only if not there already)
*
* @param int $key key name to add to cache
* @param mixed $value value of cached record
* @param int $expiration when value expires (0 - doesn't expire)
* @return bool
* @access public
*/
public function addCache($key, $value, $expiration = 0)
{
return $this->cacheHandler->addCache($key, $value, $expiration);
}
/**
* Sets rebuilding mode for given cache
*
* @param string $name
* @param int $mode
* @param int $max_rebuilding_time
* @return bool
* @access public
*/
public function rebuildCache($name, $mode = null, $max_rebuilding_time = 0)
{
return $this->cacheHandler->rebuildCache($name, $mode, $max_rebuilding_time);
}
/**
* Deletes key from cache
*
* @param string $key
* @return void
* @access public
*/
public function deleteCache($key)
{
$this->cacheHandler->delete($key);
}
/**
* Reset's all memory cache at once
*
* @return void
* @access public
*/
public function resetCache()
{
$this->cacheHandler->reset();
}
/**
* Returns value from database cache
*
* @param string $name key name
* @param int $max_rebuild_seconds
* @return mixed
* @access public
*/
public function getDBCache($name, $max_rebuild_seconds = 0)
{
// no serials in cache key OR cache is outdated
$rebuilding = false;
$wait_seconds = $max_rebuild_seconds;
while (true) {
$cached_data = $this->_getDBCache(Array ($name, $name . '_rebuilding', $name . '_rebuild'));
if ( $cached_data[$name . '_rebuild'] ) {
// cache rebuild requested -> rebuild now
$this->deleteDBCache($name . '_rebuild');
if ( $this->rebuildDBCache($name, kCache::REBUILD_NOW, $max_rebuild_seconds, '[M1]') ) {
return false;
}
}
$cache = $cached_data[$name];
$rebuilding = $cached_data[$name . '_rebuilding'];
if ( ($cache === false) && (!$rebuilding || $wait_seconds == 0) ) {
// cache missing and nobody rebuilding it -> rebuild; enough waiting for cache to be ready
$this->rebuildDBCache($name, kCache::REBUILD_NOW, $max_rebuild_seconds, '[M2' . ($rebuilding ? 'R' : '!R') . ',WS=' . $wait_seconds . ']');
return false;
}
elseif ( $cache !== false ) {
// cache present -> return it
$this->cacheHandler->storeStatistics($name, $rebuilding ? 'h' : 'H');
return $cache;
}
$wait_seconds -= kCache::WAIT_STEP;
sleep(kCache::WAIT_STEP);
}
$this->rebuildDBCache($name, kCache::REBUILD_NOW, $max_rebuild_seconds, '[M3' . ($rebuilding ? 'R' : '!R') . ',WS=' . $wait_seconds . ']');
return false;
}
/**
* Returns value from database cache
*
* @param string|Array $names key name
* @return mixed
* @access protected
*/
protected function _getDBCache($names)
{
$res = Array ();
$names = (array)$names;
$this->Conn->nextQueryCachable = true;
$sql = 'SELECT Data, Cached, LifeTime, VarName
FROM ' . TABLE_PREFIX . 'SystemCache
WHERE VarName IN (' . implode(',', $this->Conn->qstrArray($names)) . ')';
$cached_data = $this->Conn->Query($sql, 'VarName');
foreach ($names as $name) {
if ( !isset($cached_data[$name]) ) {
$res[$name] = false;
continue;
}
$lifetime = (int)$cached_data[$name]['LifeTime']; // in seconds
if ( ($lifetime > 0) && ($cached_data[$name]['Cached'] + $lifetime < time()) ) {
// delete expired
$this->Conn->nextQueryCachable = true;
$sql = 'DELETE FROM ' . TABLE_PREFIX . 'SystemCache
WHERE VarName = ' . $this->Conn->qstr($name);
$this->Conn->Query($sql);
$res[$name] = false;
continue;
}
$res[$name] = $cached_data[$name]['Data'];
}
return count($res) == 1 ? array_pop($res) : $res;
}
/**
* Sets value to database cache
*
* @param string $name
* @param mixed $value
* @param int|bool $expiration
* @return void
* @access public
*/
public function setDBCache($name, $value, $expiration = false)
{
$this->cacheHandler->storeStatistics($name, 'WU');
$this->deleteDBCache($name . '_rebuilding');
$this->_setDBCache($name, $value, $expiration);
}
/**
* Sets value to database cache
*
* @param string $name
* @param mixed $value
* @param int|bool $expiration
* @param string $insert_type
* @return bool
* @access protected
*/
protected function _setDBCache($name, $value, $expiration = false, $insert_type = 'REPLACE')
{
if ( (int)$expiration <= 0 ) {
$expiration = -1;
}
$fields_hash = Array (
'VarName' => $name,
'Data' => &$value,
'Cached' => time(),
'LifeTime' => (int)$expiration,
);
$this->Conn->nextQueryCachable = true;
return $this->Conn->doInsert($fields_hash, TABLE_PREFIX . 'SystemCache', $insert_type);
}
/**
* Sets value to database cache
*
* @param string $name
* @param mixed $value
* @param int|bool $expiration
* @return bool
* @access protected
*/
protected function _addDBCache($name, $value, $expiration = false)
{
return $this->_setDBCache($name, $value, $expiration, 'INSERT');
}
/**
* Sets rebuilding mode for given cache
*
* @param string $name
* @param int $mode
* @param int $max_rebuilding_time
* @param string $miss_type
* @return bool
* @access public
*/
public function rebuildDBCache($name, $mode = null, $max_rebuilding_time = 0, $miss_type = 'M')
{
if ( !isset($mode) || $mode == kCache::REBUILD_NOW ) {
$this->cacheHandler->storeStatistics($name, $miss_type);
if ( !$max_rebuilding_time ) {
return true;
}
if ( !$this->_addDBCache($name . '_rebuilding', 1, $max_rebuilding_time) ) {
$this->cacheHandler->storeStatistics($name, 'l');
return false;
}
$this->deleteDBCache($name . '_rebuild');
$this->cacheHandler->storeStatistics($name, 'L');
}
elseif ( $mode == kCache::REBUILD_LATER ) {
$this->_setDBCache($name . '_rebuild', 1, 0);
$this->deleteDBCache($name . '_rebuilding');
}
return true;
}
/**
* Deletes key from database cache
*
* @param string $name
* @return void
* @access public
*/
public function deleteDBCache($name)
{
$sql = 'DELETE FROM ' . TABLE_PREFIX . 'SystemCache
WHERE VarName = ' . $this->Conn->qstr($name);
$this->Conn->Query($sql);
}
/**
* Increments serial based on prefix and it's ID (optional)
*
* @param string $prefix
* @param int $id ID (value of IDField) or ForeignKeyField:ID
* @param bool $increment
* @return string
* @access public
*/
public function incrementCacheSerial($prefix, $id = null, $increment = true)
{
$pascal_case_prefix = implode('', array_map('ucfirst', explode('-', $prefix)));
$serial_name = $pascal_case_prefix . (isset($id) ? 'IDSerial:' . $id : 'Serial');
if ($increment) {
if (defined('DEBUG_MODE') && DEBUG_MODE && $this->Application->isDebugMode()) {
$this->Application->Debugger->appendHTML('Incrementing serial: ' . $serial_name . '.');
}
$this->setCache($serial_name, (int)$this->getCache($serial_name) + 1);
if (!defined('IS_INSTALL') || !IS_INSTALL) {
// delete cached mod-rewrite urls related to given prefix and id
$delete_clause = isset($id) ? $prefix . ':' . $id : $prefix;
$sql = 'DELETE FROM ' . TABLE_PREFIX . 'CachedUrls
WHERE Prefixes LIKE ' . $this->Conn->qstr('%|' . $delete_clause . '|%');
$this->Conn->Query($sql);
}
}
return $serial_name;
}
/**
* Returns cached category informaton by given cache name. All given category
* information is recached, when at least one of 4 caches is missing.
*
* @param int $category_id
* @param string $name cache name = {filenames, category_designs, category_tree}
* @return string
* @access public
*/
public function getCategoryCache($category_id, $name)
{
$serial_name = '[%CIDSerial:' . $category_id . '%]';
$cache_key = $name . $serial_name;
$ret = $this->getCache($cache_key);
if ($ret === false) {
if (!$category_id) {
// don't query database for "Home" category (ID = 0), because it doesn't exist in database
return false;
}
// this allows to save 2 sql queries for each category
$this->Conn->nextQueryCachable = true;
$sql = 'SELECT NamedParentPath, CachedTemplate, TreeLeft, TreeRight
FROM ' . TABLE_PREFIX . 'Categories
WHERE CategoryId = ' . (int)$category_id;
$category_data = $this->Conn->GetRow($sql);
if ($category_data !== false) {
// only direct links to category pages work (symlinks, container pages and so on won't work)
$this->setCache('filenames' . $serial_name, $category_data['NamedParentPath']);
$this->setCache('category_designs' . $serial_name, ltrim($category_data['CachedTemplate'], '/'));
$this->setCache('category_tree' . $serial_name, $category_data['TreeLeft'] . ';' . $category_data['TreeRight']);
}
}
return $this->getCache($cache_key);
}
}
Index: branches/5.3.x/core/kernel/utility/ClassDiscovery/ClassMapBuilder.php
===================================================================
--- branches/5.3.x/core/kernel/utility/ClassDiscovery/ClassMapBuilder.php (revision 16162)
+++ branches/5.3.x/core/kernel/utility/ClassDiscovery/ClassMapBuilder.php (revision 16163)
@@ -1,435 +1,448 @@
class > class_info).
*
* @var array
*/
- protected $fileToClassMap = array();
+ protected $buildingCache = array();
+
+ /**
+ * Class information (type, extends, implements, etc.).
+ *
+ * @var array
+ */
+ protected $classInfo = array();
/**
* Stores hash of each file on given path.
*
* @var array
*/
protected $fileHashes = array();
/**
* Parser.
*
* @var Parser
*/
protected $parser;
/**
* Node traverser.
*
* @var NodeTraverser
*/
protected $traverser;
/**
* Name of file, that is currently processed.
*
* @var string
*/
protected $currentFile;
/**
* Returns builder array for all eligible folders.
*
* @param array $module_info Module info.
*
* @return static[]
*/
public static function createBuilders(array $module_info = null)
{
$ret = array();
if ( !isset($module_info) ) {
// No module information given > scan everything.
$ret[] = new static(FULL_PATH . DIRECTORY_SEPARATOR . 'core');
foreach ( glob(MODULES_PATH . '/*', GLOB_ONLYDIR) as $module_folder ) {
if ( \kModulesHelper::isInPortalModule($module_folder) ) {
$ret[] = new static($module_folder);
}
}
}
else {
// Module information given > scan only these modules.
foreach ( $module_info as $module_name => $module_data ) {
if ( $module_name == 'In-Portal' ) {
continue;
}
$ret[] = new static(FULL_PATH . DIRECTORY_SEPARATOR . rtrim($module_data['Path'], '/'));
}
}
return $ret;
}
/**
* Creates ClassMapBuilder instance.
*
* @param string $scan_path Path to scan.
*/
public function __construct($scan_path)
{
$this->scanPath = $scan_path;
$this->assertPath($this->scanPath);
$this->cachePath = $this->scanPath . '/install/cache';
$this->assertPath($this->cachePath);
}
/**
* Validates that path exists and is directory.
*
* @param string $path Path.
*
* @return void
* @throws \InvalidArgumentException When invalid path is given.
*/
protected function assertPath($path)
{
if ( !file_exists($path) || !is_dir($path) ) {
throw new \InvalidArgumentException('Path "' . $path . '" is not a folder or doesn\'t exist');
}
}
/**
- * Returns class map, that was build previously.
+ * Returns class map and class information, that was built previously.
*
* @return array
*/
public function get()
{
$this->load(self::CACHE_FILE_STRUCTURE, false);
- return $this->classToFileMap;
+ return array($this->classToFileMap, $this->classInfo);
}
/**
* Builds class map.
*
* @return void
* @throws \RuntimeException When PHP parser not found.
*/
public function build()
{
if ( !class_exists('PhpParser\Parser') ) {
- $error_msg = 'PHP Parser not found. ';
- $error_msg .= 'Make sure, that Composer dependencies were installed using "php composer.phar install --dev" command.';
+ $error_msg = 'PHP Parser not found. Make sure, that Composer dependencies were ';
+ $error_msg .= 'installed using "php composer.phar install --dev" command.';
throw new \RuntimeException($error_msg);
}
$scan_path = preg_replace('/^' . preg_quote(FULL_PATH, '/') . '/', '...', $this->scanPath, 1);
echo $this->strPad('path "' . $scan_path . '"', 40);
$this->load(self::CACHE_FILE_STRUCTURE, true);
$this->load(self::CACHE_FILE_HASHES, true);
$start = microtime(true);
$files = $this->scan();
echo $this->strPad('scanned in ' . sprintf('%.4f', microtime(true) - $start) . 's', 25);
$start = microtime(true);
$this->createParser();
foreach ( $files as $file ) {
$this->parseFile($file);
}
echo $this->strPad('parsed in ' . sprintf('%.4f', microtime(true) - $start) . 's', 25);
echo PHP_EOL;
ksort($this->classToFileMap);
ksort($this->fileHashes);
+ ksort($this->classInfo);
$this->store(self::CACHE_FILE_STRUCTURE);
$this->store(self::CACHE_FILE_HASHES);
}
/**
* Pads text with spaces from right side.
*
* @param string $text Text.
* @param integer $length Pad length.
*
* @return string
*/
protected function strPad($text, $length)
{
return str_pad($text, $length, ' ', STR_PAD_RIGHT);
}
/**
* Loads cache from disk.
*
* @param string $filename Filename.
* @param boolean $for_writing Load cache for writing or reading.
*
* @return void
*/
protected function load($filename, $for_writing)
{
$file_path = $this->getCacheFilename($filename);
if ( !file_exists($file_path) ) {
return;
}
$cache = include $file_path;
- if ( $cache['cache_format'] < self::CACHE_FORMAT ) {
+ if ( $cache['cache_format'] != self::CACHE_FORMAT ) {
return;
}
if ( $filename === self::CACHE_FILE_STRUCTURE ) {
+ $class_info = $cache['class_info'];
+
if ( $for_writing ) {
foreach ( $cache['classes'] as $class => $file ) {
- if ( !isset($this->fileToClassMap[$file]) ) {
- $this->fileToClassMap[$file] = array();
+ if ( !isset($this->buildingCache[$file]) ) {
+ $this->buildingCache[$file] = array();
}
- $this->fileToClassMap[$file][] = $class;
+ $this->buildingCache[$file][$class] = $class_info[$class];
}
}
else {
$this->classToFileMap = $cache['classes'];
+ $this->classInfo = $class_info;
}
}
elseif ( $filename === self::CACHE_FILE_HASHES ) {
$this->fileHashes = $cache['file_hashes'];
}
}
/**
* Scans path for files.
*
* @return array
*/
protected function scan()
{
$files = array();
$directory_iterator = new \RecursiveDirectoryIterator($this->scanPath);
$filter_iterator = new CodeFolderFilterIterator($directory_iterator);
foreach ( new \RecursiveIteratorIterator($filter_iterator, \RecursiveIteratorIterator::SELF_FIRST) as $file ) {
/* @var \SplFileInfo $file */
if ( $file->isFile() && $file->getExtension() === 'php' ) {
$relative_path = preg_replace('/^' . preg_quote(FULL_PATH, '/') . '/', '', $file->getPathname(), 1);
$files[$relative_path] = true;
}
}
// Don't include cache file itself in cache.
$exclude_file = preg_replace(
'/^' . preg_quote(FULL_PATH, '/') . '/',
'',
$this->getCacheFilename(self::CACHE_FILE_STRUCTURE),
1
);
unset($files[$exclude_file]);
$exclude_file = preg_replace(
'/^' . preg_quote(FULL_PATH, '/') . '/',
'',
$this->getCacheFilename(self::CACHE_FILE_HASHES),
1
);
unset($files[$exclude_file]);
return array_keys($files);
}
/**
* Create parser.
*
* @return void
*/
protected function createParser()
{
+ \kUtil::setResourceLimit();
ini_set('xdebug.max_nesting_level', 3000);
$this->parser = new Parser(new Lexer());
$this->traverser = new NodeTraverser();
$this->traverser->addVisitor(new NameResolver());
$this->traverser->addVisitor(new ClassDetector($this));
}
/**
* Parses a file.
*
* @param string $file Path to file.
*
* @return void
*/
protected function parseFile($file)
{
$this->currentFile = $file;
$code = file_get_contents(FULL_PATH . $file);
$current_hash = filesize(FULL_PATH . $file);
$previous_hash = isset($this->fileHashes[$file]) ? $this->fileHashes[$file] : 0;
if ( $current_hash === $previous_hash ) {
// File wasn't change since time, when cache was built.
- if ( isset($this->fileToClassMap[$file]) ) {
- foreach ( $this->fileToClassMap[$file] as $class ) {
- $this->addClass($class);
+ if ( isset($this->buildingCache[$file]) ) {
+ foreach ( $this->buildingCache[$file] as $class => $class_info ) {
+ $this->addClass($class, $class_info);
}
}
}
else {
// Parse file, because it's content doesn't match the cache.
- $this->fileToClassMap[$file] = array();
$this->fileHashes[$file] = $current_hash;
$statements = $this->parser->parse($code);
$this->traverser->traverse($statements);
}
}
/**
* Stores cache to disk.
*
* @param string $filename Cache filename.
*
* @return void
* @throws \RuntimeException When cache could not be written.
*/
protected function store($filename)
{
$cache = array('cache_format' => self::CACHE_FORMAT);
if ( $filename === self::CACHE_FILE_STRUCTURE ) {
$cache['classes'] = $this->classToFileMap;
+ $cache['class_info'] = $this->classInfo;
}
elseif ( $filename === self::CACHE_FILE_HASHES ) {
$cache['file_hashes'] = $this->fileHashes;
}
$cache = $this->prettyVarExport($cache);
$at = '@';
$file_content = <<getCacheFilename($filename);
// Don't bother saving, because file wasn't even changed.
if ( file_exists($file_path) && file_get_contents($file_path) === $file_content ) {
return;
}
if ( file_put_contents($file_path, $file_content) === false ) {
throw new \RuntimeException('Unable to save cache to "' . $file_path . '" file');
}
}
/**
* Prettified var_export.
*
* @param mixed $data Data.
*
* @return string
*/
protected function prettyVarExport($data)
{
$result = var_export($data, true);
$result = preg_replace("/=> \n[ ]+array \\(/s", '=> array (', $result);
$result = str_replace(array('array (', ' '), array('array(', "\t"), $result);
return $result;
}
/**
* Returns cache filename.
*
* @param string $filename Filename.
*
* @return string
*/
protected function getCacheFilename($filename)
{
return $this->cachePath . '/' . $filename;
}
/**
* Adds class to the map.
*
- * @param string $class Class.
+ * @param string $class Class.
+ * @param array $class_info Class info.
*
* @return void
*/
- public function addClass($class)
+ public function addClass($class, array $class_info)
{
+ $this->classInfo[$class] = $class_info;
$this->classToFileMap[$class] = $this->currentFile;
- $this->fileToClassMap[$this->currentFile][] = $class;
}
}
Index: branches/5.3.x/core/kernel/utility/ClassDiscovery/ClassDetector.php
===================================================================
--- branches/5.3.x/core/kernel/utility/ClassDiscovery/ClassDetector.php (revision 16162)
+++ branches/5.3.x/core/kernel/utility/ClassDiscovery/ClassDetector.php (revision 16163)
@@ -1,65 +1,115 @@
classMapBuilder = $class_map_builder;
}
/**
* Remembers all encountered classes.
*
* @param Node $node Node.
*
* @return void
*/
public function enterNode(Node $node)
{
if ( $node instanceof ClassLike ) {
- $this->classMapBuilder->addClass((string)$node->namespacedName);
+ $class_info = array();
+
+ if ( $node instanceof Class_ ) {
+ $class_info['type'] = \kFactory::TYPE_CLASS;
+ $class_info['modifiers'] = 0;
+
+ if ( $node->isAbstract() ) {
+ $class_info['modifiers'] |= \kFactory::MODIFIER_ABSTRACT;
+ }
+
+ if ( $node->isFinal() ) {
+ $class_info['modifiers'] |= \kFactory::MODIFIER_FINAL;
+ }
+
+ $extends = array();
+
+ if ( $node->extends ) {
+ $extends[] = (string)$node->extends;
+ }
+
+ if ( $node->implements ) {
+ foreach ( $node->implements as $interface ) {
+ $extends[] = (string)$interface;
+ }
+ }
+
+ if ( $extends ) {
+ $class_info['extends'] = $extends;
+ }
+ }
+ elseif ( $node instanceof Interface_ ) {
+ $class_info['type'] = \kFactory::TYPE_INTERFACE;
+
+ if ( $node->extends ) {
+ $extends = array();
+
+ foreach ( $node->extends as $interface ) {
+ $extends[] = (string)$interface;
+ }
+
+ $class_info['extends'] = $extends;
+ }
+ }
+ elseif ( $node instanceof Trait_ ) {
+ $class_info['type'] = \kFactory::TYPE_TRAIT;
+ }
+
+ $this->classMapBuilder->addClass((string)$node->namespacedName, $class_info);
}
}
}
Index: branches/5.3.x/core/kernel/utility/factory.php
===================================================================
--- branches/5.3.x/core/kernel/utility/factory.php (revision 16162)
+++ branches/5.3.x/core/kernel/utility/factory.php (revision 16163)
@@ -1,393 +1,492 @@
Application->ModuleInfo ) {
$error_msg = 'Autoloader configuration can be only performed after module information is available';
throw new LogicException($error_msg);
}
$this->namespaceMap = array();
foreach ( $this->Application->ModuleInfo as $module_name => $module_info ) {
if ( $module_name == 'In-Portal' ) {
continue;
}
$this->namespaceMap[$module_info['ClassNamespace']] = rtrim($module_info['Path'], '/');
}
if ( defined('IS_INSTALL') && IS_INSTALL ) {
// During installation process all modules, because unit configs from all modules are scanned too.
$class_map_builders = ClassMapBuilder::createBuilders();
}
else {
$class_map_builders = ClassMapBuilder::createBuilders($this->Application->ModuleInfo);
}
foreach ( $class_map_builders as $class_map_builder ) {
- $class_map = $class_map_builder->get();
+ list($class_map, $class_info) = $class_map_builder->get();
$class_names = array_keys($class_map);
$this->classMap = array_merge($this->classMap, $class_map);
+ $this->classInfo = array_merge($this->classInfo, $class_info);
$this->realClasses = array_merge($this->realClasses, array_combine($class_names, $class_names));
+
+ foreach ( $class_info as $class => $class_data ) {
+ if ( isset($class_data['extends']) ) {
+ foreach ( $class_data['extends'] as $extends_class ) {
+ if ( !isset($this->classTree[$extends_class]) ) {
+ $this->classTree[$extends_class] = array();
+ }
+
+ $this->classTree[$extends_class][] = $class;
+ }
+ }
+ }
}
}
/**
* Sets data from cache to object
*
* @param Array $data
* @return void
* @access public
*/
public function setFromCache(&$data)
{
$this->classMap = $data['Factory.Files'];
+ $this->classInfo = $data['Factory.ClassInfo'];
+ $this->classTree = $data['Factory.ClassTree'];
$this->namespaceMap = $data['Factory.Namespaces'];
$this->realClasses = $data['Factory.realClasses'];
}
/**
* Performs automatic loading of classes registered with the factory
*
* @param string $class
* @return bool|null
* @access public
*/
public function autoload($class)
{
$file = $this->findFile($class);
if ( $file ) {
kUtil::includeOnce(FULL_PATH . $file);
return true;
}
return null;
}
/**
* Finds the path to the file where the class is defined.
*
* @param string $class The name of the class
* @return string|bool The path if found, false otherwise
* @access protected
*/
protected function findFile($class)
{
if ( $class[0] == '\\' ) {
$class = substr($class, 1);
}
if ( isset($this->classMap[$class]) ) {
return $this->classMap[$class];
}
$pos = strrpos($class, '\\');
if ( $pos !== false ) {
// namespaced class name
$class_path = str_replace('\\', DIRECTORY_SEPARATOR, substr($class, 0, $pos)) . DIRECTORY_SEPARATOR;
$class_name = substr($class, $pos + 1);
}
else {
// PEAR-like class name
$class_path = null;
$class_name = $class;
}
$class_path .= str_replace('_', DIRECTORY_SEPARATOR, $class_name) . '.php';
foreach ( $this->namespaceMap as $namespace_prefix => $namespace_path ) {
if ( strpos($class, $namespace_prefix) === 0 ) {
$test_class_path = str_replace(
str_replace('\\', DIRECTORY_SEPARATOR, $namespace_prefix),
$namespace_path,
$class_path
);
if ( file_exists(FULL_PATH . DIRECTORY_SEPARATOR . $test_class_path) ) {
return DIRECTORY_SEPARATOR . $test_class_path;
}
}
}
return $this->classMap[$class] = false;
}
/**
* Gets object data for caching
*
* @return Array
* @access public
*/
public function getToCache()
{
ksort($this->classMap);
+ ksort($this->classInfo);
+ ksort($this->classTree);
ksort($this->namespaceMap);
ksort($this->realClasses);
return Array (
'Factory.Files' => $this->classMap,
+ 'Factory.ClassInfo' => $this->classInfo,
+ 'Factory.ClassTree' => $this->classTree,
'Factory.Namespaces' => $this->namespaceMap,
'Factory.realClasses' => $this->realClasses,
);
}
/**
* Splits any mixing of prefix and
* special into correct ones
*
* @param string $prefix_special
* @return Array
* @access public
*/
public function processPrefix($prefix_special)
{
// l.pick, l, m.test_TagProcessor
//preg_match("/(.*)\.*(.*)(_*)(.*)/", $prefix_special, $regs);
//return Array('prefix'=>$regs[1].$regs[3].$regs[4], 'special'=>$regs[2]);
$tmp = explode('_', $prefix_special, 2);
$tmp[0] = explode('.', $tmp[0]);
$prefix = $tmp[0][0];
$prefix_special = $prefix; // new1
if ( isset($tmp[1]) ) {
$prefix .= '_' . $tmp[1];
}
$special = isset($tmp[0][1]) ? $tmp[0][1] : '';
$prefix_special .= '.' . $special; // new2
return Array ('prefix' => $prefix, 'special' => $special, 'prefix_special' => $prefix_special);
}
/**
* Returns object using params specified, creates it if is required.
*
* @param string $name Object name in factory.
* @param string $pseudo_class Pseudo class.
* @param Array $event_params Event params.
* @param Array $arguments Constructor arguments.
*
* @return kBase
*/
public function getObject($name, $pseudo_class = '', $event_params = Array (), $arguments = Array ())
{
$name = rtrim($name, '.');
if ( isset($this->Storage[$name]) ) {
return $this->Storage[$name];
}
$ret = $this->processPrefix($name);
if ( !$pseudo_class ) {
$pseudo_class = $ret['prefix'];
}
if ( defined('DEBUG_MODE') && defined('DBG_FACTORY') && DBG_FACTORY && $this->Application->isDebugMode() ) {
$this->Application->Debugger->appendHTML('Creating object: Pseudo class: ' . $pseudo_class . ' Prefix: ' . $name);
$this->Application->Debugger->appendTrace();
}
$this->Storage[$name] = $this->makeClass($pseudo_class, $arguments);
$this->Storage[$name]->Init($ret['prefix'], $ret['special']);
$this->Application->EventManager->runBuildEvent($ret['prefix_special'], $pseudo_class, $event_params);
return $this->Storage[$name];
}
/**
* Removes object from storage, so next time it could be created from scratch
*
* @param string $name Object's name in the Storage
* @return void
* @access public
*/
public function DestroyObject($name)
{
unset($this->Storage[$name]);
}
/**
* Checks if object with prefix passes was already created in factory
*
* @param string $name object pseudo_class, prefix
* @return bool
* @access public
*/
public function hasObject($name)
{
return isset($this->Storage[$name]);
}
/**
* Get's real class name for pseudo class, includes class file and creates class instance.
*
* Pattern: Factory Method
*
* @param string $pseudo_class Pseudo class.
* @param array $arguments Constructor arguments.
*
* @return kBase
* @throws kFactoryException When class not found.
*/
public function makeClass($pseudo_class, $arguments = Array ())
{
if ( !isset($this->realClasses[$pseudo_class]) ) {
$error_msg = 'RealClass not defined for "' . $pseudo_class . '" pseudo_class.';
$error_msg .= ' Please use "php tools/build_class_map.php" to discover new classes.';
if ( $this->Application->isInstalled() ) {
throw new kFactoryException($error_msg);
}
else {
if ( $this->Application->isDebugMode() ) {
$this->Application->Debugger->appendTrace();
}
trigger_error($error_msg, E_USER_WARNING);
}
return false;
}
$real_class = $this->realClasses[$pseudo_class];
$mem_before = memory_get_usage();
$time_before = microtime(true);
$arguments = (array)$arguments;
if ( !$arguments ) {
$class = new $real_class();
}
else {
$reflection = new ReflectionClass($real_class);
$class = $reflection->newInstanceArgs($arguments);
}
if ( defined('DEBUG_MODE') && DEBUG_MODE && defined('DBG_PROFILE_MEMORY') && DBG_PROFILE_MEMORY && $this->Application->isDebugMode() ) {
$mem_after = memory_get_usage();
$time_after = microtime(true);
$mem_used = $mem_after - $mem_before;
$time_used = $time_after - $time_before;
$this->Application->Debugger->appendHTML('Factroy created ' . $real_class . ' - used ' . round($mem_used / 1024, 3) . 'Kb time: ' . round($time_used, 5));
$this->Application->Debugger->profilerAddTotal('objects', null, $mem_used);
}
return $class;
}
/**
+ * Returns sub-classes of given ancestor class.
+ *
+ * @param string $ancestor_class Ancestor class.
+ * @param boolean $concrete_only Return only non-abstract classes.
+ *
+ * @return array
+ * @throws kFactoryException When ancestor class not found.
+ */
+ public function getSubClasses($ancestor_class, $concrete_only = true)
+ {
+ if ( !isset($this->classMap[$ancestor_class]) ) {
+ throw new kFactoryException(
+ 'Class "' . $ancestor_class . '" is not registered in the Factory'
+ );
+ }
+
+ if ( !isset($this->classTree[$ancestor_class]) ) {
+ return array();
+ }
+
+ $all_sub_classes = array();
+
+ foreach ( $this->classTree[$ancestor_class] as $sub_class ) {
+ $real_sub_class = $this->realClasses[$sub_class];
+ $all_sub_classes[$real_sub_class] = $sub_class;
+ $all_sub_classes = array_merge($all_sub_classes, $this->getSubClasses($sub_class, false));
+ }
+
+ if ( $concrete_only ) {
+ $concrete_sub_classes = array();
+
+ foreach ( $all_sub_classes as $real_sub_class => $sub_class ) {
+ if ( $this->classInfo[$sub_class]['type'] == self::TYPE_CLASS
+ && !$this->classHasModifier($sub_class, self::MODIFIER_ABSTRACT)
+ ) {
+ $concrete_sub_classes[$real_sub_class] = $sub_class;
+ }
+ }
+
+ return $concrete_sub_classes;
+ }
+
+ return $all_sub_classes;
+ }
+
+ /**
+ * Determines of class has modifier.
+ *
+ * @param string $class Class.
+ * @param integer $modifier Modifier.
+ *
+ * @return boolean
+ */
+ protected function classHasModifier($class, $modifier)
+ {
+ return ($this->classInfo[$class]['modifiers'] & $modifier) == $modifier;
+ }
+
+ /**
* Registers new class in the factory
*
* @param string $real_class Real name of class as in class declaration
* @param string $file Filename in what $real_class is declared
* @param string $pseudo_class Name under this class object will be accessed using getObject method
* @return void
* @access public
*/
public function registerClass($real_class, $file, $pseudo_class = null)
{
if ( !isset($pseudo_class) ) {
$pseudo_class = $real_class;
}
if ( !isset($this->classMap[$real_class]) ) {
$this->classMap[$real_class] = preg_replace('/^' . preg_quote(FULL_PATH, '/') . '/', '', $file, 1);
}
$this->realClasses[$pseudo_class] = $real_class;
}
/**
* Unregisters existing class from factory
*
* @param string $real_class Real name of class as in class declaration
* @param string $pseudo_class Name under this class object is accessed using getObject method
* @return void
* @access public
*/
public function unregisterClass($real_class, $pseudo_class = null)
{
unset($this->classMap[$real_class]);
}
}
class kFactoryException extends Exception {
}
Index: branches/5.3.x/core/install/cache/class_structure.php
===================================================================
--- branches/5.3.x/core/install/cache/class_structure.php (revision 16162)
+++ branches/5.3.x/core/install/cache/class_structure.php (revision 16163)
@@ -1,341 +1,2537 @@
1,
+ 'cache_format' => 2,
'classes' => array(
'AdminEventsHandler' => '/core/units/admin/admin_events_handler.php',
'AdminTagProcessor' => '/core/units/admin/admin_tag_processor.php',
'AjaxFormHelper' => '/core/units/helpers/ajax_form_helper.php',
'ApcCacheHandler' => '/core/kernel/utility/cache.php',
'BackupHelper' => '/core/units/helpers/backup_helper.php',
'BaseSession' => '/core/kernel/session/session.php',
'BaseSessionStorage' => '/core/kernel/session/session_storage.php',
'CacheSettings' => '/core/kernel/startup.php',
'CaptchaEventHandler' => '/core/units/captcha/captcha_eh.php',
'CategoriesEventHandler' => '/core/units/categories/categories_event_handler.php',
'CategoriesItem' => '/core/units/categories/categories_item.php',
'CategoriesTagProcessor' => '/core/units/categories/categories_tag_processor.php',
'CategoryHelper' => '/core/units/helpers/category_helper.php',
'CategoryItemRewrite' => '/core/units/helpers/mod_rewrite_helper.php',
'CategoryItemsEventHandler' => '/core/units/category_items/category_items_event_handler.php',
'CategoryItemsTagProcessor' => '/core/units/category_items/category_items_tag_processor.php',
'CategoryPermissionRebuild' => '/core/kernel/constants.php',
'ChangeLog' => '/core/kernel/constants.php',
'ChangeLogEventHandler' => '/core/units/logs/change_logs/change_log_eh.php',
'ChangeLogTagProcessor' => '/core/units/logs/change_logs/change_log_tp.php',
'ColumnSet' => '/core/units/helpers/col_picker_helper.php',
'ConfigSearchEventHandler' => '/core/units/config_search/config_search_event_handler.php',
'ConfigSearchTagProcessor' => '/core/units/config_search/config_search_tag_processor.php',
'ConfigurationEventHandler' => '/core/units/configuration/configuration_event_handler.php',
'ConfigurationItem' => '/core/units/configuration/configuration.php',
'ConfigurationTagProcessor' => '/core/units/configuration/configuration_tag_processor.php',
'ConfigurationValidator' => '/core/units/configuration/configuration_validator.php',
'ContentEventHandler' => '/core/units/content/content_eh.php',
'ContentTagProcessor' => '/core/units/content/content_tp.php',
'CoreUpgrades' => '/core/install/upgrades.php',
'CountryStateEventHandler' => '/core/units/country_states/country_state_eh.php',
'CssMinifyHelper' => '/core/units/helpers/minifiers/css_minify_helper.php',
'CustomDataEventHandler' => '/core/units/custom_data/custom_data_event_handler.php',
'CustomFieldsEventHandler' => '/core/units/custom_fields/custom_fields_event_handler.php',
'CustomFieldsTagProcessor' => '/core/units/custom_fields/custom_fields_tag_processor.php',
'Debugger' => '/core/kernel/utility/debugger.php',
'DebuggerUtil' => '/core/kernel/utility/debugger.php',
'DeploymentHelper' => '/core/units/helpers/deployment_helper.php',
'DraftEventHandler' => '/core/units/forms/drafts/draft_eh.php',
'EditPickerHelper' => '/core/units/helpers/controls/edit_picker_helper.php',
'EmailDelivery' => '/core/kernel/constants.php',
'EmailLogEventHandler' => '/core/units/logs/email_logs/email_log_eh.php',
'EmailLogStatus' => '/core/kernel/constants.php',
'EmailLogTagProcessor' => '/core/units/logs/email_logs/email_log_tp.php',
'EmailQueueEventHandler' => '/core/units/email_queue/email_queue_eh.php',
'EmailQueueTagProcessor' => '/core/units/email_queue/email_queue_tp.php',
'EmailTemplate' => '/core/kernel/constants.php',
'EmailTemplateEventHandler' => '/core/units/email_templates/email_template_eh.php',
'EmailTemplateTagProcessor' => '/core/units/email_templates/email_template_tp.php',
'FakeCacheHandler' => '/core/kernel/utility/cache.php',
'FavoritesEventHandler' => '/core/units/favorites/favorites_eh.php',
'FckEventHandler' => '/core/units/fck/fck_eh.php',
'FckTagProcessor' => '/core/units/fck/fck_tp.php',
'FileEventHandler' => '/core/units/files/file_eh.php',
'FileHelper' => '/core/units/helpers/file_helper.php',
'FileTagProcessor' => '/core/units/files/file_tp.php',
'FormFieldEventHandler' => '/core/units/forms/form_fields/form_field_eh.php',
'FormFieldsTagProcessor' => '/core/units/forms/form_fields/form_fields_tp.php',
'FormSubmissionHelper' => '/core/units/helpers/form_submission_helper.php',
'FormSubmissionTagProcessor' => '/core/units/forms/form_submissions/form_submission_tp.php',
'FormSubmissionsEventHandler' => '/core/units/forms/form_submissions/form_submissions_eh.php',
'FormsEventHandler' => '/core/units/forms/forms/forms_eh.php',
'FormsTagProcessor' => '/core/units/forms/forms/forms_tp.php',
'GeoCodeHelper' => '/core/units/helpers/geocode_helper.php',
'GroupTagProcessor' => '/core/units/groups/group_tp.php',
'GroupsEventHandler' => '/core/units/groups/groups_event_handler.php',
'IDBConnection' => '/core/kernel/db/i_db_connection.php',
'ImageEventHandler' => '/core/units/images/image_event_handler.php',
'ImageHelper' => '/core/units/helpers/image_helper.php',
'ImageTagProcessor' => '/core/units/images/image_tag_processor.php',
'ImagesItem' => '/core/units/images/images.php',
'InPortalPrerequisites' => '/core/install/prerequisites.php',
'InpCustomFieldsHelper' => '/core/units/helpers/custom_fields_helper.php',
'Intechnic\\InPortal\\Core\\kernel\\utility\\ClassDiscovery\\ClassDetector' => '/core/kernel/utility/ClassDiscovery/ClassDetector.php',
'Intechnic\\InPortal\\Core\\kernel\\utility\\ClassDiscovery\\ClassMapBuilder' => '/core/kernel/utility/ClassDiscovery/ClassMapBuilder.php',
'Intechnic\\InPortal\\Core\\kernel\\utility\\ClassDiscovery\\CodeFolderFilterIterator' => '/core/kernel/utility/ClassDiscovery/CodeFolderFilterIterator.php',
'ItemFilterEventHandler' => '/core/units/filters/item_filter_eh.php',
'ItemFilterTagProcessor' => '/core/units/filters/item_filter_tp.php',
'JSONHelper' => '/core/units/helpers/json_helper.php',
'JsMinifyHelper' => '/core/units/helpers/minifiers/js_minify_helper.php',
'Language' => '/core/kernel/constants.php',
'LanguageImportHelper' => '/core/units/helpers/language_import_helper.php',
'LanguagesEventHandler' => '/core/units/languages/languages_event_handler.php',
'LanguagesItem' => '/core/units/languages/languages_item.php',
'LanguagesTagProcessor' => '/core/units/languages/languages_tag_processor.php',
'LeftJoinOptimizer' => '/core/kernel/db/dblist.php',
'ListHelper' => '/core/units/helpers/list_helper.php',
'LoginResult' => '/core/kernel/constants.php',
'MInputHelper' => '/core/units/helpers/controls/minput_helper.php',
'MailboxHelper' => '/core/units/helpers/mailbox_helper.php',
'MailingList' => '/core/kernel/constants.php',
'MailingListEventHandler' => '/core/units/mailing_lists/mailing_list_eh.php',
'MailingListHelper' => '/core/units/helpers/mailing_list_helper.php',
'MailingListTagProcessor' => '/core/units/mailing_lists/mailing_list_tp.php',
'MaintenanceMode' => '/core/kernel/startup.php',
'MassImageResizer' => '/core/units/admin/admin_events_handler.php',
'MemcacheCacheHandler' => '/core/kernel/utility/cache.php',
'MenuHelper' => '/core/units/helpers/menu_helper.php',
'MimeDecodeHelper' => '/core/units/helpers/mime_decode_helper.php',
'MinifyHelper' => '/core/units/helpers/minifiers/minify_helper.php',
'ModuleDeploymentLog' => '/core/kernel/constants.php',
'ModuleDeploymentLogEventHandler' => '/core/units/logs/module_deployment_logs/module_deployment_log_eh.php',
'ModulesEventHandler' => '/core/units/modules/modules_event_handler.php',
'ModulesTagProcessor' => '/core/units/modules/modules_tag_processor.php',
'NParser' => '/core/kernel/nparser/nparser.php',
'NParserCompiler' => '/core/kernel/nparser/compiler.php',
'POP3Helper' => '/core/units/helpers/pop3_helper.php',
'PageHelper' => '/core/units/helpers/page_helper.php',
'PageRevisionEventHandler' => '/core/units/page_revisions/page_revision_eh.php',
'PageRevisionTagProcessor' => '/core/units/page_revisions/page_revision_tp.php',
'Params' => '/core/kernel/utility/params.php',
'ParserException' => '/core/kernel/nparser/nparser.php',
'PasswordHash' => '/core/kernel/utility/php_pass.php',
'PasswordHashingMethod' => '/core/kernel/constants.php',
'PermissionTypeEventHandler' => '/core/units/permission_types/permission_type_eh.php',
'PermissionsEventHandler' => '/core/units/permissions/permissions_event_handler.php',
'PermissionsTagProcessor' => '/core/units/permissions/permissions_tag_processor.php',
'PhraseTagProcessor' => '/core/units/phrases/phrase_tp.php',
'PhrasesEventHandler' => '/core/units/phrases/phrases_event_handler.php',
'PriorityEventHandler' => '/core/units/priorites/priority_eh.php',
'PromoBlockEventHandler' => '/core/units/promo_blocks/promo_block_eh.php',
'PromoBlockGroupEventHandler' => '/core/units/promo_block_groups/promo_block_group_eh.php',
'PromoBlockGroupTagProcessor' => '/core/units/promo_block_groups/promo_block_group_tp.php',
'PromoBlockTagProcessor' => '/core/units/promo_blocks/promo_block_tp.php',
'PromoBlockType' => '/core/kernel/constants.php',
'RatingHelper' => '/core/units/helpers/rating_helper.php',
'RelatedSearchEventHandler' => '/core/units/related_searches/related_searches_event_handler.php',
'RelatedSearchTagProcessor' => '/core/units/related_searches/related_searches_tag_processor.php',
'RelationshipEventHandler' => '/core/units/relationship/relationship_event_handler.php',
'RelationshipTagProcessor' => '/core/units/relationship/relationship_tp.php',
'ReviewsEventHandler' => '/core/units/reviews/reviews_event_handler.php',
'ReviewsTagProcessor' => '/core/units/reviews/reviews_tag_processor.php',
'ScheduledTask' => '/core/kernel/constants.php',
'ScheduledTaskEventHandler' => '/core/units/scheduled_tasks/scheduled_task_eh.php',
'SelectorsEventHandler' => '/core/units/selectors/selectors_event_handler.php',
'SelectorsItem' => '/core/units/selectors/selectors_item.php',
'SelectorsTagProcessor' => '/core/units/selectors/selectors_tag_processor.php',
'Session' => '/core/kernel/session/inp_session.php',
'SessionLogEventHandler' => '/core/units/logs/session_logs/session_log_eh.php',
'SessionStorage' => '/core/kernel/session/inp_session_storage.php',
'SiteConfigEventHandler' => '/core/units/sections/site_config_eh.php',
'SiteConfigHelper' => '/core/units/helpers/site_config_helper.php',
'SiteConfigTagProcessor' => '/core/units/sections/site_config_tp.php',
'SiteDomainEventHandler' => '/core/units/site_domains/site_domain_eh.php',
'SiteHelper' => '/core/units/helpers/site_helper.php',
'SkinEventHandler' => '/core/units/skins/skin_eh.php',
'SkinHelper' => '/core/units/helpers/skin_helper.php',
'SpamHelper' => '/core/units/helpers/spam_helper.php',
'SpamReportEventHandler' => '/core/units/spam_reports/spam_report_eh.php',
'SpamReportTagProcessor' => '/core/units/spam_reports/spam_report_tp.php',
'StatisticsEventHandler' => '/core/units/statistics/statistics_event_handler.php',
'StatisticsTagProcessor' => '/core/units/statistics/statistics_tag_processor.php',
'StorageEngine' => '/core/kernel/constants.php',
'StylesheetsEventHandler' => '/core/units/stylesheets/stylesheets_event_handler.php',
'StylesheetsItem' => '/core/units/stylesheets/stylesheets_item.php',
'SubmissionFormField' => '/core/kernel/constants.php',
'SubmissionLogEventHandler' => '/core/units/forms/submission_log/submission_log_eh.php',
'SubmissionLogTagProcessor' => '/core/units/forms/submission_log/submission_log_tp.php',
'SystemEventSubscriptionEventHandler' => '/core/units/system_event_subscriptions/system_event_subscription_eh.php',
'SystemEventSubscriptionTagProcessor' => '/core/units/system_event_subscriptions/system_event_subscription_tp.php',
'SystemLogEventHandler' => '/core/units/logs/system_logs/system_log_eh.php',
'SystemLogTagProcessor' => '/core/units/logs/system_logs/system_log_tp.php',
'TemplateHelper' => '/core/units/helpers/template_helper.php',
'TemplatesCache' => '/core/kernel/nparser/template_cache.php',
'ThemeFileEventHandler' => '/core/units/theme_files/theme_file_eh.php',
'ThemeItem' => '/core/units/themes/theme_item.php',
'ThemesEventHandler' => '/core/units/themes/themes_eh.php',
'ThemesTagProcessor' => '/core/units/themes/themes_tag_processor.php',
'ThesaurusEventHandler' => '/core/units/thesaurus/thesaurus_eh.php',
'ThesaurusTagProcessor' => '/core/units/thesaurus/thesaurus_tp.php',
'TranslationSaveMode' => '/core/kernel/constants.php',
'TranslatorEventHandler' => '/core/units/translator/translator_event_handler.php',
'TranslatorTagProcessor' => '/core/units/translator/translator_tp.php',
'UnitConfigDecorator' => '/core/units/admin/admin_events_handler.php',
'UserGroupsEventHandler' => '/core/units/user_groups/user_groups_eh.php',
'UserHelper' => '/core/units/helpers/user_helper.php',
'UserProfileEventHandler' => '/core/units/user_profile/user_profile_eh.php',
'UserProfileTagProcessor' => '/core/units/user_profile/user_profile_tp.php',
'UserType' => '/core/kernel/constants.php',
'UsersEventHandler' => '/core/units/users/users_event_handler.php',
'UsersItem' => '/core/units/users/users_item.php',
'UsersSyncronize' => '/core/units/users/users_syncronize.php',
'UsersSyncronizeManager' => '/core/units/users/users_syncronize.php',
'UsersTagProcessor' => '/core/units/users/users_tag_processor.php',
'VisitsEventHandler' => '/core/units/visits/visits_event_handler.php',
'VisitsList' => '/core/units/visits/visits_list.php',
'VisitsTagProcessor' => '/core/units/visits/visits_tag_processor.php',
'XCacheCacheHandler' => '/core/kernel/utility/cache.php',
'XMLIterator' => '/core/units/helpers/xml_helper5.php',
'_BlockTag' => '/core/kernel/nparser/ntags.php',
'_Tag_Cache' => '/core/kernel/nparser/ntags.php',
'_Tag_Capture' => '/core/kernel/nparser/ntags.php',
'_Tag_Comment' => '/core/kernel/nparser/ntags.php',
'_Tag_Compress' => '/core/kernel/nparser/ntags.php',
'_Tag_DefaultParam' => '/core/kernel/nparser/ntags.php',
'_Tag_DefineElement' => '/core/kernel/nparser/ntags.php',
'_Tag_If' => '/core/kernel/nparser/ntags.php',
'_Tag_IfDataExists' => '/core/kernel/nparser/ntags.php',
'_Tag_IfNot' => '/core/kernel/nparser/ntags.php',
'_Tag_Include' => '/core/kernel/nparser/ntags.php',
'_Tag_Param' => '/core/kernel/nparser/ntags.php',
'_Tag_RenderElement' => '/core/kernel/nparser/ntags.php',
'_Tag_RenderElements' => '/core/kernel/nparser/ntags.php',
'_Tag_SetParam' => '/core/kernel/nparser/ntags.php',
'clsCachedPermissions' => '/core/units/categories/cache_updater.php',
'clsRecursionStack' => '/core/units/categories/cache_updater.php',
'fckFCKHelper' => '/core/units/helpers/fck_helper.php',
'kApplication' => '/core/kernel/application.php',
'kArray' => '/core/kernel/utility/params.php',
'kBase' => '/core/kernel/kbase.php',
'kBracketsHelper' => '/core/units/helpers/brackets_helper.php',
'kCCDateFormatter' => '/core/kernel/utility/formatters/ccdate_formatter.php',
'kCSSDefaults' => '/core/units/pdf/css_defaults.php',
'kCSVHelper' => '/core/units/helpers/csv_helper.php',
'kCache' => '/core/kernel/utility/cache.php',
'kCacheHandler' => '/core/kernel/utility/cache.php',
'kCacheManager' => '/core/kernel/managers/cache_manager.php',
'kCaptchaHelper' => '/core/units/helpers/captcha_helper.php',
'kCatDBEventHandler' => '/core/kernel/db/cat_event_handler.php',
'kCatDBItem' => '/core/kernel/db/cat_dbitem.php',
'kCatDBItemExportHelper' => '/core/units/helpers/cat_dbitem_export_helper.php',
'kCatDBList' => '/core/kernel/db/cat_dblist.php',
'kCatDBTagProcessor' => '/core/kernel/db/cat_tag_processor.php',
'kChangesFormatter' => '/core/units/logs/change_logs/changes_formatter.php',
'kChartHelper' => '/core/units/helpers/chart_helper.php',
'kClipboardHelper' => '/core/units/helpers/clipboard_helper.php',
'kColumnPickerHelper' => '/core/units/helpers/col_picker_helper.php',
'kCookieHasher' => '/core/kernel/utility/cookie_hasher.php',
'kCountHelper' => '/core/units/helpers/count_helper.php',
'kCountryStatesHelper' => '/core/units/helpers/country_states_helper.php',
'kCronField' => '/core/units/helpers/cron_helper.php',
'kCronHelper' => '/core/units/helpers/cron_helper.php',
'kCurlHelper' => '/core/units/helpers/curl_helper.php',
'kCustomFieldFormatter' => '/core/kernel/utility/formatters/customfield_formatter.php',
'kDBBase' => '/core/kernel/kbase.php',
'kDBConnection' => '/core/kernel/db/db_connection.php',
'kDBConnectionDebug' => '/core/kernel/db/db_connection.php',
'kDBEventHandler' => '/core/kernel/db/db_event_handler.php',
'kDBItem' => '/core/kernel/db/dbitem.php',
'kDBList' => '/core/kernel/db/dblist.php',
'kDBLoadBalancer' => '/core/kernel/db/db_load_balancer.php',
'kDBTagProcessor' => '/core/kernel/db/db_tag_processor.php',
'kDateFormatter' => '/core/kernel/utility/formatters/date_formatter.php',
'kEmail' => '/core/kernel/utility/email.php',
'kEmailSendingHelper' => '/core/kernel/utility/email_send.php',
'kEmailTemplateHelper' => '/core/units/helpers/email_template_helper.php',
'kErrorHandlerStack' => '/core/kernel/utility/logger.php',
'kEvent' => '/core/kernel/utility/event.php',
'kEventHandler' => '/core/kernel/event_handler.php',
'kEventManager' => '/core/kernel/event_manager.php',
'kExceptionHandlerStack' => '/core/kernel/utility/logger.php',
'kFactory' => '/core/kernel/utility/factory.php',
'kFactoryException' => '/core/kernel/utility/factory.php',
'kFilenamesHelper' => '/core/units/helpers/filenames_helper.php',
'kFilesizeFormatter' => '/core/kernel/utility/formatters/filesize_formatter.php',
'kFormatter' => '/core/kernel/utility/formatters/formatter.php',
'kHTTPQuery' => '/core/kernel/utility/http_query.php',
'kHandlerStack' => '/core/kernel/utility/logger.php',
'kHelper' => '/core/kernel/kbase.php',
'kHookManager' => '/core/kernel/managers/hook_manager.php',
'kInstallToolkit' => '/core/install/install_toolkit.php',
'kInstallator' => '/core/install.php',
'kLEFTFormatter' => '/core/kernel/utility/formatters/left_formatter.php',
'kLogger' => '/core/kernel/utility/logger.php',
'kMainTagProcessor' => '/core/kernel/processors/main_processor.php',
'kModulesHelper' => '/core/units/helpers/modules_helper.php',
'kMultiLanguage' => '/core/kernel/utility/formatters/multilang_formatter.php',
'kMultiLanguageHelper' => '/core/units/helpers/multilanguage_helper.php',
'kMultipleFilter' => '/core/kernel/utility/filters.php',
'kMySQLQuery' => '/core/kernel/db/db_connection.php',
'kMySQLQueryCol' => '/core/kernel/db/db_connection.php',
'kNavigationBar' => '/core/units/helpers/navigation_bar.php',
'kNoPermissionException' => '/core/kernel/kbase.php',
'kOpenerStack' => '/core/kernel/utility/opener_stack.php',
'kOptionsFormatter' => '/core/kernel/utility/formatters/options_formatter.php',
'kPDFElemFactory' => '/core/units/pdf/pdf_helper.php',
'kPDFElement' => '/core/units/pdf/pdf_helper.php',
'kPDFHelper' => '/core/units/pdf/pdf_helper.php',
'kPDFImage' => '/core/units/pdf/pdf_image.php',
'kPDFLine' => '/core/units/pdf/pdf_helper.php',
'kPDFRenderer' => '/core/units/pdf/pdf_renderer.php',
'kPDFStylesheet' => '/core/units/pdf/pdf_styles.php',
'kPDFTable' => '/core/units/pdf/pdf_table.php',
'kPDFTableRow' => '/core/units/pdf/pdf_table.php',
'kPDFTextElement' => '/core/units/pdf/pdf_text.php',
'kPasswordFormatter' => '/core/kernel/utility/formatters/password_formatter.php',
'kPermCacheUpdater' => '/core/units/categories/cache_updater.php',
'kPermissionsHelper' => '/core/units/helpers/permissions_helper.php',
'kPhraseCache' => '/core/kernel/languages/phrases_cache.php',
'kPictureFormatter' => '/core/kernel/utility/formatters/upload_formatter.php',
'kPlainUrlProcessor' => '/core/kernel/managers/plain_url_processor.php',
'kPriorityHelper' => '/core/units/helpers/priority_helper.php',
'kRecursiveHelper' => '/core/units/helpers/recursive_helper.php',
'kRedirectException' => '/core/kernel/kbase.php',
'kRequestManager' => '/core/kernel/managers/request_manager.php',
'kRewriteUrlProcessor' => '/core/kernel/managers/rewrite_url_processor.php',
'kScheduledTaskManager' => '/core/kernel/managers/scheduled_task_manager.php',
'kSearchHelper' => '/core/units/helpers/search_helper.php',
'kSectionsHelper' => '/core/units/helpers/sections_helper.php',
'kSerializedFormatter' => '/core/kernel/utility/formatters/serialized_formatter.php',
'kSocket' => '/core/kernel/utility/socket.php',
'kSubscriptionAnalyzer' => '/core/units/system_event_subscriptions/system_event_subscription_tp.php',
'kSubscriptionItem' => '/core/kernel/managers/subscription_manager.php',
'kSubscriptionManager' => '/core/kernel/managers/subscription_manager.php',
'kSystemConfig' => '/core/kernel/utility/system_config.php',
'kSystemConfigException' => '/core/kernel/utility/system_config.php',
'kTCPDFRenderer' => '/core/units/pdf/pdf_renderer_tcpdf.php',
'kTagProcessor' => '/core/kernel/processors/tag_processor.php',
'kTempHandlerSubTable' => '/core/kernel/utility/temp_handler.php',
'kTempHandlerTable' => '/core/kernel/utility/temp_handler.php',
'kTempHandlerTopTable' => '/core/kernel/utility/temp_handler.php',
'kTempTablesHandler' => '/core/kernel/utility/temp_handler.php',
'kThemesHelper' => '/core/units/helpers/themes_helper.php',
'kUnitConfig' => '/core/kernel/utility/unit_config.php',
'kUnitConfigCloner' => '/core/kernel/utility/unit_config_cloner.php',
'kUnitConfigReader' => '/core/kernel/utility/unit_config_reader.php',
'kUnitFormatter' => '/core/kernel/utility/formatters/unit_formatter.php',
'kUpgradeHelper' => '/core/install/upgrade_helper.php',
'kUploadFormatter' => '/core/kernel/utility/formatters/upload_formatter.php',
'kUploadHelper' => '/core/units/helpers/upload_helper.php',
'kUploaderException' => '/core/units/helpers/upload_helper.php',
'kUrlManager' => '/core/kernel/managers/url_manager.php',
'kUrlProcessor' => '/core/kernel/managers/url_processor.php',
'kUtil' => '/core/kernel/globals.php',
'kValidator' => '/core/kernel/utility/validator.php',
'kXMLHelper' => '/core/units/helpers/xml_helper.php',
'kXMLNode' => '/core/units/helpers/xml_helper.php',
'kXMLNode5' => '/core/units/helpers/xml_helper5.php',
'kZendPDFRenderer' => '/core/units/pdf/pdf_renderer_zend.php',
'kiCacheable' => '/core/kernel/interfaces/cacheable.php',
),
+ 'class_info' => array(
+ 'AdminEventsHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'AdminTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'AjaxFormHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'ApcCacheHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kCacheHandler',
+ ),
+ ),
+ 'BackupHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'BaseSession' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'BaseSessionStorage' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBBase',
+ ),
+ ),
+ 'CacheSettings' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'CaptchaEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kEventHandler',
+ ),
+ ),
+ 'CategoriesEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'CategoriesItem' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBItem',
+ ),
+ ),
+ 'CategoriesTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'CategoryHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'CategoryItemRewrite' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'CategoryItemsEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'CategoryItemsTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'CategoryPermissionRebuild' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'ChangeLog' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'ChangeLogEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'ChangeLogTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'ColumnSet' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'ConfigSearchEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'ConfigSearchTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'ConfigurationEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'ConfigurationItem' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBItem',
+ ),
+ ),
+ 'ConfigurationTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'ConfigurationValidator' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kValidator',
+ ),
+ ),
+ 'ContentEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'ContentTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'CoreUpgrades' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kUpgradeHelper',
+ ),
+ ),
+ 'CountryStateEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'CssMinifyHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'CustomDataEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'CustomFieldsEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'CustomFieldsTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'Debugger' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'DebuggerUtil' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'DeploymentHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'DraftEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'EditPickerHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'EmailDelivery' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'EmailLogEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'EmailLogStatus' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'EmailLogTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'EmailQueueEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'EmailQueueTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'EmailTemplate' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'EmailTemplateEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'EmailTemplateTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'FakeCacheHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kCacheHandler',
+ ),
+ ),
+ 'FavoritesEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'FckEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'FckTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'FileEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'FileHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'FileTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'FormFieldEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'FormFieldsTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'FormSubmissionHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'FormSubmissionTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'FormSubmissionsEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'FormsEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'FormsTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'GeoCodeHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'GroupTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'GroupsEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'IDBConnection' => array(
+ 'type' => 2,
+ ),
+ 'ImageEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'ImageHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'ImageTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'ImagesItem' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBItem',
+ ),
+ ),
+ 'InPortalPrerequisites' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'InpCustomFieldsHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'Intechnic\\InPortal\\Core\\kernel\\utility\\ClassDiscovery\\ClassDetector' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'PhpParser\\NodeVisitorAbstract',
+ ),
+ ),
+ 'Intechnic\\InPortal\\Core\\kernel\\utility\\ClassDiscovery\\ClassMapBuilder' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'Intechnic\\InPortal\\Core\\kernel\\utility\\ClassDiscovery\\CodeFolderFilterIterator' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'RecursiveFilterIterator',
+ ),
+ ),
+ 'ItemFilterEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'ItemFilterTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'JSONHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'JsMinifyHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'Language' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'LanguageImportHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'LanguagesEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'LanguagesItem' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBItem',
+ ),
+ ),
+ 'LanguagesTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'LeftJoinOptimizer' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'ListHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'LoginResult' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'MInputHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'MailboxHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'MailingList' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'MailingListEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'MailingListHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'MailingListTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'MaintenanceMode' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'MassImageResizer' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'MemcacheCacheHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kCacheHandler',
+ ),
+ ),
+ 'MenuHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'MimeDecodeHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'MinifyHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'ModuleDeploymentLog' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'ModuleDeploymentLogEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'ModulesEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'ModulesTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'NParser' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'NParserCompiler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'POP3Helper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'PageHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'PageRevisionEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'PageRevisionTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'Params' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'ParserException' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'Exception',
+ ),
+ ),
+ 'PasswordHash' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'PasswordHashingMethod' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'PermissionTypeEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'PermissionsEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'PermissionsTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'PhraseTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'PhrasesEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'PriorityEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'PromoBlockEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'PromoBlockGroupEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'PromoBlockGroupTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'PromoBlockTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'PromoBlockType' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'RatingHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'RelatedSearchEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'RelatedSearchTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'RelationshipEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'RelationshipTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'ReviewsEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'ReviewsTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'ScheduledTask' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'ScheduledTaskEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'SelectorsEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'SelectorsItem' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBItem',
+ ),
+ ),
+ 'SelectorsTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'Session' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'BaseSession',
+ ),
+ ),
+ 'SessionLogEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'SessionStorage' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'BaseSessionStorage',
+ ),
+ ),
+ 'SiteConfigEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kEventHandler',
+ ),
+ ),
+ 'SiteConfigHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'SiteConfigTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kTagProcessor',
+ ),
+ ),
+ 'SiteDomainEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'SiteHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'SkinEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'SkinHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'SpamHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'SpamReportEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'SpamReportTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'StatisticsEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'StatisticsTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'StorageEngine' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'StylesheetsEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'StylesheetsItem' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBItem',
+ ),
+ ),
+ 'SubmissionFormField' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'SubmissionLogEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'SubmissionLogTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'SystemEventSubscriptionEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'SystemEventSubscriptionTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'SystemLogEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'SystemLogTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'TemplateHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'TemplatesCache' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'ThemeFileEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'ThemeItem' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBItem',
+ ),
+ ),
+ 'ThemesEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'ThemesTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'ThesaurusEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'ThesaurusTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'TranslationSaveMode' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'TranslatorEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'TranslatorTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'UnitConfigDecorator' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'UserGroupsEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'UserHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'UserProfileEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'UserProfileTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'UserType' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'UsersEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'UsersItem' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBItem',
+ ),
+ ),
+ 'UsersSyncronize' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'UsersSyncronizeManager' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'UsersTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'VisitsEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'VisitsList' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBList',
+ ),
+ ),
+ 'VisitsTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'XCacheCacheHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kCacheHandler',
+ ),
+ ),
+ 'XMLIterator' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'Iterator',
+ ),
+ ),
+ '_BlockTag' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ '_Tag_Cache' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => '_BlockTag',
+ ),
+ ),
+ '_Tag_Capture' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => '_Tag_DefineElement',
+ ),
+ ),
+ '_Tag_Comment' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => '_BlockTag',
+ ),
+ ),
+ '_Tag_Compress' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => '_BlockTag',
+ ),
+ ),
+ '_Tag_DefaultParam' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => '_BlockTag',
+ ),
+ ),
+ '_Tag_DefineElement' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => '_BlockTag',
+ ),
+ ),
+ '_Tag_If' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => '_BlockTag',
+ ),
+ ),
+ '_Tag_IfDataExists' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => '_BlockTag',
+ ),
+ ),
+ '_Tag_IfNot' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => '_Tag_If',
+ ),
+ ),
+ '_Tag_Include' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => '_BlockTag',
+ ),
+ ),
+ '_Tag_Param' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => '_BlockTag',
+ ),
+ ),
+ '_Tag_RenderElement' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => '_Tag_DefineElement',
+ ),
+ ),
+ '_Tag_RenderElements' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => '_BlockTag',
+ ),
+ ),
+ '_Tag_SetParam' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => '_BlockTag',
+ ),
+ ),
+ 'clsCachedPermissions' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'clsRecursionStack' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'fckFCKHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kApplication' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kiCacheable',
+ ),
+ ),
+ 'kArray' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ 1 => 'kiCacheable',
+ ),
+ ),
+ 'kBase' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'kBracketsHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kCCDateFormatter' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kFormatter',
+ ),
+ ),
+ 'kCSSDefaults' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'kCSVHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kCache' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kCacheHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 1,
+ ),
+ 'kCacheManager' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ 1 => 'kiCacheable',
+ ),
+ ),
+ 'kCaptchaHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kCatDBEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBEventHandler',
+ ),
+ ),
+ 'kCatDBItem' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBItem',
+ ),
+ ),
+ 'kCatDBItemExportHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kCatDBList' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBList',
+ ),
+ ),
+ 'kCatDBTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBTagProcessor',
+ ),
+ ),
+ 'kChangesFormatter' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kFormatter',
+ ),
+ ),
+ 'kChartHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kClipboardHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kColumnPickerHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kCookieHasher' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kCountHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kCountryStatesHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kCronField' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kCronHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kCurlHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kCustomFieldFormatter' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kFormatter',
+ ),
+ ),
+ 'kDBBase' => array(
+ 'type' => 1,
+ 'modifiers' => 1,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kDBConnection' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ 1 => 'IDBConnection',
+ ),
+ ),
+ 'kDBConnectionDebug' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBConnection',
+ ),
+ ),
+ 'kDBEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kEventHandler',
+ ),
+ ),
+ 'kDBItem' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBBase',
+ ),
+ ),
+ 'kDBList' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kDBBase',
+ 1 => 'Iterator',
+ 2 => 'Countable',
+ ),
+ ),
+ 'kDBLoadBalancer' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ 1 => 'IDBConnection',
+ ),
+ ),
+ 'kDBTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kTagProcessor',
+ ),
+ ),
+ 'kDateFormatter' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kFormatter',
+ ),
+ ),
+ 'kEmail' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kEmailSendingHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kEmailTemplateHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kErrorHandlerStack' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHandlerStack',
+ ),
+ ),
+ 'kEvent' => array(
+ 'type' => 1,
+ 'modifiers' => 2,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kEventHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kEventManager' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ 1 => 'kiCacheable',
+ ),
+ ),
+ 'kExceptionHandlerStack' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHandlerStack',
+ ),
+ ),
+ 'kFactory' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ 1 => 'kiCacheable',
+ ),
+ ),
+ 'kFactoryException' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'Exception',
+ ),
+ ),
+ 'kFilenamesHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kFilesizeFormatter' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kFormatter',
+ ),
+ ),
+ 'kFormatter' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kHTTPQuery' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'Params',
+ ),
+ ),
+ 'kHandlerStack' => array(
+ 'type' => 1,
+ 'modifiers' => 1,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kHookManager' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ 1 => 'kiCacheable',
+ ),
+ ),
+ 'kInstallToolkit' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'kInstallator' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'kLEFTFormatter' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kFormatter',
+ ),
+ ),
+ 'kLogger' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kMainTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kTagProcessor',
+ ),
+ ),
+ 'kModulesHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kMultiLanguage' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kFormatter',
+ ),
+ ),
+ 'kMultiLanguageHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kMultipleFilter' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'kMySQLQuery' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'Iterator',
+ 1 => 'Countable',
+ 2 => 'SeekableIterator',
+ ),
+ ),
+ 'kMySQLQueryCol' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kMySQLQuery',
+ ),
+ ),
+ 'kNavigationBar' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kNoPermissionException' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kRedirectException',
+ ),
+ ),
+ 'kOpenerStack' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kOptionsFormatter' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kFormatter',
+ ),
+ ),
+ 'kPDFElemFactory' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'kPDFElement' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'kPDFHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kPDFImage' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kPDFElement',
+ ),
+ ),
+ 'kPDFLine' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kPDFElement',
+ ),
+ ),
+ 'kPDFRenderer' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'kPDFStylesheet' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'kPDFTable' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kPDFElement',
+ ),
+ ),
+ 'kPDFTableRow' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kPDFElement',
+ ),
+ ),
+ 'kPDFTextElement' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kPDFElement',
+ ),
+ ),
+ 'kPasswordFormatter' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kFormatter',
+ ),
+ ),
+ 'kPermCacheUpdater' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kPermissionsHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kPhraseCache' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kPictureFormatter' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kUploadFormatter',
+ ),
+ ),
+ 'kPlainUrlProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kUrlProcessor',
+ ),
+ ),
+ 'kPriorityHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kRecursiveHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kRedirectException' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'Exception',
+ ),
+ ),
+ 'kRequestManager' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kRewriteUrlProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kUrlProcessor',
+ ),
+ ),
+ 'kScheduledTaskManager' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ 1 => 'kiCacheable',
+ ),
+ ),
+ 'kSearchHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kSectionsHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kSerializedFormatter' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kFormatter',
+ ),
+ ),
+ 'kSocket' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kSubscriptionAnalyzer' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kSubscriptionItem' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kSubscriptionManager' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kSystemConfig' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'kSystemConfigException' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'Exception',
+ ),
+ ),
+ 'kTCPDFRenderer' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kPDFRenderer',
+ ),
+ ),
+ 'kTagProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kTempHandlerSubTable' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kTempHandlerTable',
+ ),
+ ),
+ 'kTempHandlerTable' => array(
+ 'type' => 1,
+ 'modifiers' => 1,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kTempHandlerTopTable' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kTempHandlerTable',
+ ),
+ ),
+ 'kTempTablesHandler' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kThemesHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kUnitConfig' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'kUnitConfigCloner' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ 1 => 'kiCacheable',
+ ),
+ ),
+ 'kUnitConfigReader' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ 1 => 'kiCacheable',
+ ),
+ ),
+ 'kUnitFormatter' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kFormatter',
+ ),
+ ),
+ 'kUpgradeHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kUploadFormatter' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kFormatter',
+ ),
+ ),
+ 'kUploadHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kUploaderException' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'Exception',
+ ),
+ ),
+ 'kUrlManager' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kUrlProcessor' => array(
+ 'type' => 1,
+ 'modifiers' => 1,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kUtil' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'kValidator' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kBase',
+ ),
+ ),
+ 'kXMLHelper' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kHelper',
+ ),
+ ),
+ 'kXMLNode' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ ),
+ 'kXMLNode5' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kXMLNode',
+ 1 => 'IteratorAggregate',
+ ),
+ ),
+ 'kZendPDFRenderer' => array(
+ 'type' => 1,
+ 'modifiers' => 0,
+ 'extends' => array(
+ 0 => 'kPDFRenderer',
+ ),
+ ),
+ 'kiCacheable' => array(
+ 'type' => 2,
+ ),
+ ),
);