inc/classes/main/decorator/template/class_XmlRewriterTemplateDecorator.php

   1 <?php
   2 /**
   3  * A decorator for XML template engines which rewrites the XML for compacting
   4  * it.
   5  *
   6  * @author              Roland Haeder <webmaster@ship-simu.org>
   7  * @version             0.0.0
   8  * @copyright   Copyright (c) 2007, 2008 Roland Haeder, 2009 Core Developer Team
   9  * @license             GNU GPL 3.0 or any newer version
  10  * @link                http://www.ship-simu.org
  11  *
  12  * This program is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation, either version 3 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  24  */
  25 class XmlRewriterTemplateDecorator extends BaseDecorator implements CompileableTemplate {
  26         /**
  27          * Protected constructor
  28          *
  29          * @return      void
  30          */
  31         protected function __construct () {
  32                 // Call parent constructor
  33                 parent::__construct(__CLASS__);
  34         }
  35
  36         /**
  37          * Creates an instance of the class TemplateEngine and prepares it for usage
  38          *
  39          * @param       $innerTemplateInstance  A CompileableTemplate instance
  40          * @return      $templateInstance       An instance of TemplateEngine
  41          */
  42         public final static function createXmlRewriterTemplateDecorator (CompileableTemplate $innerTemplateInstance) {
  43                 // Get a new instance
  44                 $templateInstance = new XmlRewriterTemplateDecorator();
  45
  46                 // Set the inner template engine
  47                 $templateInstance->setTemplateInstance($innerTemplateInstance);
  48
  49                 // Return the prepared instance
  50                 return $templateInstance;
  51         }
  52
  53         /**
  54          * Settter for variable group
  55          *
  56          * @param       $groupName      Name of variable group
  57          * @param       $add            Wether add this group
  58          * @return      void
  59          */
  60         public function setVariableGroup ($groupName, $add = true) {
  61                 // Call the inner class' method
  62                 $this->getTemplateInstance()->setVariableGroup($groupName, $add);
  63         }
  64
  65         /**
  66          * Adds a variable to current group
  67          *
  68          * @param       $var    Variable to set
  69          * @param       $value  Value to store in variable
  70          * @return      void
  71          */
  72         public function addGroupVariable ($var, $value) {
  73                 // Call the inner class' method
  74                 $this->getTemplateInstance()->addGroupVariable($var, $value);
  75         }
  76
  77         /**
  78          * Setter for base path
  79          *
  80          * @param       $templateBasePath       The relative base path for all templates
  81          * @return      void
  82          */
  83         public final function setTemplateBasePath ($templateBasePath) {
  84                 // Call the inner class' method
  85                 $this->getTemplateInstance()->setTemplateBasePath($templateBasePath);
  86         }
  87
  88         /**
  89          * Getter for base path
  90          *
  91          * @return      $templateBasePath       The relative base path for all templates
  92          */
  93         public final function getTemplateBasePath () {
  94                 // Call the inner class' method
  95                 return $this->getTemplateInstance()->getTemplateBasePath();
  96         }
  97
  98         /**
  99          * Getter for generic base path
 100          *
 101          * @return      $templateBasePath       The relative base path for all templates
 102          */
 103         public final function getGenericBasePath () {
 104                 // Call the inner class' method
 105                 return $this->getTemplateInstance()->getGenericBasePath();
 106         }
 107
 108         /**
 109          * Setter for template extension
 110          *
 111          * @param       $templateExtension      The file extension for all uncompiled templates
 112          * @return      void
 113          */
 114         public final function setRawTemplateExtension ($templateExtension) {
 115                 // Call the inner class' method
 116                 $this->getTemplateInstance()->setRawTemplateExtension($templateExtension);
 117         }
 118
 119         /**
 120          * Setter for code template extension
 121          *
 122          * @param       $codeExtension  The file extension for all uncompiled templates
 123          * @return      void
 124          */
 125         public final function setCodeTemplateExtension ($codeExtension) {
 126                 // Call the inner class' method
 127                 $this->getTemplateInstance()->setCodeTemplateExtension($codeExtension);
 128         }
 129
 130         /**
 131          * Getter for template extension
 132          *
 133          * @return      $templateExtension      The file extension for all uncompiled templates
 134          */
 135         public final function getRawTemplateExtension () {
 136                 // Call the inner class' method
 137                 return $this->getTemplateInstance()->getRawTemplateExtension();
 138         }
 139
 140         /**
 141          * Getter for code-template extension
 142          *
 143          * @return      $codeExtension  The file extension for all code templates
 144          */
 145         public final function getCodeTemplateExtension () {
 146                 // Call the inner class' method
 147                 return $this->getTemplateInstance()->getCodeTemplateExtension();
 148         }
 149
 150         /**
 151          * Setter for path of compiled templates
 152          *
 153          * @param       $compileOutputPath      The local base path for all compiled templates
 154          * @return      void
 155          */
 156         public final function setCompileOutputPath ($compileOutputPath) {
 157                 // Call the inner class' method
 158                 $this->getTemplateInstance()->setCompileOutputPath($compileOutputPath);
 159         }
 160
 161         /**
 162          * Getter for template type
 163          *
 164          * @return      $templateType   The current template's type
 165          */
 166         public final function getTemplateType () {
 167                 // Call the inner class' method
 168                 return $this->getTemplateInstance()->getTemplateType();
 169         }
 170
 171         /**
 172          * Assign (add) a given variable with a value
 173          *
 174          * @param       $var    The variable we are looking for
 175          * @param       $value  The value we want to store in the variable
 176          * @return      void
 177          * @throws      EmptyVariableException  If the variable name is left empty
 178          */
 179         public final function assignVariable ($var, $value) {
 180                 // Call the inner class' method
 181                 $this->getTemplateInstance()->assignVariable($var, $value);
 182         }
 183
 184         /**
 185          * Removes a given variable
 186          *
 187          * @param       $var    The variable we are looking for
 188          * @return      void
 189          */
 190         public final function removeVariable ($var) {
 191                 // Call the inner class' method
 192                 $this->getTemplateInstance()->removeVariable($var);
 193         }
 194
 195         /**
 196          * Getter for compiled templates
 197          *
 198          * @return      $compiledData   Compiled template data
 199          */
 200         public final function getCompiledData () {
 201                 // Call the inner class' method
 202                 return $this->getTemplateInstance()->getCompiledData();
 203         }
 204
 205         /**
 206          * Load a specified web template into the engine
 207          *
 208          * @param       $template       The web template we shall load which is located in
 209          *                                              'html' by default
 210          * @return      void
 211          */
 212         public function loadWebTemplate ($template) {
 213                 // Call the inner class' method
 214                 $this->getTemplateInstance()->loadWebTemplate($template);
 215         }
 216
 217         /**
 218          * Assign a given congfiguration variable with a value
 219          *
 220          * @param       $var    The configuration variable we want to assign
 221          * @return      void
 222          */
 223         public function assignConfigVariable ($var) {
 224                 // Call the inner class' method
 225                 $this->getTemplateInstance()->assignConfigVariable($var);
 226         }
 227
 228         /**
 229          * Load a specified code template into the engine
 230          *
 231          * @param       $template       The code template we shall load which is
 232          *                                              located in 'code' by default
 233          * @return      void
 234          */
 235         public function loadCodeTemplate ($template) {
 236                 // Call the inner class' method
 237                 $this->getTemplateInstance()->loadCodeTemplate($template);
 238         }
 239
 240         /**
 241          * Compiles configuration place-holders in all variables. This 'walks'
 242          * through the variable stack 'general'. It interprets all values from that
 243          * variables as configuration entries after compiling them.
 244          *
 245          * @return      void
 246          */
 247         public final function compileConfigInVariables () {
 248                 // Call the inner class' method
 249                 $this->getTemplateInstance()->compileConfigInVariables();
 250         }
 251
 252         /**
 253          * Compile all variables by inserting their respective values
 254          *
 255          * @return      void
 256          */
 257         public final function compileVariables () {
 258                 // Call the inner class' method
 259                 $this->getTemplateInstance()->compileVariables();
 260         }
 261
 262         /**
 263          * Compile all required templates into the current loaded one
 264          *
 265          * @return      void
 266          */
 267         public function compileTemplate () {
 268                 // Call the inner class' method
 269                 $this->getTemplateInstance()->compileTemplate();
 270         }
 271
 272         /**
 273          * Assigns the last loaded raw template content with a given variable
 274          *
 275          * @param       $templateName   Name of the template we want to assign
 276          * @param       $variableName   Name of the variable we want to assign
 277          * @return      void
 278          */
 279         public function assignTemplateWithVariable ($templateName, $variableName) {
 280                 // Call the inner class' method
 281                 $this->getTemplateInstance()->assignTemplateWithVariable($templateName, $variableName);
 282         }
 283
 284         /**
 285          * Transfers the content of this template engine to a given response instance
 286          *
 287          * @param       $responseInstance       An instance of a response class
 288          * @return      void
 289          */
 290         public function transferToResponse (Responseable $responseInstance) {
 291                 // Call the inner class' method
 292                 $this->getTemplateInstance()->transportToResponse($responseInstance);
 293         }
 294
 295         /**
 296          * Assigns all the application data with template variables
 297          *
 298          * @param       $appInstance    A manageable application instance
 299          * @return      void
 300          */
 301         public function assignApplicationData (ManageableApplication $appInstance) {
 302                 // Call the inner class' method
 303                 $this->getTemplateInstance()->assignApplicationData($appInstance);
 304         }
 305
 306         /**
 307          * "Compiles" a variable by replacing {?var?} with it's content
 308          *
 309          * @param       $rawCode                        Raw code to compile
 310          * @param       $setMatchAsCode         Sets $match if readVariable() returns empty result
 311          * @return      $rawCode        Compile code with inserted variable value
 312          */
 313         public function compileRawCode ($rawCode, $setMatchAsCode=false) {
 314                 return $this->getTemplateInstance()->compileRawCode($rawCode, $setMatchAsCode);
 315         }
 316
 317         /**
 318          * Getter for variable group array
 319          *
 320          * @return      $vargroups      All variable groups
 321          */
 322         public final function getVariableGroups () {
 323                 // Call the inner class' method
 324                 return $this->getTemplateInstance()->getVariableGroups();
 325         }
 326
 327         /**
 328          * Renames a variable in code and in stack
 329          *
 330          * @param       $oldName        Old name of variable
 331          * @param       $newName        New name of variable
 332          * @return      void
 333          */
 334         public function renameVariable ($oldName, $newName) {
 335                 // Call the inner class' method
 336                 $this->getTemplateInstance()->renameVariable($oldName, $newName);
 337         }
 338
 339         /**
 340          * Renders the given XML content
 341          *
 342          * @param       $content        Valid XML content or if not set the current loaded raw content
 343          * @return      void
 344          * @throws      XmlParserException      If an XML error was found
 345          */
 346         public function renderXmlContent ($content = null) {
 347                 // Call the inner class' method
 348                 $this->getTemplateInstance()->renderXmlContent($content);
 349         }
 350
 351         /**
 352          * Enables or disables language support
 353          *
 354          * @param       $languageSupport        New language support setting
 355          * @return      void
 356          */
 357         public final function enableLanguageSupport ($languageSupport = true) {
 358                 // Call the inner class' method
 359                 $this->getTemplateInstance()->enableLanguageSupport($languageSupport);
 360         }
 361
 362         /**
 363          * Checks wether language support is enabled
 364          *
 365          * @return      $languageSupport        Wether language support is enabled or disabled
 366          */
 367         public final function isLanguageSupportEnabled () {
 368                 // Call the inner class' method
 369                 return $this->getTemplateInstance()->isLanguageSupportEnabled();
 370         }
 371
 372         /**
 373          * Enables or disables XML compacting
 374          *
 375          * @param       $xmlCompacting  New XML compacting setting
 376          * @return      void
 377          */
 378         public final function enableXmlCompacting ($xmlCompacting = true) {
 379                 // Call the inner class' method
 380                 $this->getTemplateInstance()->enableXmlCompacting($xmlCompacting);
 381         }
 382
 383         /**
 384          * Checks wether XML compacting is enabled
 385          *
 386          * @return      $xmlCompacting  Wether XML compacting is enabled or disabled
 387          */
 388         public final function isXmlCompactingEnabled () {
 389                 // Call the inner class' method
 390                 return $this->getTemplateInstance()->isXmlCompactingEnabled();
 391         }
 392 }
 393
 394 // [EOF]
 395 ?>