eZPublish  3.8
eZTemplate Class Reference

The main manager for templates. More...

Public Member Functions

 appendDebugNodes (&$root, &$resourceData)
 
 appendElement (&$text, &$item, $nspace, $name)
 
 appendElementText (&$textElements, &$item, $nspace, $name)
 
 attributeValue (&$data, $nspace)
 
 autoload ()
 
 autoloadPathList ()
 
 canCompileTemplate (&$resourceData, &$extraParameters)
 
 compileTemplate (&$resourceData, &$extraParameters)
 
 compileTemplateFile ($file, $returnResourceData=false)
 
 createLocalVariablesList ()
 
 destroyLocalVariablesList ()
 
 display ($template=false, $extraParameters=false)
 
 doFunction (&$name, &$func_obj, $nspace, $current_nspace)
 
 doOperator (&$element, &$namespace, &$current_nspace, &$value, &$operatorName, &$operatorParameters, &$named_params)
 
elementValue (&$dataElements, $rootNamespace, $currentNamespace, $placement=false, $checkExistance=false, $checkForProxy=false)
 
 emptyVariable ()
 
 error ($name, $txt, $placement=false)
 
 errorCount ()
 
 errorLog ()
 
 executeCompiledTemplate (&$resourceData, &$textElements, $rootNamespace, $currentNamespace, &$extraParameters)
 
 expandAttributes ($attributeList, $chooseText, $maxThreshold, $minThreshold=1)
 
 extraParameters ($name, $count, $maxCount)
 
 eZTemplate ()
 
fetch ($template=false, $extraParameters=false, $returnResourceData=false)
 
 fetchFunctionObject ($functionName)
 
 hasChildren (&$function, $functionName)
 
 hasErrors ()
 
 hasLocalVariable ($varName, $rootNamespace)
 
 hasVariable ($var, $namespace="", $attrs=array())
 
 hasWarnings ()
 
ini ()
 
instance ()
 
 isCachingAllowed ()
 
 leftDelimiter ()
 
load ($uri, $extraParameters=false, $returnResourceData=false)
 
 loadAndRegisterFunctions ($functionDefinition)
 
 loadAndRegisterOperators ($operatorDefinition)
 
loadURIData (&$resourceObject, $uri, $resourceName, $template, &$extraParameters, $displayErrors=true)
 
loadURIRoot ($uri, $displayErrors=true, &$extraParameters)
 
 missingParameter ($name, $param)
 
 operatorInputSupported ($operatorName)
 
 operatorParameterList ($name)
 
 parse (&$sourceText, &$rootElement, $rootNamespace, &$resourceData)
 
 placementText ($placement=false)
 
 process (&$root, &$text, $rootNamespace, $currentNamespace)
 
 processFunction ($functionName, &$textElements, $functionChildren, $functionParameters, $functionPlacement, $rootNamespace, $currentNamespace)
 
 processNode (&$node, &$textElements, $rootNamespace, $currentNamespace)
 
 processOperator ($operatorName, $operatorParameters, $rootNamespace, $currentNamespace, &$valueData, $placement=false, $checkExistance=false)
 
 processURI ($uri, $displayErrors=true, &$extraParameters, &$textElements, $rootNamespace, $currentNamespace)
 
 processVariable (&$textElements, $variableData, $variablePlacement, $rootNamespace, $currentNamespace)
 
 registerAutoloadFunctions ($functionDefinition)
 
 registerAutoloadOperators ($operatorDefinition)
 
 registerFilter ()
 
 registerFunction ($func_name, &$func_obj)
 
 registerFunctions (&$functionObject)
 
 registerLiteral ($func_name)
 
 registerOperator ($op_name, &$op_obj)
 
 registerOperators (&$operatorObject)
 
 registerOperatorsInternal (&$operatorObject, $debug=false)
 
 registerResource (&$res)
 
 reset ()
 
 resetElements ()
 
 resetErrorLog ()
 
 resetVariables ()
 
resourceFor (&$uri, &$res, &$template)
 
