Graphe d'héritage de patTemplate:

Fonctions membres publiques

patTemplate ($type= 'html')
setOption ($option, $value)
getOption ($option)
setBasedir ($basedir)
setRoot ($root, $reader= '__default')
getRoot ($reader= '__default')
setNamespace ($ns)
getNamespace ()
setDefaultAttribute ($name, $value)
setDefaultAttributes ($attributes)
getDefaultAttributes ()
setType ($type)
setTags ($startTag, $endTag)
getStartTag ()
getEndTag ()
addModuleDir ($moduleType, $dir)
setAttribute ($template, $attribute, $value)
setAttributes ($template, $attributes)
getAttributes ($template)
getAttribute ($template, $attribute)
clearAttribute ($template, $attribute)
prepareTemplate ($name)
addVar ($template, $varname, $value)
getVar ($template, $varname)
clearVar ($template, $varname)
addVars ($template, $variables, $prefix= '')
clearVars ($template)
addRows ($template, $rows, $prefix= '')
addObject ($template, $object, $prefix= '', $ignorePrivate=false)
getObjectVars ($obj, $ignorePrivate=false)
addGlobalVar ($varname, $value)
clearGlobalVar ($varname)
clearGlobalVars ()
addGlobalVars ($variables, $prefix= '')
getGlobalVars ()
exists ($name)
useTemplateCache ($cache, $params=array())
applyOutputFilter ($filter, $params=array(), $template=null)
applyInputFilter ($filter, $params=array())
readTemplatesFromFile ($filename)
readTemplatesFromInput ($input, $reader= 'File', $options=null, $parseInto=null)
_loadTemplatesFromCache ($input, &$reader, $options, $key)
loadTemplateFromInput ($input, $reader= 'File', $options=null, $parseInto=false)
loadTemplate ($template)
& loadModule ($moduleType, $moduleName, $params=array(), $new=false)
moduleExists ($moduleType, $moduleName)
parseTemplate ($template, $mode= 'w')
_initTemplate ($template)
_parseVariables ($template)
_parseGlobals ($template)
_applyModifers ($template, &$vars)
_parseDependencies ($template)
_fetchTemplate ($template)
_hasVariables ($template)
_getConditionValue ($template, $value, $isVar=true)
_fetchVariables ($template)
_handleUnusedVars ($template)
getParsedTemplate ($name=null, $applyFilters=false)
displayParsedTemplate ($name=null, $applyFilters=true)
parseIntoVar ($srcTmpl, $destTmpl, $var, $append=false)
clearTemplate ($name, $recursive=false)
clearAllTemplates ()
freeTemplate ($name, $recursive=false)
freeAllTemplates ()
_getDependencies ($template)
dump ($restrict=null, $dumper= 'Html')
getIncludePath ()
applyInputFilters ($template)
placeholderExists ($placeholder, $tmpl, $cached=true)
__toString ()

Attributs publics

Documentation des fonctions membres

patTemplate::__toString ( )

Convert the template to its string representation.

This method allows you to just echo the patTemplate object in order to display the template.

Requires PHP5

$tmpl = new patTemplate(); $tmpl->readTemplatesFromFile( 'myfile.tmpl' ); echo $tmpl;

private

Renvoie:: string

Références getParsedTemplate().

Voici le graphe d'appel pour cette fonction :

patTemplate::_applyModifers	(	$	template,
		&$	vars
	)

apply variable modifiers

The variables will be passed by reference.

private

Paramètres:

string	name of the template (use modifiers from this template)
array	variables to which the modifiers should be applied

Renvoie:: boolean

Références $type, et loadModule().

Référencé par _parseGlobals(), et _parseVariables().

Voici le graphe d'appel pour cette fonction :

patTemplate::_fetchTemplate ( $ template )

fetch plain template

The template content will be stored in the template configuration so it can be used by other methods.

private

Paramètres:

string template name

Renvoie:: boolean

condition template

modulo template

standard template

Références _fetchVariables(), _getConditionValue(), et _hasVariables().

Référencé par parseTemplate().

Voici le graphe d'appel pour cette fonction :

patTemplate::_fetchVariables ( $ template )

fetch variables for a template

The variables will be stored in the template configuration so they can be used by other methods.

private

Paramètres:

