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