resourceHandler ($resourceName)
 
 rightDelimiter ()
 
 setAutoloadPathList ($pathList)
 
 setCompileTest ($val)
 
 setIncludeOutput ($uri, &$output)
 
 setIncludeText ($uri, &$text)
 
 setIsCachingAllowed ($allowed)
 
 setLeftDelimiter ($delim)
 
 setLocalVariable ($varName, $varValue, $rootNamespace)
 
 setRightDelimiter ($delim)
 
 setShowDetails ($show)
 
 setVariable ($var, $val, $namespace="")
 
 setVariableRef ($var, &$val, $namespace="")
 
 testCompile ()
 
 undefinedFunction ($func_name)
 
 undefinedVariable ($name, $var)
 
 unregisterLiteral ($func_name)
 
 unregisterOperator ($op_name)
 
 unregisterResource ($res_name)
 
 unsetLocalVariable ($varName, $rootNamespace)
 
 unsetLocalVariables ()
 
 unsetVariable ($var, $namespace="")
 
 validateTemplateFile ($file, $returnResourceData=false)
 
variable ($var, $namespace="", $attrs=array())
 
variableAttribute (&$var, $attrs)
 
variableElementValue (&$data, $def_nspace)
 
 variableText ($var, $namespace="", $attrs=array())
 
 warning ($name, $txt, $placement=false)
 
 warningCount ()
 
 warningLog ()
 

Static Public Member Functions

 appendTemplateToStatistics (&$templateName, &$templateFileName)
 
 appendTemplateToStatisticsIfNeeded (&$templateName, &$templateFileName)
 
 isDebugEnabled ()
 
 isMethodDebugEnabled ()
 
 isTemplatesUsageStatisticsEnabled ()
 
 isXHTMLCodeIncluded ()
 
 mergeNamespace ($rootNamespace, $additionalNamespace)
 
 resourceData (&$resourceObject, $uri, $resourceName, $templateName)
 
 setIsDebugEnabled ($debug)
 
 setIsTemplatesUsageStatisticsEnabled ($enabled)
 
templatesUsageStatistics ()
 

Private Member Functions

 registerFunctionsInternal (&$functionObject, $debug=false)
 

Private Attributes

 $AutoloadPathList
 
 $CurrentLocalVariablesNames
 
 $DefaultResource
 Reference to the default resource object. More...
 
 $DoCounter
 
 $ElseifCounter
 
 $ErrorLog
 Array containing all errors occured during a fetch. More...
 
 $ForCounter
 
 $ForeachCounter
 
 $FunctionAttributes
 An associative array of function attributes. More...
 
 $Functions
 An associative array of functions. More...
 
 $IncludeOutput
 Included outputs, usually performed by custom functions. More...
 
 $IncludeText
 Included texts, usually performed by custom functions. More...
 
 $IsCachingAllowed
 true if caching is allowed More...
 
 $LDelim
 The left delimiter used for parsing. More...
 
 $Level = 0
 include level More...
 
 $Literals
 An associative array of literal tags. More...
 
 $LocalVariablesNamesStack
 
 $MaxLevel = 40
 
 $Operators
 An associative array of operators. More...
 
 $RDelim
 The right delimiter used for parsing. More...
 
 $Resources
 Associative array of resource objects. More...
 
 $ShowDetails = false
 True if output details is to be shown. More...
 
 $TemplatesUsageStatistics
 A list of templates used by a rendered page. More...
 
 $TestCompile
 
 $Text
 The original template text. More...
 
 $TimeStamp
 The timestamp of the template when it was last modified. More...
 
 $Tree
 The resulting object tree of the template. More...
 
 $Variables
 An associative array of template variables. More...
 
 $WarningLog
 Array containing all warnings occured during a fetch. More...
 
 $WhileCounter
 

Detailed Description

The main manager for templates.

The template systems allows for separation of code and layout by moving the layout part into template files. These template files are parsed and processed with template variables set by the PHP code.

The template system in itself is does not do much, it parses template files according to a rule set sets up a tree hierarchy and process the data using functions and operators. The standard template system comes with only a few functions and no operators, it is meant for these functions and operators to be specified by the users of the template system. But for simplicity a few help classes is available which can be easily enabled.