string template name

Renvoie:: boolean

variables already have been fetched

get the scalar variables

get the row variables

add some system variables

Références exists(), et patErrorManager::raiseWarning().

Référencé par _fetchTemplate(), _getConditionValue(), et parseTemplate().

Voici le graphe d'appel pour cette fonction :

patTemplate::_getConditionValue	(	$	template,
		$	value,
		$	isVar = `true`
	)

fetch the value of a condition variable

_fetchVariables() has to be called before this method is being called.

private

Paramètres:

string	template name
string	condition value
boolean	flag that indicates whether value is the name of the variable that should be resolved

get the value from the template variables

is __last?

is __default?

Références _fetchVariables().

Référencé par _fetchTemplate().

Voici le graphe d'appel pour cette fonction :

patTemplate::_getDependencies ( $ template )

get _all_ dependencies of a template, regardless of the subtemplates

private

Paramètres:

string template name

Renvoie:: array list of all subtemplates

Référencé par clearTemplate(), et freeTemplate().

Voici le graphe d'appel pour cette fonction :

patTemplate::_handleUnusedVars ( $ template )

handle all unused variables in a template

This is influenced by the 'unusedvars' attribute of the template

private

Paramètres:

string

Référencé par parseTemplate().

Voici le graphe d'appel pour cette fonction :

patTemplate::_hasVariables ( $ template )

check, whether a template contains variables

private

Paramètres:

string template name

Renvoie:: boolean

Référencé par _fetchTemplate().

Voici le graphe d'appel pour cette fonction :

patTemplate::_initTemplate ( $ template )

Initialize a template

This method checks the variable specifications and copys variables from other templates.

private

Paramètres:

string name of the template

Renvoie:: boolean true on success

copy from the same template

copy from another template

Références $i, et $rows.

Référencé par parseTemplate().

Voici le graphe d'appel pour cette fonction :

patTemplate::_loadTemplatesFromCache	(	$	input,
		&$	reader,
		$	options,
		$	key
	)

load from template cache

private

Paramètres:

string	name of the input (filename, shm segment, etc.)
string	driver that is used as reader, you may also pass a Reader object
array	options for the reader
string	cache key

Renvoie:: array|boolean either an array containing the templates, or false

get modification time

Réimplémentée dans JTemplate.

Références loadModule().

Référencé par readTemplatesFromInput().

Voici le graphe d'appel pour cette fonction :

patTemplate::_parseDependencies ( $ template )

parse all dependencies in a template

private

Paramètres:

string

Références $i, parseTemplate(), et patErrorManager::raiseError().

Référencé par parseTemplate().

Voici le graphe d'appel pour cette fonction :

patTemplate::_parseGlobals ( $ template )

parse global variables in the template

private

Paramètres:

string name of the template

Renvoie:: boolean

Références _applyModifers().

Référencé par parseTemplate().

Voici le graphe d'appel pour cette fonction :

patTemplate::_parseVariables ( $ template )

parse all variables in a template

private

Paramètres:

string

modify variables before parsing

Références _applyModifers(), addVar(), et setAttribute().

Référencé par parseTemplate().

Voici le graphe d'appel pour cette fonction :

patTemplate::addGlobalVar	(	$	varname,
		$	value
	)

Adds a global variable

Global variables are valid in all templates of this object. A global variable has to be scalar, it will be converted to a string.

public

Paramètres:

string	$varname	name of the global variable
string	$value	value of the variable

Renvoie:: boolean true on success

Voir également:: addGlobalVars(), addVar(), addVars(), addRows()

patTemplate::addGlobalVars	(	$	variables,
		$	prefix = `''`
	)

Adds several global variables

Global variables are valid in all templates of this object.

$variables is an associative array, containing name/value pairs of the variables.

public

Paramètres:

array	$variables	array containing the variables
string	$prefix	prefix for variable names

Renvoie:: boolean true on success

Voir également:: addGlobalVar(), addVar(), addVars(), addRows()

patTemplate::addModuleDir	(	$	moduleType,
		$	dir
	)

add a directory where patTemplate should search for modules.

You may either pass a string or an array of directories.

patTemplate will be searching for a module in the same order you added them. If the module cannot be found in the custom folders, it will look in patTemplate/$moduleType.

