Cleanup + expanded CompileableTemplate with a lot public methods from BaseTemplateEngine
[core.git] / 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@shipsimu.org>
7  * @version             0.0.0
8  * @copyright   Copyright (c) 2007, 2008 Roland Haeder, 2009 - 2015 Core Developer Team
9  * @license             GNU GPL 3.0 or any newer version
10  * @link                http://www.shipsimu.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 static final 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            Whether 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       $variableName   The variable we are looking for
188          * @param       $variableGroup  Name of variable group (default: 'general')
189          * @return      void
190          */
191         public final function removeVariable ($variableName, $variableGroup = 'general') {
192                 // Call the inner class' method
193                 $this->getTemplateInstance()->removeVariable($variableName, $variableGroup);
194         }
195
196         /**
197          * Load a specified web template into the engine
198          *
199          * @param       $template       The web template we shall load which is located in
200          *                                              'html' by default
201          * @return      void
202          */
203         public function loadWebTemplate ($template) {
204                 // Call the inner class' method
205                 $this->getTemplateInstance()->loadWebTemplate($template);
206         }
207
208         /**
209          * Assign a given congfiguration variable with a value
210          *
211          * @param       $variableName   The configuration variable we want to assign
212          * @return      void
213          */
214         public function assignConfigVariable ($variableName) {
215                 // Call the inner class' method
216                 $this->getTemplateInstance()->assignConfigVariable($variableName);
217         }
218
219         /**
220          * Load a specified code template into the engine
221          *
222          * @param       $template       The code template we shall load which is
223          *                                              located in 'code' by default
224          * @return      void
225          */
226         public function loadCodeTemplate ($template) {
227                 // Call the inner class' method
228                 $this->getTemplateInstance()->loadCodeTemplate($template);
229         }
230
231         /**
232          * Compiles configuration place-holders in all variables. This 'walks'
233          * through the variable stack 'general'. It interprets all values from that
234          * variables as configuration entries after compiling them.
235          *
236          * @return      void
237          */
238         public final function compileConfigInVariables () {
239                 // Call the inner class' method
240                 $this->getTemplateInstance()->compileConfigInVariables();
241         }
242
243         /**
244          * Compile all variables by inserting their respective values
245          *
246          * @return      void
247          */
248         public final function compileVariables () {
249                 // Call the inner class' method
250                 $this->getTemplateInstance()->compileVariables();
251         }
252
253         /**
254          * Compile all required templates into the current loaded one
255          *
256          * @return      void
257          */
258         public function compileTemplate () {
259                 // Call the inner class' method
260                 $this->getTemplateInstance()->compileTemplate();
261         }
262
263         /**
264          * Assigns the last loaded raw template content with a given variable
265          *
266          * @param       $templateName   Name of the template we want to assign
267          * @param       $variableName   Name of the variable we want to assign
268          * @return      void
269          */
270         public function assignTemplateWithVariable ($templateName, $variableName) {
271                 // Call the inner class' method
272                 $this->getTemplateInstance()->assignTemplateWithVariable($templateName, $variableName);
273         }
274
275         /**
276          * Transfers the content of this template engine to a given response instance
277          *
278          * @param       $responseInstance       An instance of a response class
279          * @return      void
280          */
281         public function transferToResponse (Responseable $responseInstance) {
282                 // Call the inner class' method
283                 $this->getTemplateInstance()->transportToResponse($responseInstance);
284         }
285
286         /**
287          * Assigns all the application data with template variables
288          *
289          * @param       $applicationInstance    A manageable application instance
290          * @return      void
291          */
292         public function assignApplicationData (ManageableApplication $applicationInstance) {
293                 // Call the inner class' method
294                 $this->getTemplateInstance()->assignApplicationData($applicationInstance);
295         }
296
297         /**
298          * "Compiles" a variable by replacing {?var?} with it's content
299          *
300          * @param       $rawCode                        Raw code to compile
301          * @param       $setMatchAsCode         Sets $match if readVariable() returns empty result
302          * @return      $rawCode                        Compile code with inserted variable value
303          */
304         public function compileRawCode ($rawCode, $setMatchAsCode = FALSE) {
305                 return $this->getTemplateInstance()->compileRawCode($rawCode, $setMatchAsCode);
306         }
307
308         /**
309          * Getter for variable group array
310          *
311          * @return      $variableGroups         All variable groups
312          */
313         public final function getVariableGroups () {
314                 // Call the inner class' method
315                 return $this->getTemplateInstance()->getVariableGroups();
316         }
317
318         /**
319          * Renames a variable in code and in stack
320          *
321          * @param       $oldName        Old name of variable
322          * @param       $newName        New name of variable
323          * @return      void
324          */
325         public function renameVariable ($oldName, $newName) {
326                 // Call the inner class' method
327                 $this->getTemplateInstance()->renameVariable($oldName, $newName);
328         }
329
330         /**
331          * Renders the given XML content
332          *
333          * @param       $content        Valid XML content or if not set the current loaded raw content
334          * @return      void
335          * @throws      XmlParserException      If an XML error was found
336          */
337         public function renderXmlContent ($content = NULL) {
338                 // Call the inner class' method
339                 $this->getTemplateInstance()->renderXmlContent($content);
340         }
341
342         /**
343          * Enables or disables language support
344          *
345          * @param       $languageSupport        New language support setting
346          * @return      void
347          */
348         public final function enableLanguageSupport ($languageSupport = TRUE) {
349                 // Call the inner class' method
350                 $this->getTemplateInstance()->enableLanguageSupport($languageSupport);
351         }
352
353         /**
354          * Checks whether language support is enabled
355          *
356          * @return      $languageSupport        Whether language support is enabled or disabled
357          */
358         public final function isLanguageSupportEnabled () {
359                 // Call the inner class' method
360                 return $this->getTemplateInstance()->isLanguageSupportEnabled();
361         }
362
363         /**
364          * Enables or disables XML compacting
365          *
366          * @param       $xmlCompacting  New XML compacting setting
367          * @return      void
368          */
369         public final function enableXmlCompacting ($xmlCompacting = TRUE) {
370                 // Call the inner class' method
371                 $this->getTemplateInstance()->enableXmlCompacting($xmlCompacting);
372         }
373
374         /**
375          * Checks whether XML compacting is enabled
376          *
377          * @return      $xmlCompacting  Whether XML compacting is enabled or disabled
378          */
379         public final function isXmlCompactingEnabled () {
380                 // Call the inner class' method
381                 return $this->getTemplateInstance()->isXmlCompactingEnabled();
382         }
383
384         /**
385          * Handles the start element of an XML resource
386          *
387          * @param       $resource               XML parser resource (currently ignored)
388          * @param       $element                The element we shall handle
389          * @param       $attributes             All attributes
390          * @return      void
391          * @throws      InvalidXmlNodeException         If an unknown/invalid XML node name was found
392          */
393         public function startElement ($resource, $element, array $attributes) {
394                 // Call the inner class' method
395                 $this->getTemplateInstance()->startElement($resource, $element, $attributes);
396         }
397
398         /**
399          * Ends the main or sub node by sending out the gathered data
400          *
401          * @param       $resource       An XML resource pointer (currently ignored)
402          * @param       $nodeName       Name of the node we want to finish
403          * @return      void
404          * @throws      XmlNodeMismatchException        If current main node mismatches the closing one
405          */
406         public function finishElement ($resource, $nodeName) {
407                 // Call the inner class' method
408                 $this->getTemplateInstance()->finishElement($resource, $nodeName);
409         }
410
411         /**
412          * Currently not used
413          *
414          * @param       $resource               XML parser resource (currently ignored)
415          * @param       $characters             Characters to handle
416          * @return      void
417          * @todo        Find something useful with this!
418          */
419         public function characterHandler ($resource, $characters) {
420                 // Call the inner class' method but trim the characters before
421                 $this->getTemplateInstance()->characterHandler($resource, trim($characters));
422         }
423
424         /**
425          * Removes all comments, tabs and new-line charcters to compact the content
426          *
427          * @param       $uncompactedContent             The uncompacted content
428          * @return      $compactedContent               The compacted content
429          */
430         public function compactContent ($uncompactedContent) {
431                 // Compact it ...
432                 $compactedContent = $this->getTemplateInstance()->compactContent($uncompactedContent);
433
434                 // ... and return it
435                 return $compactedContent;
436         }
437 }
438
439 // [EOF]
440 ?>