The classes are:

To enable these functions and operator use registerFunction and registerOperator.

In keeping with the spirit of being simple the template system does not know how to get the template files itself. Instead it relies on resource handlers, these handlers fetches the template files using different kind of transport mechanism. For simplicity a default resource class is available, eZTemplateFileResource fetches templates from the filesystem.

The parser process consists of three passes, each pass adds a new level of complexity. The first pass strips text from template blocks which starts with a left delimiter and ends with a right delimiter (default is { and } ), and places them in an array. The second pass iterates the text and block elements and removes newlines from text before function blocks and text after function blocks. The third pass builds the tree according the function rules.

Processing is done by iterating over the root of the tree, if a text block is found the text is appended to the result text. If a variable or contant is it's data is extracted and any operators found are run on it before fetching the result and appending it to the result text. If a function is found the function is called with the parameters and it's up to the function handle children if any.

Constants and template variables will usually be called variables since there's little difference. A template variable expression will start with a $ and consists of a namespace (optional) a name and attribues(optional). The variable expression

$root:var.attr1 

exists in the "root" namespace, has the name "var" and uses the attribute "attr1". Some functions will create variables on demand, to avoid name conflicts namespaces were introduced, each function will place the new variables in a namespace specified in the template file. Attribues are used for fetching parts of the variable, for instance an element in an array or data in an object. Since the syntax is the same for arrays and objects the PHP code can use simple arrays when speed is required, the template code will not care. A different syntax is also available when you want to access an attribute using a variable. For instance

$root:var[$attr_var] 

, if the variable $attr_var contains "attr1" it would access the same attribute as in the first example.

The syntax for operators is a | and a name, optionally parameters can be specified with ( and ) delimited with ,. Valid operators are

|upcase, |l10n(date) 

.

Functions look a lot like HTML/XML tags. The function consists of a name and parameters which are assigned using the param=value syntax. Some parameters may be required while others may be optionally, the exact behaviour is specified by each function. Valid functions are

"section name=abc loop=4" 

Example of usage:

// Init template
$tpl->registerOperators( new eZTemplatePHPOperator( array( "upcase" => "strtoupper",
"reverse" => "strrev" ) ) );
$tpl->registerOperators( new eZTemplateLocaleOperator() );
$tpl->registerFunction( "section", new eZTemplateSectionFunction( "section" ) );
$tpl->registerFunctions( new eZTemplateDelimitFunction() );
$tpl->setVariable( "my_var", "{this value set by variable}", "test" );
$tpl->setVariable( "my_arr", array( "1st", "2nd", "third", "fjerde" ) );
$tpl->setVariable( "multidim", array( array( "a", "b" ),
array( "c", "d" ),
array( "e", "f" ),
array( "g", "h" ) ) );
class mytest
{
function mytest( $n, $s )
{
$this->n = $n;
$this->s = $s;
}
function hasAttribute( $attr )
{
return ( $attr == "name" || $attr == "size" );
}
function &attribute( $attr )
{
switch ( $attr )
{
case "name";
return $this->n;
case "size";
return $this->s;
default:
$retAttr = null;
return $retAttr;
}
}
};
$tpl->setVariable( "multidim_obj", array( new mytest( "jan", 200 ),
new mytest( "feb", 200 ),
new mytest( "john", 200 ),
new mytest( "doe", 50 ) ) );
$tpl->setVariable( "curdate", mktime() );
$tpl->display( "lib/eztemplate/example/test.tpl" );
// test.tpl
{section name=outer loop=4}
123
{delimit}::{/delimit}
{/section}
{literal test=1} This is some {blah arg1="" arg2="abc" /} {/literal}
<title>This is a test</title>
<table border="1">
<tr><th>{$test:my_var}
{"some text!!!"|upcase|reverse}</th></tr>
{section name=abc loop=$my_arr}
<tr><td>{$abc:item}</td></tr>
{/section}
</table>
<table border="1">
{section name=outer loop=$multidim}
<tr>
{section name=inner loop=$outer:item}
<td>{$inner:item}</td>
{/section}
</tr>
{/section}
</table>
<table border="1">
{section name=outer loop=$multidim_obj}
<tr>
<td>{$outer:item.name}</td>
<td>{$outer:item.size}</td>
</tr>
{/section}
</table>
{section name=outer loop=$nonexistingvar}
<b><i>Dette skal ikke vises</b></i>
{section-else}
<b><i>This is shown when the {ldelim}$loop{rdelim} variable is non-existant</b></i>
{/section}
Denne koster {1.4|l10n(currency)}<br>
{-123456789|l10n(number)}<br>
{$curdate|l10n(date)}<br>
{$curdate|l10n(shortdate)}<br>
{$curdate|l10n(time)}<br>
{$curdate|l10n(shorttime)}<br>
{include file="test2.tpl"/}

