application/selector/class_ApplicationSelector.php

   1 <?php
   2 /**
   3  * The application selector class.
   4  *
   5  * Please remember that this include file is being loaded *before* the class
   6  * loader is loading classes from "exceptions", "interfaces" and "main"!
   7  *
   8  * @author              Roland Haeder <webmaster@ship-simu.org>
   9  * @version             0.0.0
  10  * @copyright   Copyright (c) 2007, 2008 Roland Haeder, this is free software
  11  * @license             GNU GPL 3.0 or any newer version
  12  * @link                http://www.ship-simu.org
  13  *
  14  * This program is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation, either version 3 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  26  */
  27 class ApplicationSelector extends BaseFrameworkSystem {
  28         /**
  29          * An ArrayObject for all found applications
  30          */
  31         private $foundApps = null;
  32
  33         /**
  34          * An array object for all loaded application templates (selector_app-name.tpl)
  35          */
  36         private $loadedTemplates = null;
  37
  38         /**
  39          * The application selector's own template engine handler
  40          */
  41         private $selectorTplEngine = null;
  42
  43         /**
  44          * A list of items we shall ignore while reading from directories
  45          */
  46         private $dirIgnoreList = array(
  47                 ".",
  48                 "..",
  49                 ".htaccess",
  50                 ".svn"
  51         );
  52
  53         /**
  54          * The protected constructor. No direct instances can be created from this.
  55          *
  56          * @return      void
  57          */
  58         protected function __construct() {
  59                 // Call parent constructor
  60                 parent::__construct(__CLASS__);
  61
  62                 // Remove system array and thousand seperator
  63                 $this->removeSystemArray();
  64                 $this->removeNumberFormaters();
  65
  66                 // Initialize the array lists
  67                 $this->initializeAppsList();
  68                 $this->initializeTemplatesList();
  69         }
  70
  71         /**
  72          * Create a prepared instance of ApplicationSelector
  73          *
  74          * @param       $langInstance           The language sub-system: LanguageSystem
  75          * @param       $fileIOInstance         The file I/O instance
  76          * @return      $selInstance            An instance of ApplicationSelector
  77          */
  78         public final static function createApplicationSelector (ManageableLanguage $langInstance, FileIoHandler $fileIOInstance) {
  79                 // Get a new instance
  80                 $selInstance = new ApplicationSelector();
  81
  82                 // Get all applications
  83                 $selInstance->readApplicationDirectory();
  84
  85                 // Set language and file I/O instances
  86                 $selInstance->setLanguageInstance($langInstance);
  87                 $selInstance->setFileIoInstance($fileIOInstance);
  88
  89                 // Return the prepared instance
  90                 return $selInstance;
  91         }
  92
  93         /**
  94          * Initialize the application list
  95          *
  96          * @return      void
  97          */
  98         private function initializeAppsList () {
  99                 $this->foundApps = new FrameworkArrayObject("FakedFoundApplications");
 100         }
 101
 102         /**
 103          * Initialize the loaded templates list
 104          *
 105          * @return      void
 106          */
 107         private function initializeTemplatesList () {
 108                 $this->loadedTemplates = new FrameworkArrayObject("FakedLoadedTemplates");
 109         }
 110
 111         /**
 112          * Load the data.php script of an application and append the application
 113          * instance to $foundApps
 114          *
 115          * @param       $appData                The FQFN of data.php
 116          * @param       $appName                The application's Uni* name
 117          * @return      void
 118          */
 119         private function loadApplicationData ($appData, $appName) {
 120                 // Is it a file and readable?
 121                 if ((is_file($appData)) && (is_readable($appData))) {
 122                         // Then include it
 123                         include ($appData);
 124
 125                         // Add the current instance to the list
 126                         $this->foundApps->append($app);
 127
 128                 } // END - if ((is_file(...
 129         }
 130
 131         /**
 132          * Setter for the selector's template engine instance
 133          *
 134          * @param       $templateInstance       An instance of TemplateEngine
 135          * @return      void
 136          */
 137         private final function setSelectorTemplateEngine (CompileableTemplate $templateInstance) {
 138                 $this->selectorTplEngine = $templateInstance;
 139         }
 140
 141         /**
 142          * Getter for the selector's template engine instance
 143          *
 144          * @return      $selectTplEngine        The selector's template engine
 145          */
 146         private final function getSelectorTemplateEngine () {
 147                 return $this->selectorTplEngine;
 148         }
 149
 150         /**
 151          * Getter for the $loadedTemplates array object
 152          *
 153          * @return      $loadedTemplates        An array object holding all loaded
 154          *                                                      application templates
 155          */
 156         private final function getLoadedTemplates () {
 157                 return $this->loadedTemplates;
 158         }
 159
 160         /**
 161          * Method for compatiblity with prepareTemplateInstance()
 162          *
 163          * @return      $shortName      This selector's short name
 164          */
 165         public function getAppShortName() {
 166                 $shortName = $this->getConfigInstance()->readConfig('selector_path');
 167                 return $shortName;
 168         }
 169
 170         /**
 171          * Add a directory/file to the ignore list
 172          *
 173          * @param               $ignoreItem     The file/directory we shall ignore
 174          * @return      void
 175          */
 176         public function addDirIgnoreList ($ignoreItem) {
 177                 // Cast and add it
 178                 $ignoreItem = (string) $ignoreItem;
 179                 $this->dirIgnoreList[] = $ignoreItem;
 180         }
 181
 182         /**
 183          * Read the base path for all applications (application/) and create a
 184          * list of all found applications
 185          *
 186          * @return      void
 187          */
 188         public function readApplicationDirectory () {
 189                 // Generate the base path for all applications
 190                 $appBasePath = $this->getConfigInstance()->readConfig('application_path');
 191
 192                 // Add the selector path to the ignore list
 193                 $this->addDirIgnoreList($this->getConfigInstance()->readConfig('selector_path'));
 194
 195                 // Get a directory pointer for the application path
 196                 $dirInstance = FrameworkDirectoryPointer::createFrameworkDirectoryPointer($appBasePath);
 197
 198                 // Backup and remove the 'app' from local name space
 199                 /*$appBackup = $app;
 200                 unset($app);*/
 201
 202                 // Read all directories&files except some parts
 203                 while ($appName = $dirInstance->readDirectoryExcept($this->dirIgnoreList)) {
 204                         // Generate FQFN for the application name (or better directory name)
 205                         $fqfn = sprintf("%s%s", $appBasePath, $appName);
 206
 207                         // Is this a readable directory? (files will be ignored silently)
 208                         if ((is_dir($fqfn)) && (is_readable($fqfn))) {
 209                                 // Then get the data.php script for analyzing
 210                                 $appData = sprintf("%s/data.php", $fqfn);
 211
 212                                 // Load the application's data.php script and append the
 213                                 // application to the ArrayObject
 214                                 $this->loadApplicationData($appData, $appName);
 215                         } // END - if
 216                 } // END - while
 217
 218                 // Close directory pointer
 219                 $dirInstance->closeDirectory();
 220
 221                 // Restore old 'app' from backup
 222                 //$app = $appBackup;
 223         }
 224
 225         /**
 226          * Load all templates for found applications in previous scan
 227          *
 228          * @return      void
 229          */
 230         public function loadApplicationTemplates () {
 231                 // Iterate through all applications
 232                 for ($idx = $this->foundApps->getIterator(); $idx->valid(); $idx->next()) {
 233                         // Get current application
 234                         $appInstance = $idx->current();
 235
 236                         // Prepare the template engine for the current template
 237                         $templateInstance = $this->prepareTemplateInstance($appInstance);
 238
 239                         // Try to load the web template
 240                         $templateInstance->loadWebTemplate(sprintf("%s_%s",
 241                                 $this->getConfigInstance()->readConfig('tpl_selector_prefix'),
 242                                 strtolower($appInstance->getAppShortName())
 243                         ));
 244
 245                         // Remember this template and the application for later usage
 246                         $this->loadedTemplates->append(array(
 247                                 'template_class'   => $templateInstance,
 248                                 'app_instance' => $appInstance
 249                         ));
 250                 }
 251
 252                 // Re-initialize the application list to avoid double loading
 253                 $this->initializeAppsList();
 254         }
 255
 256         /**
 257          * Removes $dirIgnoreList from the object to save some memory
 258          *
 259          * @return      void
 260          */
 261         public final function removeDirIgnoreList () {
 262                 unset($this->dirIgnoreList);
 263         }
 264
 265         /**
 266          * Loads the selector's own main template. This step is not linking the
 267          * application's templates into the main one.
 268          *
 269          * @return      void
 270          */
 271         public function loadSelectorTemplate () {
 272                 // Prepare the template engine
 273                 $templateInstance = $this->prepareTemplateInstance($this);
 274
 275                 // Load the selector's template
 276                 $templateInstance->loadCodeTemplate($this->getConfigInstance()->readConfig('selector_main_tpl'));
 277
 278                 // Now store it in the class
 279                 $this->setSelectorTemplateEngine($templateInstance);
 280         }
 281
 282         /**
 283          * Inserts all loaded application templates into the selector's template
 284          *
 285          * @return      void
 286          * @throws      NullPointerException            If $curr is null
 287          * @throws      NoArrayException                        If $curr is not an array
 288          * @throws      InvalidArrayCountException      If $curr contains an
 289          *                                                                              unexpected count of elements
 290          * @throws      MissingArrayElementsException   If $curr is missing expected
 291          *                                                                                      array elements
 292          */
 293         public function insertApplicationTemplates () {
 294                 // First prepare the instance
 295                 $templateInstance = $this->prepareTemplateInstance($this);
 296
 297                 // Load template which shall later hold all application templates
 298                 $templateInstance->loadCodeTemplate($this->getConfigInstance()->readConfig('selector_apps_tpl'));
 299
 300                 // Add all loaded application templates together
 301                 $dummy = "";
 302                 for ($idx = $this->getLoadedTemplates()->getIterator(); $idx->valid(); $idx->next()) {
 303                         // Get current item from array object
 304                         $curr = $idx->current();
 305
 306                         // Do some sanity checks on the loaded item
 307                         if (is_null($curr)) {
 308                                 // $curr is null
 309                                 throw new NullPointerException($this, self::EXCEPTION_IS_NULL_POINTER);
 310                         } elseif (!is_array($curr)) {
 311                                 // Not an array
 312                                 throw new NoArrayException($curr, self::EXCEPTION_IS_NO_ARRAY);
 313                         } elseif (count($curr) != 2) {
 314                                 // Not expected count of entries
 315                                 throw new InvalidArrayCountException(array($this, "curr", count($curr), 2), self::EXCEPTION_ARRAY_HAS_INVALID_COUNT);
 316                         } elseif (!isset($curr['template_class']) || (!isset($curr['app_instance']))) {
 317                                 // Expected entries missing
 318                                 throw new MissingArrayElementsException(array($this, "curr", array("template_class", "app_instance")), self::EXCEPTION_ARRAY_ELEMENTS_MISSING);
 319                         }
 320                         die("<pre>".print_r($curr, true)."</pre>");
 321
 322                 } // END - for
 323         }
 324 }
 325
 326 // [EOF]
 327 ?>