eZPublishCommunityProject(LegacyStack)  2013.6
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)
 
 appendTemplateFetch ($actualTemplateName)
 
 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 ()
 Singelton instance of eZTemplate used by eZTemplate::instance() Reset with eZTemplate::resetInstance(). More...
 
 fetch ($template=false, $extraParameters=false, $returnResourceData=false)
 
 fetchFunctionObject ($functionName)
 
 hasChildren (&$function, $functionName)
 
 hasErrors ()
 
 hasLocalVariable ($varName, $rootNamespace)
 
 hasVariable ($var, $namespace= '', $attrs=null)
 Returns true if the variable $var is set in namespace $namespace, if $attrs is supplied all attributes must exist for the function to return true. More...
 
 hasWarnings ()
 
 ini ()
 Returns the eZINI object instance for the template.ini file. More...
 
 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= '', $scopeSafe=false)
 Sets the template variable $var to the value $val. More...
 
 templateFetchList ()
 
 testCompile ()
 
 undefinedFunction ($func_name)
 
 undefinedVariable ($name, $var)
 
 unregisterLiteral ($func_name)
 
 unregisterOperator ($op_name)
 
 unregisterResource ($res_name)
 
 unsetLocalVariable ($varName, $rootNamespace)
 
 unsetLocalVariables ()
 
 unsetVariable ($var, $namespace= '')
 Unsets the template variable $var. More...
 
 validateTemplateFile ($file, $returnResourceData=false)
 
 variable ($var, $namespace= '', $attrs=null)
 Returns the content of the variable $var using namespace $namespace, if $attrs is supplied the result of the attributes is returned. More...
 
 variableAttribute ($var, $attrs)
 
 variableText ($var, $namespace="", $attrs=array())
 
 warning ($name, $txt, $placement=false)
 
 warningCount ()
 
 warningLog ()
 

Static Public Member Functions

 appendTemplateToStatistics ($templateName, $templateFileName)
 
 appendTemplateToStatisticsIfNeeded (&$templateName, &$templateFileName)
 
static factory ()
 Returns a shared instance of the eZTemplate class with default settings applied, like: More...
 
static instance ()
 Returns a shared instance of the eZTemplate class. More...
 
static isDebugEnabled ()
 
static isMethodDebugEnabled ()
 
static isTemplatesUsageStatisticsEnabled ()
 
static isXHTMLCodeIncluded ()
 
 mergeNamespace ($rootNamespace, $additionalNamespace)
 
static resetInstance ()
 Reset shared instance of the eZTemplate class and factory flag as used by eZTemplate::instance() and eZTemplate::factory(). More...
 
 resourceData ($resourceObject, $uri, $resourceName, $templateName)
 
static setIsDebugEnabled ($debug)
 
 setIsTemplatesUsageStatisticsEnabled ($enabled)
 
static templatesUsageStatistics ()
 

Public 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
 
const DEBUG_INTERNALS = false
 
const ELEMENT_COMMENT = 6
 
const ELEMENT_END_TAG = 4
 
const ELEMENT_NORMAL_TAG = 3
 
const ELEMENT_SINGLE_TAG = 2
 
const ELEMENT_TEXT = 1
 
const ELEMENT_VARIABLE = 5
 
const FILE_ERRORS = 1
 
const NAMESPACE_SCOPE_GLOBAL = 1
 
const NAMESPACE_SCOPE_LOCAL = 2
 
const NAMESPACE_SCOPE_RELATIVE = 3
 
const NODE_FUNCTION = 4
 
const NODE_INTERNAL = 100
 
const NODE_INTERNAL_CODE_PIECE = 101
 
const NODE_INTERNAL_ERROR = 121
 
const NODE_INTERNAL_NAMESPACE_CHANGE = 103
 
const NODE_INTERNAL_NAMESPACE_RESTORE = 104
 
const NODE_INTERNAL_OUTPUT_ASSIGN = 150
 
const NODE_INTERNAL_OUTPUT_DECREASE = 153
 
const NODE_INTERNAL_OUTPUT_INCREASE = 152
 
const NODE_INTERNAL_OUTPUT_READ = 151
 
const NODE_INTERNAL_OUTPUT_SPACING_INCREASE = 160
 
const NODE_INTERNAL_RESOURCE_ACQUISITION = 140
 
const NODE_INTERNAL_SPACING_DECREASE = 161
 
const NODE_INTERNAL_VARIABLE_SET = 105
 
const NODE_INTERNAL_VARIABLE_UNSET = 102
 
const NODE_INTERNAL_WARNING = 120
 
const NODE_OPERATOR = 5
 
const NODE_OPTIMIZED_INIT = 201
 
const NODE_OPTIMIZED_RESOURCE_ACQUISITION = 141
 