Member Function Documentation

eZTemplate::appendDebugNodes ( $root,
$resourceData 
)

Creates some text nodes before and after the children of $root. It will extract the current filename and uri and create some XHTML comments and inline text.

See Also
isXHTMLCodeIncluded

Referenced by compileTemplateFile(), loadURIRoot(), and validateTemplateFile().

eZTemplate::appendElement ( $text,
$item,
  $nspace,
  $name 
)
eZTemplate::appendElementText ( $textElements,
$item,
  $nspace,
  $name 
)

Referenced by appendElement(), and processVariable().

eZTemplate::appendTemplateToStatistics ( $templateName,
$templateFileName 
)
static

Appends template info to stats.

Referenced by appendTemplateToStatisticsIfNeeded().

eZTemplate::appendTemplateToStatisticsIfNeeded ( $templateName,
$templateFileName 
)
static

Checks settings and if 'ShowUsedTemplates' is enabled appends template info to stats.

Referenced by loadURIRoot().

eZTemplate::attributeValue ( $data,
  $nspace 
)

Return the identifier used for attribute lookup.

Referenced by variableElementValue().

eZTemplate::autoload ( )

Looks trough the pathes specified in autoloadPathList() and fetches autoload definition files used for autoloading functions and operators.

eZTemplate::autoloadPathList ( )
Returns
the path list which is used for autoloading functions and operators.

Referenced by autoload().

eZTemplate::canCompileTemplate ( $resourceData,
$extraParameters 
)

Referenced by loadURIRoot().

eZTemplate::compileTemplate ( $resourceData,
$extraParameters 
)

Referenced by loadURIRoot().

eZTemplate::compileTemplateFile (   $file,
  $returnResourceData = false 
)

Compiles the template file $file and returns true if the compilation was OK.

Parameters
$returnResourceDataIf true then the returned value will be the resourcedata structure
See Also
validateTemplateFile(), fetch()
eZTemplate::createLocalVariablesList ( )

Initialize list of local variables for the current template. The list contains only names of variables.

Referenced by process().

eZTemplate::destroyLocalVariablesList ( )

Destroy list of local variables defined in the current (innermost) template.

Referenced by process().

eZTemplate::display (   $template = false,
  $extraParameters = false 
)

Fetches the result of the template file and displays it. If $template is supplied it will load this template file first.

eZTemplate::doFunction ( $name,
$func_obj,
  $nspace,
  $current_nspace 
)

Tries to run the function object $func_obj

eZTemplate::doOperator ( $element,
$namespace,
$current_nspace,
$value,
$operatorName,
$operatorParameters,
$named_params 
)

Tries to run the operator $operatorName with parameters $operatorParameters on the value $value.

& eZTemplate::elementValue ( $dataElements,
  $rootNamespace,
  $currentNamespace,
  $placement = false,
  $checkExistance = false,
  $checkForProxy = false 
)

Returns the actual value of a template type or null if an unknown type.

Referenced by attributeValue(), processOperator(), and processVariable().

eZTemplate::emptyVariable ( )

Returns the empty variable type.

eZTemplate::error (   $name,
  $txt,
  $placement = false 
)

Displays an error for the function/operator $name and text $txt.

