PHP F::Array_MergeCombo方法代码示例

 /**
  * Returns full widget data (extends other widget or config dataset if needs)
  *
  * @param string|null $sWidgetId
  * @param array       $aWidgetData
  * @param array       $aWidgets
  *
  * @return array
  */
 protected function _getWidgetData($sWidgetId, $aWidgetData, $aWidgets)
 {
     if (!empty($aWidgetData[Config::KEY_REPLACE])) {
         unset($aWidgetData[Config::KEY_EXTENDS]);
         return $aWidgetData;
     }
     $xExtends = true;
     $bReset = false;
     if (!empty($aWidgetData[Config::KEY_EXTENDS])) {
         $xExtends = $aWidgetData[Config::KEY_EXTENDS];
         unset($aWidgetData[Config::KEY_EXTENDS]);
     }
     if (!empty($aWidgetData[Config::KEY_RESET])) {
         $bReset = $aWidgetData[Config::KEY_RESET];
         unset($aWidgetData[Config::KEY_RESET]);
     }
     if ($xExtends) {
         if ($xExtends === true && $sWidgetId && isset($aWidgets[$sWidgetId])) {
             if ($bReset) {
                 $aWidgetData = F::Array_Merge($aWidgets[$sWidgetId], $aWidgetData);
             } else {
                 $aWidgetData = F::Array_MergeCombo($aWidgets[$sWidgetId], $aWidgetData);
             }
         } elseif (is_string($xExtends)) {
             if ($bReset) {
                 $aWidgetData = F::Array_Merge(Config::Get($xExtends), $aWidgetData);
             } else {
                 $aWidgetData = F::Array_MergeCombo(Config::Get($xExtends), $aWidgetData);
             }
         }
     }
     return $aWidgetData;
 }

 /**
  * Returns full widget data (extends other widget or config dataset if needs)
  *
  * @param string|null $sWidgetId
  * @param array       $aWidgetData
  * @param array       $aWidgets
  *
  * @return array
  */
 protected function _getWidgetData($sWidgetId, $aWidgetData, $aWidgets)
 {
     $xExtends = false;
     if (!empty($aWidgetData[Config::KEY_EXTENDS])) {
         $xExtends = $aWidgetData[Config::KEY_EXTENDS];
         unset($aWidgetData[Config::KEY_EXTENDS]);
     } elseif (($iKey = array_search(Config::KEY_EXTENDS, $aWidgetData)) !== false) {
         $xExtends = true;
         unset($aWidgetData[$iKey]);
     }
     if ($xExtends) {
         if ($xExtends === true && $sWidgetId && isset($aWidgets[$sWidgetId])) {
             $aWidgetData = F::Array_MergeCombo($aWidgets[$sWidgetId], $aWidgetData);
         } elseif (is_string($xExtends)) {
             $aWidgetData = F::Array_MergeCombo(Config::Get($xExtends), $aWidgetData);
         }
     }
     return $aWidgetData;
 }

 /**
  * Initialization of skin
  *
  */
 protected function _initSkin()
 {
     $this->sViewSkin = $this->GetConfigSkin();
     // Load skin's config
     $aConfig = array();
     Config::ResetLevel(Config::LEVEL_SKIN);
     $aSkinConfigPaths['sSkinConfigCommonPath'] = Config::Get('path.smarty.template') . '/settings/config/';
     $aSkinConfigPaths['sSkinConfigAppPath'] = Config::Get('path.dir.app') . F::File_LocalPath($aSkinConfigPaths['sSkinConfigCommonPath'], Config::Get('path.dir.common'));
     // Может загружаться основной конфиг скина, так и внешние секции конфига,
     // которые задаются ключом 'config_load'
     // (обычно это 'classes', 'assets', 'jevix', 'widgets', 'menu')
     $aConfigNames = array('config') + F::Str2Array(Config::Get('config_load'));
     // Config section that are loaded for the current skin
     $aSkinConfigNames = array();
     // ** Old skin version compatibility
     $oSkin = E::ModuleSkin()->GetSkin($this->sViewSkin);
     if (!$oSkin || !$oSkin->GetCompatible() || $oSkin->SkinCompatible('1.1', '<')) {
         // 'head.default' may be used in skin config
         C::Set('head.default', C::Get('assets.default'));
     }
     // Load configs from paths
     foreach ($aConfigNames as $sConfigName) {
         foreach ($aSkinConfigPaths as $sPath) {
             $sFile = $sPath . $sConfigName . '.php';
             if (F::File_Exists($sFile)) {
                 $aSubConfig = F::IncludeFile($sFile, false, true);
                 if ($sConfigName != 'config' && !isset($aSubConfig[$sConfigName])) {
                     $aSubConfig = array($sConfigName => $aSubConfig);
                 } elseif ($sConfigName == 'config' && isset($aSubConfig['head'])) {
                     // ** Old skin version compatibility
                     $aSubConfig['assets'] = $aSubConfig['head'];
                     unset($aSubConfig['head']);
                 }
                 // загружаем конфиг, что позволяет сразу использовать значения
                 // в остальных конфигах скина (assets и кастомном config.php) через Config::Get()
                 Config::Load($aSubConfig, false, null, null, $sFile);
                 if ($sConfigName != 'config' && !isset($aSkinConfigNames[$sConfigName])) {
                     $aSkinConfigNames[$sConfigName] = $sFile;
                 }
             }
         }
     }
     if (!$oSkin || !$oSkin->GetCompatible() || $oSkin->SkinCompatible('1.1', '<')) {
         // 'head.default' may be used in skin config
         C::Set('head.default', false);
     }
     Config::ResetLevel(Config::LEVEL_SKIN_CUSTOM);
     $aStorageConfig = Config::ReadStorageConfig(null, true);
     // Reload sections changed by user
     if ($aSkinConfigNames) {
         foreach (array_keys($aSkinConfigNames) as $sConfigName) {
             if (isset($aStorageConfig[$sConfigName])) {
                 if (empty($aConfig)) {
                     $aConfig[$sConfigName] = $aStorageConfig[$sConfigName];
                 } else {
                     $aConfig = F::Array_MergeCombo($aConfig, array($sConfigName => $aStorageConfig[$sConfigName]));
                 }
             }
         }
     }
     // Checks skin's config from users settings
     $sUserConfigKey = 'skin.' . $this->sViewSkin . '.config';
     $aUserConfig = Config::Get($sUserConfigKey);
     if ($aUserConfig) {
         if (!$aConfig) {
             $aConfig = $aUserConfig;
         } else {
             $aConfig = F::Array_MergeCombo($aConfig, $aUserConfig);
         }
     }
     if ($aConfig) {
         Config::Load($aConfig, false, null, null, $sUserConfigKey);
     }
     // Check skin theme and set one in config if it was changed
     if ($this->GetConfigTheme() != Config::Get('view.theme')) {
         Config::Set('view.theme', $this->GetConfigTheme());
     }
     // Load lang files for skin
     E::ModuleLang()->LoadLangFileTemplate(E::ModuleLang()->GetLang());
     // Load template variables from config
     if (($aVars = Config::Get('view.assign')) && is_array($aVars)) {
         $this->Assign($aVars);
     }
 }

 /**
  * Initialization of skin
  *
  */
 protected function _initSkin()
 {
     $this->sViewSkin = $this->GetConfigSkin();
     // Load skin's config
     $aConfig = array();
     if (F::File_Exists($sFile = Config::Get('path.smarty.template') . '/settings/config/config.php')) {
         $aConfig = F::IncludeFile($sFile, FALSE, TRUE);
     }
     if (F::File_Exists($sFile = Config::Get('path.smarty.template') . '/settings/config/menu.php')) {
         $aConfig = F::Array_MergeCombo($aConfig, F::IncludeFile($sFile, false, true));
     }
     //        $aConfigLoad = F::Str2Array(Config::Get('config_load'));
     //        if ($aConfigLoad) {
     //            foreach ($aConfigLoad as $sConfigName) {
     //                if (F::File_Exists($sFile = Config::Get('path.smarty.template') . "/settings/config/$sConfigName.php")) {
     //                    $aConfig = array_merge($aConfig, F::IncludeFile($sFile, false, true));
     //                }
     //            }
     //        }
     // Checks skin's config in app dir
     $sFile = Config::Get('path.dir.app') . F::File_LocalPath($sFile, Config::Get('path.dir.common'));
     if (F::File_Exists($sFile)) {
         $aConfig = F::Array_MergeCombo($aConfig, F::IncludeFile($sFile, false, true));
     }
     // Checks skin's config from users settings
     $aUserConfig = Config::Get('skin.' . $this->sViewSkin . '.config');
     if ($aUserConfig) {
         if (!$aConfig) {
             $aConfig = $aUserConfig;
         } else {
             $aConfig = F::Array_MergeCombo($aConfig, $aUserConfig);
         }
     }
     Config::ResetLevel(Config::LEVEL_SKIN);
     if ($aConfig) {
         Config::Load($aConfig, false, null, null, 'skin');
     }
     // Check skin theme and set one in config if it was changed
     if ($this->GetConfigTheme() != Config::Get('view.theme')) {
         Config::Set('view.theme', $this->GetConfigTheme());
     }
     // Load lang files for skin
     E::ModuleLang()->LoadLangFileTemplate(E::ModuleLang()->GetLang());
     // Skip skin widgets for local viewer
     if (!$this->bLocal) {
         // * Load skin widgets
         if (F::File_Exists($sFile = Config::Get('path.smarty.template') . '/settings/config/widgets.php')) {
             $aSkinWidgets = F::IncludeFile($sFile, false, true);
             if (isset($aSkinWidgets['widgets']) && is_array($aSkinWidgets['widgets']) && count($aSkinWidgets['widgets'])) {
                 $aWidgets = array_merge(Config::Get('widgets'), $aSkinWidgets['widgets']);
                 Config::Set('widgets', $aWidgets);
             }
         }
     }
     // Load template variables from config
     if (($aVars = Config::Get('view.assign')) && is_array($aVars)) {
         $this->Assign($aVars);
     }
 }

 /**
  * Sets the value at the specified $xIndex to $xValue
  * $xIndex can be combined via the delimiter
  *
  * @param mixed $xIndex
  * @param mixed $xValue
  */
 public function offsetSet($xIndex, $xValue)
 {
     if (!is_int($xIndex) && strpos($xIndex, '.')) {
         $aPath = explode($this->sDelimiter, $xIndex);
         $aData = array();
         $xItem = null;
         foreach ($aPath as $sPiece) {
             if (is_null($xItem)) {
                 $aData[$sPiece] = array();
                 $xItem =& $aData[$sPiece];
             } else {
                 $xItem[$sPiece] = array();
                 $xItem =& $xItem[$sPiece];
             }
         }
         $xItem = $xValue;
         $xIndex = F::Array_FirstKey($aData);
         $xValue = reset($aData);
     }
     if (is_array($xValue) && parent::offsetExists($xIndex)) {
         $xOldValue = parent::offsetGet($xIndex);
         if (is_array($xOldValue)) {
             $xValue = F::Array_MergeCombo($xOldValue, $xValue);
         }
     }
     parent::offsetSet($xIndex, $xValue);
     $this->aQuickMap = array();
 }

 /**
  * @param string $sConfigDir
  * @param int    $nConfigLevel
  */
 protected static function _loadConfigFiles($sConfigDir, $nConfigLevel)
 {
     // * Загружаем конфиги модулей вида /config/modules/[module_name]/config.php
     $sDirConfig = $sConfigDir . '/modules/';
     $aFiles = glob($sDirConfig . '*/config.php');
     if ($aFiles) {
         foreach ($aFiles as $sConfigFile) {
             $sDirModule = basename(dirname($sConfigFile));
             $aConfig = F::IncludeFile($sConfigFile, true, true);
             if (!empty($aConfig) && is_array($aConfig)) {
                 $sKey = 'module.' . $sDirModule;
                 Config::Load(array($sKey => $aConfig), false, null, $nConfigLevel, $sConfigFile);
             }
         }
     }
     /*
      * Подгружаем файлы локального конфига
      */
     $sConfigFile = $sConfigDir . '/config.local.php';
     if (F::File_Exists($sConfigFile)) {
         if ($aConfig = F::File_IncludeFile($sConfigFile, true)) {
             Config::Set($aConfig, false, null, $nConfigLevel, $sConfigFile);
         }
     }
     /*
      * Загружает конфиг-файлы плагинов вида /plugins/[plugin_name]/config/*.php
      * и include-файлы вида /plugins/[plugin_name]/include/*.php
      */
     $sPluginsDir = F::GetPluginsDir($nConfigLevel == Config::LEVEL_APP);
     if ($aPluginsList = F::GetPluginsList(false, false)) {
         foreach ($aPluginsList as $sPlugin => $aPluginInfo) {
             // Paths to dirs of plugins
             Config::Set('path.dir.plugin.' . $aPluginInfo['id'], $aPluginInfo['path']);
             // Загружаем все конфиг-файлы плагина
             $aConfigFiles = glob($sPluginsDir . '/' . $aPluginInfo['dirname'] . '/config/*.php');
             if ($aConfigFiles) {
                 // move config.php to begin of array
                 if (sizeof($aConfigFiles) > 1) {
                     $sConfigFile = $sPluginsDir . '/' . $aPluginInfo['dirname'] . '/config/config.php';
                     $iIndex = array_search($sConfigFile, $aConfigFiles);
                     if ($iIndex) {
                         $aConfigFiles = array_merge(array_splice($aConfigFiles, $iIndex, 1), $aConfigFiles);
                     }
                 }
                 foreach ($aConfigFiles as $sConfigFile) {
                     $aConfig = F::IncludeFile($sConfigFile, true, true);
                     if (!empty($aConfig) && is_array($aConfig)) {
                         // Если конфиг этого плагина пуст, то загружаем массив целиком
                         $sKey = 'plugin.' . $sPlugin;
                         if (!Config::isExist($sKey)) {
                             Config::Set($sKey, $aConfig, null, $nConfigLevel, $sConfigFile);
                         } else {
                             // Если уже существуют привязанные к плагину ключи,
                             // то сливаем старые и новое значения ассоциативно-комбинированно
                             /** @see AltoFunc_Array::MergeCombo() */
                             Config::Set($sKey, F::Array_MergeCombo(Config::Get($sKey), $aConfig), null, $nConfigLevel, $sConfigFile);
                         }
                     }
                 }
             }
         }
     }
 }

 /**
  * Set config value(s)
  * Usage:
  *   Config::Set('key', $xData, ...);
  * or
  *   Config::Set(array('key', $xData), $bReplace, ...);
  *
  * @param string|array $sKey    - Key or Config data array
  * @param mixed        $xValue  - Value(s) or Replace flag
  * @param string       $sRoot   - Root key
  * @param int          $nLevel  - Level of config
  * @param string       $sSource - Source of data
  *
  * @return bool
  */
 public static function Set($sKey, $xValue, $sRoot = self::DEFAULT_CONFIG_ROOT, $nLevel = null, $sSource = null)
 {
     if (is_array($sKey) && is_bool($xValue)) {
         $aConfigData = $sKey;
         $bReplace = $xValue;
         $xValue = reset($aConfigData);
     } else {
         $aConfigData = array($sKey => $xValue);
         $bReplace = false;
     }
     if ($aConfigData) {
         if (is_integer($sRoot) && (is_null($nLevel) || is_string($nLevel))) {
             if (is_string($nLevel)) {
                 $sSource = $nLevel;
             }
             $nLevel = $sRoot;
             $sRoot = self::DEFAULT_CONFIG_ROOT;
         }
         // Check for KEY_ROOT in config data
         if (isset($xValue[self::KEY_ROOT]) && is_array($xValue[self::KEY_ROOT])) {
             $aRoot = $xValue[self::KEY_ROOT];
             unset($xValue[self::KEY_ROOT]);
             foreach ($aRoot as $sRootKey => $xVal) {
                 if (static::isExist($sRootKey)) {
                     static::Set($sRootKey, F::Array_MergeCombo(Config::Get($sRootKey, $sRoot, null, true), $xVal), $sRoot, $nLevel, $sSource);
                 } else {
                     static::Set($sRootKey, $xVal, $sRoot, $nLevel, $sSource);
                 }
             }
         }
         /** @var Config $oConfig */
         $oConfig = static::getInstance();
         // Check for KEY_REPLACE in config data
         $aClearConfig = self::_extractForReplacement($aConfigData);
         if ($aClearConfig) {
             $oConfig->SetConfig($aClearConfig, false, $sRoot, $nLevel, $sSource);
         }
         $oConfig->SetConfig($aConfigData, $bReplace, $sRoot, $nLevel, $sSource);
     }
     return true;
 }

 /**
  * @param string      $sPrefix
  * @param string|null $sConfigKeyPrefix
  * @param bool        $bCacheOnly
  * @param bool        $bRaw
  *
  * @return array
  */
 protected static function _readConfig($sPrefix, $sConfigKeyPrefix = null, $bCacheOnly = false, $bRaw = false)
 {
     if ($sPrefix && substr($sPrefix, -1) != '.') {
         $sPrefix .= '.';
     }
     $aConfig = array();
     if (!$bRaw && self::_checkFileCfg(!$bCacheOnly)) {
         $aConfig = self::_getFileCfg();
     }
     if (!$aConfig) {
         if (!$bCacheOnly && class_exists('E', false)) {
             // Reread config from db
             $sPrefix = $sPrefix . $sConfigKeyPrefix;
             $aData = E::ModuleAdmin()->GetStorageConfig($sPrefix);
             $aConfig = self::_explodeData($aData, $sPrefix);
             if ($bRaw) {
                 return $aConfig;
             }
             if (isset($aConfig['plugin'])) {
                 $aConfigPlugins = array_keys($aConfig['plugin']);
                 $aActivePlugins = F::GetPluginsList(false, true);
                 if (!$aActivePlugins) {
                     unset($aConfig['plugin']);
                 } else {
                     $bRootConfig = false;
                     foreach ($aConfigPlugins as $sPlugin) {
                         if (!in_array($sPlugin, $aActivePlugins)) {
                             unset($aConfig['plugin'][$sPlugin]);
                         } else {
                             if (isset($aConfig['plugin'][$sPlugin][self::KEY_ROOT])) {
                                 $bRootConfig = true;
                             }
                         }
                     }
                     if (empty($aConfig['plugin'])) {
                         unset($aConfig['plugin']);
                     }
                     // Need to prepare config data
                     if ($bRootConfig) {
                         $aConfigResult = array();
                         foreach ($aConfig as $sKey => $xVal) {
                             if ($sKey == 'plugin') {
                                 // sort plugin config by order of active pligin list
                                 foreach ($aActivePlugins as $sPluginId) {
                                     if (isset($aConfig['plugin'][$sPluginId])) {
                                         $aPluginConfig = $aConfig['plugin'][$sPluginId];
                                         if (isset($aPluginConfig[self::KEY_ROOT])) {
                                             if (is_array($aPluginConfig[self::KEY_ROOT]) && $aPluginConfig[self::KEY_ROOT]) {
                                                 foreach ($aPluginConfig[self::KEY_ROOT] as $sRootKey => $xRootVal) {
                                                     if (isset($aConfigResult[$sRootKey])) {
                                                         $aConfigResult[$sRootKey] = F::Array_MergeCombo($aConfigResult[$sRootKey], $xRootVal);
                                                     } else {
                                                         $aConfigResult[$sRootKey] = $xRootVal;
                                                     }
                                                 }
                                             }
                                             unset($aPluginConfig[self::KEY_ROOT]);
                                         }
                                         if (!empty($aPluginConfig)) {
                                             $aConfigResult['plugin'][$sPluginId] = $aPluginConfig;
                                         }
                                     }
                                 }
                             } else {
                                 $aConfigResult[$sKey] = $xVal;
                             }
                         }
                         $aConfig = $aConfigResult;
                     }
                     // $bRootConfig
                 }
             }
             // Признак того, что кеш конфига синхронизирован с базой
             $aConfig['_db_'] = time();
             self::_putFileCfg($aConfig);
         } else {
             // Признак того, что кеш конфига НЕ синхронизиован с базой
             $aConfig['_db_'] = false;
         }
     } elseif ($sConfigKeyPrefix) {
         $aData = new DataArray($aConfig);
         if ($sPrefix == self::ENGINE_CONFIG_PREFIX) {
             $sConfigKeyPrefix = $sPrefix . $sConfigKeyPrefix;
         }
         return $aData[$sConfigKeyPrefix];
     }
     return $aConfig;
 }