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