Referenced by attributeValue(), elementValue(), processOperator(), registerAutoloadFunctions(), registerAutoloadOperators(), undefinedFunction(), and variableElementValue().

eZTemplate::errorCount ( )
Returns
The number of errors that occured with the last fetch
See Also
hasErrors()

Referenced by hasErrors().

eZTemplate::errorLog ( )
Returns
error log.
See Also
errorCount()
eZTemplate::executeCompiledTemplate ( $resourceData,
$textElements,
  $rootNamespace,
  $currentNamespace,
$extraParameters 
)

Referenced by fetch(), and processURI().

eZTemplate::expandAttributes (   $attributeList,
  $chooseText,
  $maxThreshold,
  $minThreshold = 1 
)

Referenced by elementValue().

eZTemplate::extraParameters (   $name,
  $count,
  $maxCount 
)

Outputs a warning about the parameter count being to high for function/operator $name.

eZTemplate::eZTemplate ( )

Intializes the template with left and right delimiters being { and }, and a file resource. The literal tag "literal" is also registered.

Referenced by instance().

& eZTemplate::fetch (   $template = false,
  $extraParameters = false,
  $returnResourceData = false 
)

Tries to fetch the result of the template file and returns it. If $template is supplied it will load this template file first.

Referenced by display().

eZTemplate::fetchFunctionObject (   $functionName)
eZTemplate::hasChildren ( $function,
  $functionName 
)
eZTemplate::hasErrors ( )
Returns
\ true if errors occured with the last fetch.
See Also
errorCount()

Referenced by validateTemplateFile().

eZTemplate::hasLocalVariable (   $varName,
  $rootNamespace 
)

Check if the given local variable exists.

Referenced by unsetLocalVariable().

eZTemplate::hasVariable (   $var,
  $namespace = "",
  $attrs = array() 
)

Returns true if the variable $var is set in namespace $namespace, if $attrs is supplied alle attributes must exist for the function to return true.

Referenced by elementValue(), and variableElementValue().

eZTemplate::hasWarnings ( )
Returns
\ true if warnings occured with the last fetch.
See Also
warningCount()

Referenced by validateTemplateFile().

& eZTemplate::ini ( )

Returns the INI object for the template.ini file.

Referenced by error().

& eZTemplate::instance ( )

Returns the globale template instance, creating it if it does not exist.

Referenced by appendTemplateToStatistics(), templateInit(), and templatesUsageStatistics().

eZTemplate::isCachingAllowed ( )
Returns
true if caching is allowed (default) or false otherwise. This also affects template compiling.
See Also
setIsCachingAllowed

Referenced by loadURIRoot().

eZTemplate::isDebugEnabled ( )
static
Returns
true if debugging of internals is enabled, this will display which files are loaded and when cache files are created. Set the option with setIsDebugEnabled().

Referenced by compileTemplateFile(), fetch(), eZTemplateFileResource\handleResourceData(), loadURIRoot(), processURI(), resourceFor(), and validateTemplateFile().

eZTemplate::isMethodDebugEnabled ( )
static
Returns
true if debug output of template functions and operators should be enabled.

Referenced by processFunction(), and processOperator().

eZTemplate::isTemplatesUsageStatisticsEnabled ( )
static
Returns
true if templates usage statistics should be enabled.

Referenced by appendTemplateToStatisticsIfNeeded(), and eZTemplatesStatisticsReporter\generateStatistics().

eZTemplate::isXHTMLCodeIncluded ( )
static
Returns
true if special XHTML code should be included before the included template file. This code will display the template filename in the browser but will eventually break the design.

Referenced by appendDebugNodes().

eZTemplate::leftDelimiter ( )

Returns the left delimiter being used.

& eZTemplate::load (   $uri,
  $extraParameters = false,
  $returnResourceData = false 
)

Loads the template using the URI $uri and parses it.

Returns
The root node of the tree if $returnResourceData is false, if true the entire resource data structure.
eZTemplate::loadAndRegisterFunctions (   $functionDefinition)
eZTemplate::loadAndRegisterOperators (   $operatorDefinition)
& eZTemplate::loadURIData ( $resourceObject,
  $uri,
  $resourceName,
  $template,
$extraParameters,
  $displayErrors = true 
)

