<?php
/**
 * A decorator for XML template engines which rewrites the XML for compacting
 * it.
 *
 * @author		Roland Haeder <webmaster@ship-simu.org>
 * @version		0.0.0
 * @copyright	Copyright (c) 2007, 2008 Roland Haeder, 2009, 2010 Core Developer Team
 * @license		GNU GPL 3.0 or any newer version
 * @link		http://www.ship-simu.org
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
class XmlRewriterTemplateDecorator extends BaseDecorator implements CompileableTemplate {
	/**
	 * Protected constructor
	 *
	 * @return	void
	 */
	protected function __construct () {
		// Call parent constructor
		parent::__construct(__CLASS__);
	}

	/**
	 * Creates an instance of the class TemplateEngine and prepares it for usage
	 *
	 * @param	$innerTemplateInstance	A CompileableTemplate instance
	 * @return	$templateInstance	An instance of TemplateEngine
	 */
	public static final function createXmlRewriterTemplateDecorator (CompileableTemplate $innerTemplateInstance) {
		// Get a new instance
		$templateInstance = new XmlRewriterTemplateDecorator();

		// Set the inner template engine
		$templateInstance->setTemplateInstance($innerTemplateInstance);

		// Return the prepared instance
		return $templateInstance;
	}

	/**
	 * Settter for variable group
	 *
	 * @param	$groupName	Name of variable group
	 * @param	$add		Wether add this group
	 * @return	void
	 */
	public function setVariableGroup ($groupName, $add = true) {
		// Call the inner class' method
		$this->getTemplateInstance()->setVariableGroup($groupName, $add);
	}

	/**
	 * Adds a variable to current group
	 *
	 * @param	$var	Variable to set
	 * @param	$value	Value to store in variable
	 * @return	void
	 */
	public function addGroupVariable ($var, $value) {
		// Call the inner class' method
		$this->getTemplateInstance()->addGroupVariable($var, $value);
	}

	/**
	 * Setter for base path
	 *
	 * @param	$templateBasePath	The relative base path for all templates
	 * @return	void
	 */
	public final function setTemplateBasePath ($templateBasePath) {
		// Call the inner class' method
		$this->getTemplateInstance()->setTemplateBasePath($templateBasePath);
	}

	/**
	 * Getter for base path
	 *
	 * @return	$templateBasePath	The relative base path for all templates
	 */
	public final function getTemplateBasePath () {
		// Call the inner class' method
		return $this->getTemplateInstance()->getTemplateBasePath();
	}

	/**
	 * Getter for generic base path
	 *
	 * @return	$templateBasePath	The relative base path for all templates
	 */
	public final function getGenericBasePath () {
		// Call the inner class' method
		return $this->getTemplateInstance()->getGenericBasePath();
	}

	/**
	 * Setter for template extension
	 *
	 * @param	$templateExtension	The file extension for all uncompiled templates
	 * @return	void
	 */
	public final function setRawTemplateExtension ($templateExtension) {
		// Call the inner class' method
		$this->getTemplateInstance()->setRawTemplateExtension($templateExtension);
	}

	/**
	 * Setter for code template extension
	 *
	 * @param	$codeExtension	The file extension for all uncompiled templates
	 * @return	void
	 */
	public final function setCodeTemplateExtension ($codeExtension) {
		// Call the inner class' method
		$this->getTemplateInstance()->setCodeTemplateExtension($codeExtension);
	}

	/**
	 * Getter for template extension
	 *
	 * @return	$templateExtension	The file extension for all uncompiled templates
	 */
	public final function getRawTemplateExtension () {
		// Call the inner class' method
		return $this->getTemplateInstance()->getRawTemplateExtension();
	}

	/**
	 * Getter for code-template extension
	 *
	 * @return	$codeExtension	The file extension for all code templates
	 */
	public final function getCodeTemplateExtension () {
		// Call the inner class' method
		return $this->getTemplateInstance()->getCodeTemplateExtension();
	}

	/**
	 * Setter for path of compiled templates
	 *
	 * @param	$compileOutputPath	The local base path for all compiled templates
	 * @return	void
	 */
	public final function setCompileOutputPath ($compileOutputPath) {
		// Call the inner class' method
		$this->getTemplateInstance()->setCompileOutputPath($compileOutputPath);
	}

	/**
	 * Getter for template type
	 *
	 * @return	$templateType	The current template's type
	 */
	public final function getTemplateType () {
		// Call the inner class' method
		return $this->getTemplateInstance()->getTemplateType();
	}

	/**
	 * Assign (add) a given variable with a value
	 *
	 * @param	$var	The variable we are looking for
	 * @param	$value	The value we want to store in the variable
	 * @return	void
	 * @throws	EmptyVariableException	If the variable name is left empty
	 */
	public final function assignVariable ($var, $value) {
		// Call the inner class' method
		$this->getTemplateInstance()->assignVariable($var, $value);
	}

	/**
	 * Removes a given variable
	 *
	 * @param	$var	The variable we are looking for
	 * @return	void
	 */
	public final function removeVariable ($var) {
		// Call the inner class' method
		$this->getTemplateInstance()->removeVariable($var);
	}

	/**
	 * Getter for compiled templates
	 *
	 * @return	$compiledData	Compiled template data
	 */
	public final function getCompiledData () {
		// Call the inner class' method
		return $this->getTemplateInstance()->getCompiledData();
	}

	/**
	 * Load a specified web template into the engine
	 *
	 * @param	$template	The web template we shall load which is located in
	 *						'html' by default
	 * @return	void
	 */
	public function loadWebTemplate ($template) {
		// Call the inner class' method
		$this->getTemplateInstance()->loadWebTemplate($template);
	}

	/**
	 * Assign a given congfiguration variable with a value
	 *
	 * @param	$var	The configuration variable we want to assign
	 * @return	void
	 */
	public function assignConfigVariable ($var) {
		// Call the inner class' method
		$this->getTemplateInstance()->assignConfigVariable($var);
	}

	/**
	 * Load a specified code template into the engine
	 *
	 * @param	$template	The code template we shall load which is
	 *						located in 'code' by default
	 * @return	void
	 */
	public function loadCodeTemplate ($template) {
		// Call the inner class' method
		$this->getTemplateInstance()->loadCodeTemplate($template);
	}

	/**
	 * Compiles configuration place-holders in all variables. This 'walks'
	 * through the variable stack 'general'. It interprets all values from that
	 * variables as configuration entries after compiling them.
	 *
	 * @return	void
	 */
	public final function compileConfigInVariables () {
		// Call the inner class' method
		$this->getTemplateInstance()->compileConfigInVariables();
	}

	/**
	 * Compile all variables by inserting their respective values
	 *
	 * @return	void
	 */
	public final function compileVariables () {
		// Call the inner class' method
		$this->getTemplateInstance()->compileVariables();
	}

	/**
	 * Compile all required templates into the current loaded one
	 *
	 * @return	void
	 */
	public function compileTemplate () {
		// Call the inner class' method
		$this->getTemplateInstance()->compileTemplate();
	}

	/**
	 * Assigns the last loaded raw template content with a given variable
	 *
	 * @param	$templateName	Name of the template we want to assign
	 * @param	$variableName	Name of the variable we want to assign
	 * @return	void
	 */
	public function assignTemplateWithVariable ($templateName, $variableName) {
		// Call the inner class' method
		$this->getTemplateInstance()->assignTemplateWithVariable($templateName, $variableName);
	}

	/**
	 * Transfers the content of this template engine to a given response instance
	 *
	 * @param	$responseInstance	An instance of a response class
	 * @return	void
	 */
	public function transferToResponse (Responseable $responseInstance) {
		// Call the inner class' method
		$this->getTemplateInstance()->transportToResponse($responseInstance);
	}

	/**
	 * Assigns all the application data with template variables
	 *
	 * @param	$appInstance	A manageable application instance
	 * @return	void
	 */
	public function assignApplicationData (ManageableApplication $appInstance) {
		// Call the inner class' method
		$this->getTemplateInstance()->assignApplicationData($appInstance);
	}

	/**
	 * "Compiles" a variable by replacing {?var?} with it's content
	 *
	 * @param	$rawCode			Raw code to compile
	 * @param	$setMatchAsCode		Sets $match if readVariable() returns empty result
	 * @return	$rawCode	Compile code with inserted variable value
	 */
	public function compileRawCode ($rawCode, $setMatchAsCode=false) {
		return $this->getTemplateInstance()->compileRawCode($rawCode, $setMatchAsCode);
	}

	/**
	 * Getter for variable group array
	 *
	 * @return	$vargroups	All variable groups
	 */
	public final function getVariableGroups () {
		// Call the inner class' method
		return $this->getTemplateInstance()->getVariableGroups();
	}

	/**
	 * Renames a variable in code and in stack
	 *
	 * @param	$oldName	Old name of variable
	 * @param	$newName	New name of variable
	 * @return	void
	 */
	public function renameVariable ($oldName, $newName) {
		// Call the inner class' method
		$this->getTemplateInstance()->renameVariable($oldName, $newName);
	}

	/**
	 * Renders the given XML content
	 *
	 * @param	$content	Valid XML content or if not set the current loaded raw content
	 * @return	void
	 * @throws	XmlParserException	If an XML error was found
	 */
	public function renderXmlContent ($content = null) {
		// Call the inner class' method
		$this->getTemplateInstance()->renderXmlContent($content);
	}

	/**
	 * Enables or disables language support
	 *
	 * @param	$languageSupport	New language support setting
	 * @return	void
	 */
	public final function enableLanguageSupport ($languageSupport = true) {
		// Call the inner class' method
		$this->getTemplateInstance()->enableLanguageSupport($languageSupport);
	}

	/**
	 * Checks wether language support is enabled
	 *
	 * @return	$languageSupport	Wether language support is enabled or disabled
	 */
	public final function isLanguageSupportEnabled () {
		// Call the inner class' method
		return $this->getTemplateInstance()->isLanguageSupportEnabled();
	}

	/**
	 * Enables or disables XML compacting
	 *
	 * @param	$xmlCompacting	New XML compacting setting
	 * @return	void
	 */
	public final function enableXmlCompacting ($xmlCompacting = true) {
		// Call the inner class' method
		$this->getTemplateInstance()->enableXmlCompacting($xmlCompacting);
	}

	/**
	 * Checks wether XML compacting is enabled
	 *
	 * @return	$xmlCompacting	Wether XML compacting is enabled or disabled
	 */
	public final function isXmlCompactingEnabled () {
		// Call the inner class' method
		return $this->getTemplateInstance()->isXmlCompactingEnabled();
	}

	/**
	 * Handles the start element of an XML resource
	 *
	 * @param	$resource		XML parser resource (currently ignored)
	 * @param	$element		The element we shall handle
	 * @param	$attributes		All attributes
	 * @return	void
	 * @throws	InvalidXmlNodeException		If an unknown/invalid XML node name was found
	 */
	public function startElement ($resource, $element, array $attributes) {
		// Call the inner class' method
		$this->getTemplateInstance()->startElement($resource, $element, $attributes);
	}

	/**
	 * Ends the main or sub node by sending out the gathered data
	 *
	 * @param	$resource	An XML resource pointer (currently ignored)
	 * @param	$nodeName	Name of the node we want to finish
	 * @return	void
	 * @throws	XmlNodeMismatchException	If current main node mismatches the closing one
	 */
	public function endElement ($resource, $nodeName) {
		// Call the inner class' method
		$this->getTemplateInstance()->endElement($resource, $nodeName);
	}

	/**
	 * Currently not used
	 *
	 * @param	$resource		XML parser resource (currently ignored)
	 * @param	$characters		Characters to handle
	 * @return	void
	 * @todo	Find something useful with this!
	 */
	public function characterHandler ($resource, $characters) {
		// Call the inner class' method but trim the characters before
		$this->getTemplateInstance()->characterHandler($resource, trim($characters));
	}

	/**
	 * Removes all comments, tabs and new-line charcters to compact the content
	 *
	 * @param	$uncompactedContent		The uncompacted content
	 * @return	$compactedContent		The compacted content
	 */
	public function compactContent ($uncompactedContent) {
		// Compact it ...
		$compactedContent = $this->getTemplateInstance()->compactContent($uncompactedContent);

		// ... and return it
		return $compactedContent;
	}
}

// [EOF]
?>