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

   1 <?php
   2 // Own namespace
   3 namespace Org\Mxchange\CoreFramework\Template\Xml;
   4
   5 // Import framework stuff
   6 use Org\Mxchange\CoreFramework\Generic\BaseDecorator;
   7 use Org\Mxchange\CoreFramework\Manager\ManageableApplication;
   8 use Org\Mxchange\CoreFramework\Response\Responseable;
   9 use Org\Mxchange\CoreFramework\Template\CompileableTemplate;
  10
  11 /**
  12  * A decorator for XML template engines which rewrites the XML for compacting
  13  * it.
  14  *
  15  * @author              Roland Haeder <webmaster@shipsimu.org>
  16  * @version             0.0.0
  17 <<<<<<< HEAD:framework/main/classes/decorator/template/class_XmlRewriterTemplateDecorator.php
  18  * @copyright   Copyright (c) 2007, 2008 Roland Haeder, 2009 - 2017 Core Developer Team
  19 =======
  20  * @copyright   Copyright (c) 2007, 2008 Roland Haeder, 2009 - 2016 Core Developer Team
  21 >>>>>>> Some updates::inc/main/classes/decorator/template/class_XmlRewriterTemplateDecorator.php
  22  * @license             GNU GPL 3.0 or any newer version
  23  * @link                http://www.shipsimu.org
  24  *
  25  * This program is free software: you can redistribute it and/or modify
  26  * it under the terms of the GNU General Public License as published by
  27  * the Free Software Foundation, either version 3 of the License, or
  28  * (at your option) any later version.
  29  *
  30  * This program is distributed in the hope that it will be useful,
  31  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  32  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  33  * GNU General Public License for more details.
  34  *
  35  * You should have received a copy of the GNU General Public License
  36  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  37  */
  38 class XmlRewriterTemplateDecorator extends BaseDecorator implements CompileableTemplate {
  39         /**
  40          * Protected constructor
  41          *
  42          * @return      void
  43          */
  44         protected function __construct () {
  45                 // Call parent constructor
  46                 parent::__construct(__CLASS__);
  47         }
  48
  49         /**
  50          * Creates an instance of the class TemplateEngine and prepares it for usage
  51          *
  52          * @param       $innerTemplateInstance  A CompileableTemplate instance
  53          * @return      $templateInstance       An instance of TemplateEngine
  54          */
  55         public static final function createXmlRewriterTemplateDecorator (CompileableTemplate $innerTemplateInstance) {
  56                 // Get a new instance
  57                 $templateInstance = new XmlRewriterTemplateDecorator();
  58
  59                 // Set the inner template engine
  60                 $templateInstance->setTemplateInstance($innerTemplateInstance);
  61
  62                 // Return the prepared instance
  63                 return $templateInstance;
  64         }
  65
  66         /**
  67          * Settter for variable group
  68          *
  69          * @param       $groupName      Name of variable group
  70          * @param       $add            Whether add this group
  71          * @return      void
  72          */
  73         public function setVariableGroup ($groupName, $add = true) {
  74                 // Call the inner class' method
  75                 $this->getTemplateInstance()->setVariableGroup($groupName, $add);
  76         }
  77
  78         /**
  79          * Adds a variable to current group
  80          *
  81          * @param       $var    Variable to set
  82          * @param       $value  Value to store in variable
  83          * @return      void
  84          */
  85         public function addGroupVariable ($var, $value) {
  86                 // Call the inner class' method
  87                 $this->getTemplateInstance()->addGroupVariable($var, $value);
  88         }
  89
  90         /**
  91          * Getter for base path
  92          *
  93          * @return      $templateBasePath       The relative base path for all templates
  94          */
  95         public final function getTemplateBasePath () {
  96                 // Call the inner class' method
  97                 return $this->getTemplateInstance()->getTemplateBasePath();
  98         }
  99
 100         /**
 101          * Getter for generic base path
 102          *
 103          * @return      $templateBasePath       The relative base path for all templates
 104          */
 105         public final function getGenericBasePath () {
 106                 // Call the inner class' method
 107                 return $this->getTemplateInstance()->getGenericBasePath();
 108         }
 109
 110         /**
 111          * Getter for template extension
 112          *
 113          * @return      $templateExtension      The file extension for all uncompiled templates
 114          */
 115         public final function getRawTemplateExtension () {
 116                 // Call the inner class' method
 117                 return $this->getTemplateInstance()->getRawTemplateExtension();
 118         }
 119
 120         /**
 121          * Getter for given variable group
 122          *
 123          * @param       $variableGroup  Variable group to check
 124          * @return      $varStack               Found variable group
 125          */
 126         public function getVarStack ($variableGroup) {
 127                 // Call the inner class' method
 128                 return $this->getTemplateInstance()->getVarStack($variableGroup);
 129         }
 130
 131         /**
 132          * Getter for code-template extension
 133          *
 134          * @return      $codeExtension  The file extension for all code templates
 135          */
 136         public final function getCodeTemplateExtension () {
 137                 // Call the inner class' method
 138                 return $this->getTemplateInstance()->getCodeTemplateExtension();
 139         }
 140
 141         /**
 142          * Getter for template type
 143          *
 144          * @return      $templateType   The current template's type
 145          */
 146         public final function getTemplateType () {
 147                 // Call the inner class' method
 148                 return $this->getTemplateInstance()->getTemplateType();
 149         }
 150
 151         /**
 152          * Assign (add) a given variable with a value
 153          *
 154          * @param       $var    The variable we are looking for
 155          * @param       $value  The value we want to store in the variable
 156          * @return      void
 157          */
 158         public function assignVariable ($var, $value) {
 159                 // Call the inner class' method
 160                 $this->getTemplateInstance()->assignVariable($var, $value);
 161         }
 162
 163         /**
 164          * Removes a given variable
 165          *
 166          * @param       $variableName   The variable we are looking for
 167          * @param       $variableGroup  Name of variable group (default: 'general')
 168          * @return      void
 169          */
 170         public function removeVariable ($variableName, $variableGroup = 'general') {
 171                 // Call the inner class' method
 172                 $this->getTemplateInstance()->removeVariable($variableName, $variableGroup);
 173         }
 174
 175         /**
 176          * Load a specified HTML template into the engine
 177          *
 178          * @param       $template       The web template we shall load which is located in
 179          *                                              'html' by default
 180          * @return      void
 181          */
 182         public function loadHtmlTemplate ($template) {
 183                 // Call the inner class' method
 184                 $this->getTemplateInstance()->loadHtmlTemplate($template);
 185         }
 186
 187         /**
 188          * Assign a given congfiguration variable with a value
 189          *
 190          * @param       $variableName   The configuration variable we want to assign
 191          * @return      void
 192          */
 193         public function assignConfigVariable ($variableName) {
 194                 // Call the inner class' method
 195                 $this->getTemplateInstance()->assignConfigVariable($variableName);
 196         }
 197
 198         /**
 199          * Load a specified code template into the engine
 200          *
 201          * @param       $template       The code template we shall load which is
 202          *                                              located in 'code' by default
 203          * @return      void
 204          */
 205         public function loadCodeTemplate ($template) {
 206                 // Call the inner class' method
 207                 $this->getTemplateInstance()->loadCodeTemplate($template);
 208         }
 209
 210         /**
 211          * Load a specified email template into the engine for later compilation
 212          * with other code/web/email templates.
 213          *
 214          * @param       $template       The email template we shall load which is
 215          *                                              located in "html" by default
 216          * @return      void
 217          */
 218         public function loadEmailTemplate ($template) {
 219                 // Call the inner class' method
 220                 $this->getTemplateInstance()->loadEmailTemplate($template);
 221         }
 222
 223         /**
 224          * Compiles configuration place-holders in all variables. This 'walks'
 225          * through the variable stack 'general'. It interprets all values from that
 226          * variables as configuration entries after compiling them.
 227          *
 228          * @return      void
 229          */
 230         public function compileConfigInVariables () {
 231                 // Call the inner class' method
 232                 $this->getTemplateInstance()->compileConfigInVariables();
 233         }
 234
 235         /**
 236          * Compile all variables by inserting their respective values
 237          *
 238          * @return      void
 239          */
 240         public function compileVariables () {
 241                 // Call the inner class' method
 242                 $this->getTemplateInstance()->compileVariables();
 243         }
 244
 245         /**
 246          * Compile all required templates into the current loaded one
 247          *
 248          * @return      void
 249          */
 250         public function compileTemplate () {
 251                 // Call the inner class' method
 252                 $this->getTemplateInstance()->compileTemplate();
 253         }
 254
 255         /**
 256          * Assigns the last loaded raw template content with a given variable
 257          *
 258          * @param       $templateName   Name of the template we want to assign
 259          * @param       $variableName   Name of the variable we want to assign
 260          * @return      void
 261          */
 262         public function assignTemplateWithVariable ($templateName, $variableName) {
 263                 // Call the inner class' method
 264                 $this->getTemplateInstance()->assignTemplateWithVariable($templateName, $variableName);
 265         }
 266
 267         /**
 268          * Transfers the content of this template engine to a given response instance
 269          *
 270          * @param       $responseInstance       An instance of a Responseable class
 271          * @return      void
 272          */
 273         public function transferToResponse (Responseable $responseInstance) {
 274                 // Call the inner class' method
 275                 $this->getTemplateInstance()->transportToResponse($responseInstance);
 276         }
 277
 278         /**
 279          * Assigns all the application data with template variables
 280          *
 281          * @param       $applicationInstance    A manageable application instance
 282          * @return      void
 283          */
 284         public function assignApplicationData (ManageableApplication $applicationInstance) {
 285                 // Call the inner class' method
 286                 $this->getTemplateInstance()->assignApplicationData($applicationInstance);
 287         }
 288
 289         /**
 290          * "Compiles" a variable by replacing {?var?} with it's content
 291          *
 292          * @param       $rawCode                        Raw code to compile
 293          * @param       $setMatchAsCode         Sets $match if readVariable() returns empty result
 294          * @return      $rawCode                        Compile code with inserted variable value
 295          */
 296         public function compileRawCode ($rawCode, $setMatchAsCode = false) {
 297                 return $this->getTemplateInstance()->compileRawCode($rawCode, $setMatchAsCode);
 298         }
 299
 300         /**
 301          * Getter for variable group array
 302          *
 303          * @return      $variableGroups         All variable groups
 304          */
 305         public final function getVariableGroups () {
 306                 // Call the inner class' method
 307                 return $this->getTemplateInstance()->getVariableGroups();
 308         }
 309
 310         /**
 311          * Getter for raw template data
 312          *
 313          * @return      $rawTemplateData        The raw data from the template
 314          */
 315         public function getRawTemplateData () {
 316                 // Call the inner class' method
 317                 return $this->getTemplateInstance()->getRawTemplateData();
 318         }
 319
 320         /**
 321          * Renames a variable in code and in stack
 322          *
 323          * @param       $oldName        Old name of variable
 324          * @param       $newName        New name of variable
 325          * @return      void
 326          */
 327         public function renameVariable ($oldName, $newName) {
 328                 // Call the inner class' method
 329                 $this->getTemplateInstance()->renameVariable($oldName, $newName);
 330         }
 331
 332         /**
 333          * Renders the given XML content
 334          *
 335          * @param       $content        Valid XML content or if not set the current loaded raw content
 336          * @return      void
 337          * @throws      XmlParserException      If an XML error was found
 338          */
 339         public function renderXmlContent ($content = NULL) {
 340                 // Call the inner class' method
 341                 $this->getTemplateInstance()->renderXmlContent($content);
 342         }
 343
 344         /**
 345          * Enables or disables language support
 346          *
 347          * @param       $languageSupport        New language support setting
 348          * @return      void
 349          */
 350         public function enableLanguageSupport ($languageSupport = true) {
 351                 // Call the inner class' method
 352                 $this->getTemplateInstance()->enableLanguageSupport($languageSupport);
 353         }
 354
 355         /**
 356          * Checks whether language support is enabled
 357          *
 358          * @return      $languageSupport        Whether language support is enabled or disabled
 359          */
 360         public function isLanguageSupportEnabled () {
 361                 // Call the inner class' method
 362                 return $this->getTemplateInstance()->isLanguageSupportEnabled();
 363         }
 364
 365         /**
 366          * Enables or disables XML compacting
 367          *
 368          * @param       $xmlCompacting  New XML compacting setting
 369          * @return      void
 370          */
 371         public function enableXmlCompacting ($xmlCompacting = true) {
 372                 // Call the inner class' method
 373                 $this->getTemplateInstance()->enableXmlCompacting($xmlCompacting);
 374         }
 375
 376         /**
 377          * Checks whether XML compacting is enabled
 378          *
 379          * @return      $xmlCompacting  Whether XML compacting is enabled or disabled
 380          */
 381         public function isXmlCompactingEnabled () {
 382                 // Call the inner class' method
 383                 return $this->getTemplateInstance()->isXmlCompactingEnabled();
 384         }
 385
 386         /**
 387          * Handles the start element of an XML resource
 388          *
 389          * @param       $resource               XML parser resource (currently ignored)
 390          * @param       $element                The element we shall handle
 391          * @param       $attributes             All attributes
 392          * @return      void
 393          * @throws      InvalidXmlNodeException         If an unknown/invalid XML node name was found
 394          */
 395         public function startElement ($resource, $element, array $attributes) {
 396                 // Call the inner class' method
 397                 $this->getTemplateInstance()->startElement($resource, $element, $attributes);
 398         }
 399
 400         /**
 401          * Ends the main or sub node by sending out the gathered data
 402          *
 403          * @param       $resource       An XML resource pointer (currently ignored)
 404          * @param       $nodeName       Name of the node we want to finish
 405          * @return      void
 406          * @throws      XmlNodeMismatchException        If current main node mismatches the closing one
 407          */
 408         public function finishElement ($resource, $nodeName) {
 409                 // Call the inner class' method
 410                 $this->getTemplateInstance()->finishElement($resource, $nodeName);
 411         }
 412
 413         /**
 414          * Currently not used
 415          *
 416          * @param       $resource               XML parser resource (currently ignored)
 417          * @param       $characters             Characters to handle
 418          * @return      void
 419          * @todo        Find something useful with this!
 420          */
 421         public function characterHandler ($resource, $characters) {
 422                 // Call the inner class' method but trim the characters before
 423                 $this->getTemplateInstance()->characterHandler($resource, trim($characters));
 424         }
 425
 426         /**
 427          * Removes all comments, tabs and new-line charcters to compact the content
 428          *
 429          * @param       $uncompactedContent             The uncompacted content
 430          * @return      $compactedContent               The compacted content
 431          */
 432         public function compactContent ($uncompactedContent) {
 433                 // Compact it ...
 434                 $compactedContent = $this->getTemplateInstance()->compactContent($uncompactedContent);
 435
 436                 // ... and return it
 437                 return $compactedContent;
 438         }
 439
 440         /**
 441          * Assigns a lot variables into the stack of currently loaded template.
 442          * This method should only be used in very rare circumstances, e.g. when
 443          * you have to copy a whole set of variables into the template engine.
 444          * Before you use this method, please make sure you have considered all
 445          * other possiblities.
 446          *
 447          * @param       $variables      An array with variables to be assigned
 448          * @return      void
 449          */
 450         public function assignMultipleVariables (array $variables) {
 451                 // Call the inner class' method but trim the characters before
 452                 $this->getTemplateInstance()->assignMultipleVariables($variables);
 453         }
 454
 455 }