Referenced by loadURIRoot().

& eZTemplate::loadURIRoot (   $uri,
  $displayErrors = true,
$extraParameters 
)

Loads the template using the URI $uri and returns a structure with the text and timestamp, false otherwise. The structure keys are:

  • "text", the text.
  • "time-stamp", the timestamp.

Referenced by fetch(), load(), and processURI().

eZTemplate::mergeNamespace (   $rootNamespace,
  $additionalNamespace 
)
static

Referenced by elementValue().

eZTemplate::missingParameter (   $name,
  $param 
)

Outputs a warning about the parameter $param missing for function/operator $name.

eZTemplate::operatorInputSupported (   $operatorName)
eZTemplate::operatorParameterList (   $name)

Returns the named parameter list for the operator $name.

Referenced by processOperator().

eZTemplate::parse ( $sourceText,
$rootElement,
  $rootNamespace,
$resourceData 
)
eZTemplate::placementText (   $placement = false)

Creates a string for the placement information and returns it.

Note
The placement information can either be in indexed or associative

Referenced by error(), and warning().

eZTemplate::process ( $root,
$text,
  $rootNamespace,
  $currentNamespace 
)

Referenced by fetch(), and processURI().

eZTemplate::processFunction (   $functionName,
$textElements,
  $functionChildren,
  $functionParameters,
  $functionPlacement,
  $rootNamespace,
  $currentNamespace 
)

Referenced by processNode().

eZTemplate::processNode ( $node,
$textElements,
  $rootNamespace,
  $currentNamespace 
)

Referenced by process().

eZTemplate::processOperator (   $operatorName,
  $operatorParameters,
  $rootNamespace,
  $currentNamespace,
$valueData,
  $placement = false,
  $checkExistance = false 
)

Referenced by elementValue().

eZTemplate::processURI (   $uri,
  $displayErrors = true,
$extraParameters,
$textElements,
  $rootNamespace,
  $currentNamespace 
)
eZTemplate::processVariable ( $textElements,
  $variableData,
  $variablePlacement,
  $rootNamespace,
  $currentNamespace 
)

Referenced by processNode().

eZTemplate::registerAutoloadFunctions (   $functionDefinition)

Referenced by autoload().

eZTemplate::registerAutoloadOperators (   $operatorDefinition)

Referenced by autoload().

eZTemplate::registerFilter ( )

Not implemented yet.

eZTemplate::registerFunction (   $func_name,
$func_obj 
)

Registers the function $func_name to be bound to object $func_obj. If the object has a function called attributeList() it is used for registering function attributes. The function returns an associative array with each key being the name of the function and the value being a boolean. If the boolean is true the function will have children.

eZTemplate::registerFunctions ( $functionObject)

Registers the functions supplied by the object $functionObject. The object must have a function called functionList() which returns an array of functions this object handles. If the object has a function called attributeList() it is used for registering function attributes. The function returns an associative array with each key being the name of the function and the value being a boolean. If the boolean is true the function will have children.

eZTemplate::registerFunctionsInternal ( $functionObject,
  $debug = false 
)
private
eZTemplate::registerLiteral (   $func_name)

Registers a new literal tag in which the tag will be transformed into a text element.

Referenced by eZTemplate().

eZTemplate::registerOperator (   $op_name,
$op_obj 
)

Registers the operator $op_name to use the object $op_obj.

eZTemplate::registerOperators ( $operatorObject)

Registers the operators supplied by the object $operatorObject. The function operatorList() must return an array of operator names.

eZTemplate::registerOperatorsInternal ( $operatorObject,
  $debug = false 
)
eZTemplate::registerResource ( $res)

Registers a new resource object $res. The resource object take care of fetching templates using an URI.

Referenced by eZTemplate().

eZTemplate::reset ( )

Resets all template variables, functions, operators and error counts.

Referenced by display().

eZTemplate::resetElements ( )

Resets all template functions and operators by calling the resetFunction and resetOperator on all elements that supports it.