public

Paramètres:

string	module type
string\|array	directory or directories to search.

patTemplate::addObject	(	$	template,
		$	object,
		$	prefix = `''`,
		$	ignorePrivate = `false`
	)

Adds an object to a template

All properties of the object will be available as template variables.

public

Paramètres:

string	name of the template
object\|array	object or array of objects
string	prefix for all variable names
boolean	ignore private properties (starting with _)

Voir également:: addVar(), addRows(), addGlobalVar(), addGlobalVars()

Références $rows, addRows(), addVars(), elseif, et getObjectVars().

Voici le graphe d'appel pour cette fonction :

patTemplate::addRows	(	$	template,
		$	rows,
		$	prefix = `''`
	)

Adds several rows of variables to a template

Each Template can have an unlimited amount of its own variables Can be used to add a database result as variables to a template

Paramètres:

string	$template	name of the template
array	$rows	array containing assotiative arrays with variable/value pairs
string	$prefix	prefix for all variable names public

Voir également:: addVar(), addVars(), addGlobalVar(), addGlobalVars()

Références $i, et $rows.

Référencé par addObject().

Voici le graphe d'appel pour cette fonction :

patTemplate::addVar	(	$	template,
		$	varname,
		$	value
	)

add a variable to a template

A variable may also be an indexed array, but _not_ an associative array!

public

Paramètres:

string	$template	name of the template
string	$varname	name of the variable
mixed	$value	value of the variable

Références $i.

Référencé par _parseVariables(), clearTemplate(), et readTemplatesFromInput().

Voici le graphe d'appel pour cette fonction :

patTemplate::addVars	(	$	template,
		$	variables,
		$	prefix = `''`
	)

Adds several variables to a template

Each Template can have an unlimited amount of its own variables $variables has to be an assotiative array containing variable/value pairs

Paramètres:

string	$template	name of the template
array	$variables	assotiative array of the variables
string	$prefix	prefix for all variable names public

Voir également:: addVar(), addRows(), addGlobalVar(), addGlobalVars()

Références $i.

Référencé par addObject().

Voici le graphe d'appel pour cette fonction :

patTemplate::applyInputFilter	(	$	filter,
		$	params = `array()`
	)

enable an input filter

input filters are used to modify the template stream before it is split into smaller templates-

public

Paramètres:

string	name of the input filter
array	parameters for the input filter

Renvoie:: boolean true on success, patError otherwise

Références $params, patErrorManager::isError(), et loadModule().

Voici le graphe d'appel pour cette fonction :

patTemplate::applyInputFilters ( $ template )

apply input filters that have been set

This is being called by the readers.

public

Paramètres:

string template

Renvoie:: string filtered templeta

Références $i.

patTemplate::applyOutputFilter	(	$	filter,
		$	params = `array()`,
		$	template = `null`
	)

enable an output filter

Output filters are used to modify the template result before it is sent to the browser.

They are applied, when displayParsedTemplate() is called.

public

Paramètres:

string	name of the output filter
array	parameters for the output filter

Renvoie:: boolean true on success, patError otherwise

Références $params, exists(), patErrorManager::isError(), loadModule(), et patErrorManager::raiseWarning().

Voici le graphe d'appel pour cette fonction :

patTemplate::clearAllTemplates ( )

clears all templates

public clearTemplate()

Références $i, et clearTemplate().

Voici le graphe d'appel pour cette fonction :

patTemplate::clearAttribute	(	$	template,
		$	attribute
	)

Clears an attribute of a template

supported attributes: visibilty, loop, parse, unusedvars

Paramètres:

string	$template	name of the template
string	$attribute	name of the attribute public

Voir également:: setAttribute(), setAttributes(), getAttribute()

Références patErrorManager::raiseWarning().

Voici le graphe d'appel pour cette fonction :

patTemplate::clearGlobalVar ( $ varname )

Clears a global variable

public

Paramètres:

string $varname name of the global variable

Renvoie:: boolean true on success

Voir également:: clearVar(), clearVars(), clearGlobalVars()

patTemplate::clearGlobalVars ( )

Clears all global variables

public

Renvoie:: boolean true on success

Voir également:: clearVar(), clearVars(), clearGlobalVar()