const NODE_ROOT = 1
 
const NODE_TEXT = 2
 
const NODE_USER_CUSTOM = 1000
 
const NODE_VARIABLE = 3
 
const RESOURCE_FETCH = 1
 
const RESOURCE_QUERY = 2
 
const TYPE_ALL = 63
 
const TYPE_ARRAY = 8
 
const TYPE_ATTRIBUTE = 5
 
const TYPE_ATTRIBUTE_BIT = 16
 
const TYPE_BASIC = 47
 
const TYPE_BOOLEAN = 7
 
const TYPE_DYNAMIC_ARRAY = 9
 
const TYPE_IDENTIFIER = 3
 
const TYPE_IDENTIFIER_BIT = 4
 
const TYPE_INTERNAL = 100
 
const TYPE_INTERNAL_CODE_PIECE = 101
 
const TYPE_INTERNAL_STOP = 999
 
const TYPE_MODIFIER_MASK = 48
 
const TYPE_NONE = 0
 
const TYPE_NUMERIC = 2
 
const TYPE_NUMERIC_BIT = 2
 
const TYPE_OPERATOR = 6
 
const TYPE_OPERATOR_BIT = 32
 
const TYPE_OPTIMIZED_ARRAY_LOOKUP = 202
 
const TYPE_OPTIMIZED_ATTRIBUTE_LOOKUP = 204
 
const TYPE_OPTIMIZED_CONTENT_CALL = 203
 
const TYPE_OPTIMIZED_NODE = 201
 
const TYPE_PHP_VARIABLE = 102
 
const TYPE_STRING = 1
 
const TYPE_STRING_BIT = 1
 
const TYPE_VARIABLE = 4
 
const TYPE_VARIABLE_BIT = 8
 
const TYPE_VOID = 0
 

Static Protected Attributes

static $factory = false
 
static $instance
 

Private Member Functions

 registerFunctionsInternal ($functionObject, $debug=false)
 

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", time() );
$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 border="1">
{section name=outer loop=$multidim}
<tr>
{section name=inner loop=$outer:item}
<td>{$inner:item}</td>
{/section}
</tr>
{/section}
<table border="1">
{section name=outer loop=$multidim_obj}
<tr>
<td>{$outer:item.name}</td>
<td>{$outer:item.size}</td>
</tr>
{/section}
{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::appendTemplateFetch (   $actualTemplateName)

Appends template info for current fetch.

Referenced by loadURIRoot().

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.

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(), and undefinedFunction().

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.

null eZTemplate::eZTemplate ( )

Singelton instance of eZTemplate used by eZTemplate::instance() Reset with eZTemplate::resetInstance().

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(), eZNodeviewfunctions\generateNodeViewData(), and eZStepRegistration\generateRegistration().

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 = null 
)

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

Parameters
string$var
string$namespace(optional)
array$attrs(optional) Deprecated as of 4.4.
Returns
bool

Referenced by elementValue(), and eZNodeviewfunctions\generateNodeViewData().

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

Referenced by validateTemplateFile().

eZTemplate::ini ( )

Returns the eZINI object instance for the template.ini file.

Returns
eZINI

Referenced by error().

static eZTemplate::instance ( )
static

Returns a shared instance of the eZTemplate class.

Returns
eZTemplate

Referenced by appendTemplateToStatistics(), 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().

static 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().

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

Referenced by processFunction(), and processOperator().

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

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

static 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().

static eZTemplate::resetInstance ( )
static

Reset shared instance of the eZTemplate class and factory flag as used by eZTemplate::instance() and eZTemplate::factory().

Since
4.3
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
static eZTemplate::setIsDebugEnabled (   $debug)
static

Sets whether internal debugging is enabled or not.

Referenced by factory().

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 = '',
  $scopeSafe = false 
)

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

Parameters
string$var
string$val
string$namespace(optional)
bool$scopeSafeIf true, will assure that $var is not overridden for $namespace. False by default

Referenced by appendElementText(), eZNodeviewfunctions\generateNodeViewData(), eZStepRegistration\generateRegistration(), and setLocalVariable().

eZTemplate::templateFetchList ( )

Returns template list for the last fetch.

Referenced by eZNodeviewfunctions\generateNodeViewData().

static 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 = '' 
)

Unsets the template variable $var.

Parameters
string$var
string$namespace(optional)

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 = null 
)

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

Parameters
string$var
string$namespace(optional)
array$attrs(optional) Deprecated as of 4.4
Returns
string|array

Referenced by elementValue(), and eZNodeviewfunctions\generateNodeViewData().

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::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

Referenced by autoloadPathList().

eZTemplate::$CurrentLocalVariablesNames
eZTemplate::$DefaultResource

Reference to the default resource object.

Referenced by resourceFor(), and resourceHandler().

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

Array containing all errors occured during a fetch.

Referenced by errorLog().

eZTemplate::$factory = false
staticprotected
eZTemplate::$ForCounter
eZTemplate::$ForeachCounter
eZTemplate::$FunctionAttributes

An associative array of function attributes.

eZTemplate::$Functions

An associative array of functions.

eZTemplate::$IncludeOutput

Included outputs, usually performed by custom functions.

eZTemplate::$IncludeText

Included texts, usually performed by custom functions.

eZTemplate::$instance
staticprotected

Referenced by factory().

eZTemplate::$IsCachingAllowed

true if caching is allowed

Referenced by isCachingAllowed(), and validateTemplateFile().

eZTemplate::$LDelim

The left delimiter used for parsing.

Referenced by leftDelimiter().

eZTemplate::$Level = 0

include level

eZTemplate::$Literals

An associative array of literal tags.

eZTemplate::$LocalVariablesNamesStack

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
eZTemplate::$Operators

An associative array of operators.

eZTemplate::$RDelim

The right delimiter used for parsing.

Referenced by rightDelimiter().

eZTemplate::$Resources

Associative array of resource objects.

eZTemplate::$ShowDetails = false

True if output details is to be shown.

eZTemplate::$TemplatesUsageStatistics

A list of templates used by a rendered page.

eZTemplate::$TestCompile

Referenced by resourceData(), and testCompile().

eZTemplate::$Text

The original template text.

eZTemplate::$TimeStamp

The timestamp of the template when it was last modified.

eZTemplate::$Tree

The resulting object tree of the template.

eZTemplate::$Variables

An associative array of template variables.

eZTemplate::$WarningLog

Array containing all warnings occured during a fetch.

Referenced by warningLog().

eZTemplate::$WhileCounter
const eZTemplate::DEBUG_INTERNALS = false

Referenced by isDebugEnabled().

const eZTemplate::FILE_ERRORS = 1

Referenced by error().

const eZTemplate::NODE_INTERNAL = 100
const eZTemplate::NODE_INTERNAL_ERROR = 121
const eZTemplate::NODE_INTERNAL_NAMESPACE_CHANGE = 103
const eZTemplate::NODE_INTERNAL_NAMESPACE_RESTORE = 104
const eZTemplate::NODE_INTERNAL_OUTPUT_ASSIGN = 150
const eZTemplate::NODE_INTERNAL_OUTPUT_DECREASE = 153
const eZTemplate::NODE_INTERNAL_OUTPUT_INCREASE = 152
const eZTemplate::NODE_INTERNAL_OUTPUT_READ = 151
const eZTemplate::NODE_INTERNAL_OUTPUT_SPACING_INCREASE = 160
const eZTemplate::NODE_INTERNAL_RESOURCE_ACQUISITION = 140
const eZTemplate::NODE_INTERNAL_SPACING_DECREASE = 161
const eZTemplate::NODE_INTERNAL_VARIABLE_SET = 105
const eZTemplate::NODE_INTERNAL_VARIABLE_UNSET = 102
const eZTemplate::NODE_INTERNAL_WARNING = 120
const eZTemplate::NODE_OPERATOR = 5
const eZTemplate::NODE_OPTIMIZED_INIT = 201
const eZTemplate::NODE_OPTIMIZED_RESOURCE_ACQUISITION = 141
const eZTemplate::NODE_USER_CUSTOM = 1000
const eZTemplate::RESOURCE_QUERY = 2
const eZTemplate::TYPE_ALL = 63
const eZTemplate::TYPE_ATTRIBUTE_BIT = 16
const eZTemplate::TYPE_BASIC = 47
const eZTemplate::TYPE_IDENTIFIER_BIT = 4
const eZTemplate::TYPE_INTERNAL = 100
const eZTemplate::TYPE_INTERNAL_CODE_PIECE = 101
const eZTemplate::TYPE_INTERNAL_STOP = 999
const eZTemplate::TYPE_MODIFIER_MASK = 48
const eZTemplate::TYPE_NONE = 0
const eZTemplate::TYPE_NUMERIC_BIT = 2
const eZTemplate::TYPE_OPERATOR_BIT = 32
const eZTemplate::TYPE_OPTIMIZED_ARRAY_LOOKUP = 202
const eZTemplate::TYPE_OPTIMIZED_ATTRIBUTE_LOOKUP = 204
const eZTemplate::TYPE_OPTIMIZED_CONTENT_CALL = 203
const eZTemplate::TYPE_OPTIMIZED_NODE = 201
const eZTemplate::TYPE_STRING_BIT = 1
const eZTemplate::TYPE_VARIABLE_BIT = 8

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