Referenced by reset().

eZTemplate::resetErrorLog ( )

Reset error and warning logs

Referenced by compileTemplateFile(), eZTemplate(), fetch(), reset(), and validateTemplateFile().

eZTemplate::resetVariables ( )

Resets all template variables.

Referenced by reset().

eZTemplate::resourceData ( $resourceObject,
  $uri,
  $resourceName,
  $templateName 
)
static

Creates a resource data structure of the parameters and returns it. This structure is passed to various parts of the template system.

Note
If you only have the URI you should call resourceFor() first to figure out the resource handler.

Referenced by compileTemplateFile(), loadURIData(), and validateTemplateFile().

& eZTemplate::resourceFor ( $uri,
$res,
$template 
)

Returns the resource object for URI $uri. If a resource type is specified in the URI it is extracted and set in $res. The template name is set in $template without any resource specifier. To specify a resource the name and a ":" is prepended to the URI, for instance file:my.tpl. If no resource type is found the URI the default resource handler is used.

Referenced by compileTemplateFile(), loadURIRoot(), and validateTemplateFile().

& eZTemplate::resourceHandler (   $resourceName)
Returns
The resource handler object for resource name $resourceName.
See Also
resourceFor
eZTemplate::rightDelimiter ( )

Returns the right delimiter being used.

eZTemplate::setAutoloadPathList (   $pathList)

Sets the path list for autoloading.

eZTemplate::setCompileTest (   $val)

Set template compilation test mode.

Parameters
true,willset template compilation in test mode ( no disc writes ). false, will compile templates to disc
eZTemplate::setIncludeOutput (   $uri,
$output 
)

Sets the output for uri $uri to $output.

Referenced by processURI().

eZTemplate::setIncludeText (   $uri,
$text 
)

Sets the original text for uri $uri to $text.

Referenced by loadURIRoot().

eZTemplate::setIsCachingAllowed (   $allowed)

Sets whether caching/compiling is allowed or not. This is useful if you need to make sure templates are parsed and processed without any caching mechanisms.

Note
The default is to allow caching.
See Also
isCachingAllowed
eZTemplate::setIsDebugEnabled (   $debug)
static

Sets whether internal debugging is enabled or not.

Referenced by templateInit().

eZTemplate::setIsTemplatesUsageStatisticsEnabled (   $enabled)
static

Sets whether templates usage statistics enabled or not.

Returns
true if templates usage statistics was enabled, otherwise false.
eZTemplate::setLeftDelimiter (   $delim)

Sets the left delimiter.

eZTemplate::setLocalVariable (   $varName,
  $varValue,
  $rootNamespace 
)

Create a local variable.

eZTemplate::setRightDelimiter (   $delim)

Sets the right delimiter.

eZTemplate::setShowDetails (   $show)

Sets whether detail output is used or not. Detail output is useful for debug output where you want to examine the template and the output text.

eZTemplate::setVariable (   $var,
  $val,
  $namespace = "" 
)

Sets the template variable $var to the value $val.

See Also
setVariableRef

Referenced by setLocalVariable().

eZTemplate::setVariableRef (   $var,
$val,
  $namespace = "" 
)

Sets the template variable $var to the value $val.

Note
This sets the variable using reference
See Also
setVariable

Referenced by appendElementText().

& eZTemplate::templatesUsageStatistics ( )
static

Returns template usage statistics

Referenced by eZTemplatesStatisticsReporter\generateStatistics().

eZTemplate::testCompile ( )

Get if template session is test compile

eZTemplate::undefinedFunction (   $func_name)

Outputs an error about the template function $func_name being undefined.

eZTemplate::undefinedVariable (   $name,
  $var 
)

Outputs a warning about the variable $var being undefined.

eZTemplate::unregisterLiteral (   $func_name)

Removes the literal tag $func_name.

eZTemplate::unregisterOperator (   $op_name)

Unregisters the operator $op_name.

eZTemplate::unregisterResource (   $res_name)

Unregisters the resource $res_name.

eZTemplate::unsetLocalVariable (   $varName,
  $rootNamespace 
)