patTemplate::clearTemplate	(	$	name,
		$	recursive = `false`
	)

clears a parsed Template

Parsed Content, variables and the loop attribute are cleared

If you will not be using this template anymore, then you should call freeTemplate()

public

Paramètres:

string	name of the template
boolean	set this to true to clear all child templates, too

Voir également:: clearAllTemplates(); freeTemplate()

clear child templates as well

Références $name, _getDependencies(), et addVar().

Référencé par clearAllTemplates().

Voici le graphe d'appel pour cette fonction :

patTemplate::clearVar	(	$	template,
		$	varname
	)

clear the value of a variable

public

Paramètres:

string	name of the template
string	name of the variable

Renvoie:: boolean

Voir également:: clearVars(), clearTemplate()

Références $i.

patTemplate::clearVars ( $ template )

Clear all variables in a template

This clears only variables, but does

public

Paramètres:

string $template name of the template

Renvoie:: boolean

Voir également:: clearVar(), clearTemplate()

patTemplate::displayParsedTemplate	(	$	name = `null`,
		$	applyFilters = `true`
	)

displays a parsed Template

If the template has not been loaded, it will be loaded.

Voir également:: getParsedTemplate()

Paramètres:

string	name of the template
boolean	whether to apply output filters

Renvoie:: boolean true on success public

error happened

Références $name, getParsedTemplate(), et patErrorManager::isError().

Voici le graphe d'appel pour cette fonction :

patTemplate::dump	(	$	restrict = `null`,
		$	dumper = `'Html'`
	)

Displays useful information about all or named templates

This method breaks BC, as it now awaits an array instead of unlimited parameters.

Paramètres:

mixed	array of templates that should be dumped, or null if you want all templates to be dumped
string	dumper public

Références $name, patErrorManager::isError(), et loadModule().

Voici le graphe d'appel pour cette fonction :

patTemplate::exists ( $ name )

checks wether a template exists

public

Paramètres:

string name of the template

Renvoie:: boolean true, if the template exists, false otherwise

Références $name.

Référencé par _fetchVariables(), applyOutputFilter(), et placeholderExists().

Voici le graphe d'appel pour cette fonction :

patTemplate::freeAllTemplates ( )

frees all templates

All memory consumed by the templates will be freed.

public

Voir également:: freeTemplate()

patTemplate::freeTemplate	(	$	name,
		$	recursive = `false`
	)

frees a template

All memory consumed by the template will be freed.

public

Paramètres:

string	name of the template
boolean	clear dependencies of the template

Voir également:: freeAllTemplates()

free child templates as well

Références $name, _getDependencies(), et patErrorManager::raiseWarning().

Voici le graphe d'appel pour cette fonction :

patTemplate::getAttribute	(	$	template,
		$	attribute
	)

Gets an attribute of a template

supported attributes: visibilty, loop, parse, unusedvars

Paramètres:

string	$template	name of the template
string	$attribute	name of the attribute

Renvoie:: mixed value of the attribute public

Voir également:: setAttribute(), setAttributes(), clearAttribute()

Références patErrorManager::raiseWarning().

Voici le graphe d'appel pour cette fonction :

patTemplate::getAttributes ( $ template )

Get all attributes of a template

Paramètres:

string name of the template

Renvoie:: array attributes public

Références patErrorManager::raiseWarning().

Référencé par readTemplatesFromInput().

Voici le graphe d'appel pour cette fonction :

patTemplate::getDefaultAttributes ( )

get default attributes

public

Renvoie:: return default attributes

patTemplate::getEndTag ( )

get end tag for variables

public

Renvoie:: string end tag

patTemplate::getGlobalVars ( )

get all global variables

public

Renvoie:: array global variables

patTemplate::getIncludePath ( )

get the include path

public

Renvoie:: string

Référencé par loadModule(), et moduleExists().

Voici le graphe d'appel pour cette fonction :

patTemplate::getNamespace ( )

gets namespace of patTemplate tags

public

Renvoie:: string|array namespace(s)

patTemplate::getObjectVars	(	$	obj,
		$	ignorePrivate = `false`
	)

get the vars from an object

private

Paramètres:

object
boolean	ignore private properties (starting with _)

Renvoie:: array

Référencé par addObject().

Voici le graphe d'appel pour cette fonction :

patTemplate::getOption ( $ option )

gets an option

public

Paramètres:

string option to get

Renvoie:: mixed value of the option

Références $option.

patTemplate::getParsedTemplate	(	$	name = `null`,
		$	applyFilters = `false`
	)

returns a parsed Template

If the template already has been parsed, it just returns the parsed template. If the template has not been loaded, it will be loaded.

public

Paramètres:

string	name of the template
boolean	whether to apply output filters

Renvoie:: string Content of the parsed template

Voir également:: displayParsedTemplate()

Références $i, $name, patErrorManager::isError(), et parseTemplate().

Référencé par __toString(), et displayParsedTemplate().

Voici le graphe d'appel pour cette fonction :

patTemplate::getRoot ( $ reader = '__default' )

gets name of root base for the templates

public

Renvoie:: mixed root base

patTemplate::getStartTag ( )

get start tag for variables

public

Renvoie:: string start tag

patTemplate::getVar	(	$	template,
		$	varname
	)

get the value of a variable

public

Paramètres:

string	name of the template
string	name of the variable

Renvoie:: string value of the variable, null if the variable is not set

Références $i.

Référencé par readTemplatesFromInput().

Voici le graphe d'appel pour cette fonction :

& patTemplate::loadModule	(	$	moduleType,
		$	moduleName,
		$	params = `array()`,
		$	new = `false`
	)

loads a patTemplate module

Modules are located in the patTemplate folder and include:

Readers
Caches
Variable Modifiers
Filters
Functions
Stats

public

Paramètres:

string	moduleType (Reader\|TemplateCache\|Modifier\|OutputFilter\|InputFilter)
string	moduleName
array	parameters for the module

Renvoie:: object

Références $file, $params, getIncludePath(), et patErrorManager::raiseError().

Référencé par _applyModifers(), _loadTemplatesFromCache(), applyInputFilter(), applyOutputFilter(), dump(), loadTemplateFromInput(), parseTemplate(), readTemplatesFromInput(), et useTemplateCache().

Voici le graphe d'appel pour cette fonction :

patTemplate::loadTemplate ( $ template )

load a template that had autoload="off"

This is needed, if you change the source of a template and want to load it, after changing the attribute.

public

Paramètres:

string template name

Renvoie:: boolean true, if template could be loaded

Références loadTemplateFromInput(), patErrorManager::raiseWarning(), et readTemplatesFromInput().

Voici le graphe d'appel pour cette fonction :

patTemplate::loadTemplateFromInput	(	$	input,
		$	reader = `'File'`,
		$	options = `null`,
		$	parseInto = `false`
	)

open any input and load content into template

public

Paramètres:

string	name of the input (filename, shm segment, etc.)
string	driver that is used as reader
string	name of the template that should be used as a container,

Renvoie:: boolean true, if the template could be parsed, false otherwise

Références patErrorManager::isError(), et loadModule().

Référencé par loadTemplate(), parseTemplate(), et readTemplatesFromInput().

Voici le graphe d'appel pour cette fonction :

patTemplate::moduleExists	(	$	moduleType,
		$	moduleName
	)

checks whether a module exists.

Modules are located in the patTemplate folder and include:

Readers
Caches
Variable Modifiers
Filters
Functions
Stats

public

Paramètres:

string	moduleType (Reader\|TemplateCache\|Modifier\|OutputFilter\|InputFilter)
string	moduleName

Renvoie:: boolean

Références getIncludePath().

Voici le graphe d'appel pour cette fonction :

patTemplate::parseIntoVar	(	$	srcTmpl,
		$	destTmpl,
		$	var,
		$	append = `false`
	)

parse a template and push the result into a variable of any other template

If the template already has been parsed, it will just be pushed into the variable. If the template has not been loaded, it will be loaded.

public

Paramètres:

string name of the template

Renvoie:: string Content of the parsed template

Paramètres:

boolean if set to true, the value will be appended to the value already stored.

Voir également:: getParsedTemplate(); addVar()

Références patErrorManager::isError(), et parseTemplate().

Voici le graphe d'appel pour cette fonction :

patTemplate::parseTemplate	(	$	template,
		$	mode = `'w'`
	)

parses a template

Parses a template and stores the parsed content. mode can be "w" for write (delete already parsed content) or "a" for append (appends the new parsed content to the already parsed content)

public

Paramètres:

string	name of the template
string	mode for the parsing

template is not visible

check, if the template has been loaded and load it if necessary.

check for autoclear

template has been parsed and mode is not 'append'

loop at least one times

template should be cleared before parsing

fetch the variables

fetch the template

parse

store result

check for maximum loops

Références $i, $start, _fetchTemplate(), _fetchVariables(), _handleUnusedVars(), _initTemplate(), _parseDependencies(), _parseGlobals(), _parseVariables(), patErrorManager::isError(), loadModule(), loadTemplateFromInput(), patErrorManager::raiseWarning(), et readTemplatesFromInput().

Référencé par _parseDependencies(), getParsedTemplate(), et parseIntoVar().

Voici le graphe d'appel pour cette fonction :

patTemplate::patTemplate ( $ type = 'html' )

Create a new patTemplate instance.

The constructor accepts the type of the templates as sole parameter. You may choose one of:

html (default)
tex

The type influences the tags you are using in your templates.

public

Paramètres:

string type (either html or tex)

Références $type, et setType().

Référencé par patTemplate_Compiler::patTemplate_Compiler().

Voici le graphe d'appel pour cette fonction :

patTemplate::placeholderExists	(	$	placeholder,
		$	tmpl,
		$	cached = `true`
	)

checks, whether a placeholder exists in a template

public

Paramètres:

string	name of the placeholder
string	name of the template
boolean	whether to use the cached result of a previous call

Références $content, et exists().

Voici le graphe d'appel pour cette fonction :

patTemplate::prepareTemplate ( $ name )

Prepare a template

This can be used if you want to add variables to a template, that has not been loaded yet.

public

Paramètres:

string template name

Références $name.

Référencé par readTemplatesFromInput().

Voici le graphe d'appel pour cette fonction :

patTemplate::readTemplatesFromFile ( $ filename )

open a file and parse for patTemplate tags

public

Paramètres:

name	of the file

Renvoie:: true, if the template could be parsed

Obsolète:: Use patTemplate::readTemplatesFromInput() instead, as the method name is misleading

Voir également:: readTemplatesFromInput()

Références $filename, et readTemplatesFromInput().

Voici le graphe d'appel pour cette fonction :

patTemplate::readTemplatesFromInput	(	$	input,
		$	reader = `'File'`,
		$	options = `null`,
		$	parseInto = `null`
	)

open any input and parse for patTemplate tags

public

Paramètres:

string	name of the input (filename, shm segment, etc.)
string	driver that is used as reader, you may also pass a Reader object
array	additional options that will only be used for this template
string	name of the template that should be used as a container, should not be used by public calls.

Renvoie:: boolean true, if the template could be parsed, false otherwise

get the unique cache key

check for error returned from cache

templates have not been loaded from cache

set the root attributes

check for error returned from reader

store the

traverse all templates

root template

store the name

if this is the first template that has been loaded set it as the root template

set some default values

store the template

store the default values of the variables

autoload the template

Some error management is needed here...

Références $name, _loadTemplatesFromCache(), addVar(), getAttributes(), getVar(), patErrorManager::isError(), loadModule(), loadTemplateFromInput(), prepareTemplate(), et patErrorManager::raiseError().

Référencé par loadTemplate(), parseTemplate(), et readTemplatesFromFile().

Voici le graphe d'appel pour cette fonction :

patTemplate::setAttribute	(	$	template,
		$	attribute,
		$	value
	)

Sets an attribute of a template

supported attributes: visibilty, loop, parse, unusedvars

Paramètres:

string	$template	name of the template
string	$attribute	name of the attribute
mixed	$value	value of the attribute public

Voir également:: setAttributes(),getAttribute(), clearAttribute()

Références patErrorManager::raiseWarning().

Référencé par _parseVariables().

Voici le graphe d'appel pour cette fonction :

patTemplate::setAttributes	(	$	template,
		$	attributes
	)

Sets several attribute of a template

$attributes has to be a assotiative arrays containing attribute/value pairs supported attributes: visibilty, loop, parse, unusedvars

Paramètres:

string	$template	name of the template
array	$attributes	attribute/value pairs public

Voir également:: setAttribute(), getAttribute(), clearAttribute()

Références patErrorManager::raiseError(), et patErrorManager::raiseWarning().

Voici le graphe d'appel pour cette fonction :

patTemplate::setBasedir ( $ basedir )

sets name of directory where templates are stored

public

Paramètres:

string dir where templates are stored

Obsolète:: please use patTemplate::setRoot() instead

Références setRoot().

Voici le graphe d'appel pour cette fonction :

patTemplate::setDefaultAttribute	(	$	name,
		$	value
	)

set default attribute

public

Paramètres:

string	attribute name
mixed	attribute value

Références $name.

patTemplate::setDefaultAttributes ( $ attributes )

set default attributes

public

Paramètres:

array attributes

patTemplate::setNamespace ( $ ns )

sets namespace of patTemplate tags

If you want to use more than one namespace, you may set this to an array. All tags in these namespaces will be treated as patTemplate tags.

public

Paramètres:

string|array namespace(s)

patTemplate::setOption	(	$	option,
		$	value
	)

sets an option

Currently, the following options are supported

maintainBc (true|false)
namespace (string)

public

Paramètres:

string	option to set
string	value of the option

Références $option.

patTemplate::setRoot	(	$	root,
		$	reader = `'__default'`
	)

sets root base for the template

The parameter depends on the reader you are using.

public

Paramètres:

string root base of the templates

Référencé par setBasedir().

Voici le graphe d'appel pour cette fonction :

patTemplate::setTags	(	$	startTag,
		$	endTag
	)

set the start and end tag for variables

public

Paramètres:

string	start tag
string	end tag

Renvoie:: boolean true on success

Référencé par setType().

Voici le graphe d'appel pour cette fonction :

patTemplate::setType ( $ type )

set the type for the templates

public

Paramètres:

string type (html or tex)

Renvoie:: boolean true on success

Références $type, patErrorManager::raiseWarning(), et setTags().

Référencé par patTemplate().

Voici le graphe d'appel pour cette fonction :

patTemplate::useTemplateCache	(	$	cache,
		$	params = `array()`
	)

enable a template cache

A template cache will improve performace, as the templates do not have to be read on each request.

public

Paramètres:

string	name of the template cache
array	parameters for the template cache

Renvoie:: boolean true on success, patError otherwise

Références $params, patErrorManager::isError(), et loadModule().

Voici le graphe d'appel pour cette fonction :

Documentation des données membres

patTemplate::$_defaultAttributes

Valeur initiale :

        array(
                                                                                'type'                  =>      'standard',
                                                                                'visibility'    =>      'visible',
                                                                                'loop'                  =>      1,
                                                                                'unusedvars'    =>      'strip',
                                                                                'whitespace'    =>      'keep',
                                                                                'autoclear'             =>      'off',
                                                                                'autoload'              =>      'on'
                                                                        )

patTemplate::$_discoveredPlaceholders = array()

patTemplate::$_endTag = '}'

patTemplate::$_globals = array()

patTemplate::$_inputFilters = array()

patTemplate::$_moduleDirs = array()

patTemplate::$_modules = array()

patTemplate::$_options

Valeur initiale :

        array(
                                                                'startTag'                      => '{',
                                                                'endTag'                        => '}',
                                                                'root'                          => array('__default' => '.'),
                                                                'namespace'                     => 'patTemplate',
                                                                'maintainBc'            => true,
                                                                'defaultFunction'       => false
                                                         )

patTemplate::$_outputFilters = array()

patTemplate::$_root

patTemplate::$_startTag = '{'

patTemplate::$_systemVars

Valeur initiale :

        array(
                                                                                'appName'               =>      'patTemplate',
                                                                                'appVersion'    =>      '3.1.0',
                                                                                'author'                =>      array(
                                                                                                                                        'Stephan Schmidt <schst@php.net>'
                                                                                                                                 )
                                                                        )

patTemplate::$_templateList = array()

patTemplate::$_templates = array()

patTemplate::$_tmplCache = null

patTemplate::$_vars = array()

La documentation de cette classe a été générée à partir du fichier suivant :

patTemplate.php

Référence de la classe patTemplate

Fonctions membres publiques

Attributs publics

Documentation des fonctions membres

Documentation des données membres