Destroy a local variable.

Referenced by unsetLocalVariables().

eZTemplate::unsetLocalVariables ( )

Destroy all local variables defined in the current template.

Referenced by process().

eZTemplate::unsetVariable (   $var,
  $namespace = "" 
)

Removes the template variable $var. If the variable does not exists an error is output.

Referenced by unsetLocalVariable().

eZTemplate::validateTemplateFile (   $file,
  $returnResourceData = false 
)

Validates the template file $file and returns true if the file has correct syntax.

Parameters
$returnResourceDataIf true then the returned value will be the resourcedata structure
See Also
compileTemplateFile(), fetch()
& eZTemplate::variable (   $var,
  $namespace = "",
  $attrs = array() 
)

Returns the content of the variable $var using namespace $namespace, if $attrs is supplied the result of the attributes is returned.

Referenced by elementValue(), and variableElementValue().

& eZTemplate::variableAttribute ( $var,
  $attrs 
)

Returns the attribute(s) of the template variable $var, $attrs is an array of attribute names to use iteratively for each new variable returned.

& eZTemplate::variableElementValue ( $data,
  $def_nspace 
)

Returns the value of the template variable $data, or null if no defined variable for that name.

eZTemplate::variableText (   $var,
  $namespace = "",
  $attrs = array() 
)

Helper function for creating a displayable text for a variable.

eZTemplate::warning (   $name,
  $txt,
  $placement = false 
)
eZTemplate::warningCount ( )
Returns
The number of warnings that occured with the last fetch
See Also
hasWarnings()

Referenced by hasWarnings().

eZTemplate::warningLog ( )
Returns
waring log.
See Also
warningCount()

Member Data Documentation

eZTemplate::$AutoloadPathList
private

Referenced by autoloadPathList().

eZTemplate::$CurrentLocalVariablesNames
private
eZTemplate::$DefaultResource
private

Reference to the default resource object.

Referenced by resourceFor(), and resourceHandler().

eZTemplate::$DoCounter
private
eZTemplate::$ElseifCounter
private
eZTemplate::$ErrorLog
private

Array containing all errors occured during a fetch.

Referenced by errorLog().

eZTemplate::$ForCounter
private
eZTemplate::$ForeachCounter
private
eZTemplate::$FunctionAttributes
private

An associative array of function attributes.

eZTemplate::$Functions
private

An associative array of functions.

eZTemplate::$IncludeOutput
private

Included outputs, usually performed by custom functions.

eZTemplate::$IncludeText
private

Included texts, usually performed by custom functions.

eZTemplate::$IsCachingAllowed
private

true if caching is allowed

Referenced by isCachingAllowed(), and validateTemplateFile().

eZTemplate::$LDelim
private

The left delimiter used for parsing.

Referenced by leftDelimiter().

eZTemplate::$Level = 0
private

include level

eZTemplate::$Literals
private

An associative array of literal tags.

eZTemplate::$LocalVariablesNamesStack
private

Last element of this stack contains names of all variables created in the innermost template, for them to be destroyed after the template execution finishes.

eZTemplate::$MaxLevel = 40
private
eZTemplate::$Operators
private

An associative array of operators.

eZTemplate::$RDelim
private

The right delimiter used for parsing.

Referenced by rightDelimiter().

eZTemplate::$Resources
private

Associative array of resource objects.

eZTemplate::$ShowDetails = false
private

True if output details is to be shown.

eZTemplate::$TemplatesUsageStatistics
private

A list of templates used by a rendered page.

eZTemplate::$TestCompile
private

Referenced by resourceData(), and testCompile().

eZTemplate::$Text
private

The original template text.

eZTemplate::$TimeStamp
private

The timestamp of the template when it was last modified.

eZTemplate::$Tree
private

The resulting object tree of the template.

eZTemplate::$Variables
private

An associative array of template variables.

eZTemplate::$WarningLog
private

Array containing all warnings occured during a fetch.

Referenced by warningLog().

eZTemplate::$WhileCounter
private

The documentation for this class was generated from the following file: