[ Index ]

PHP Cross Reference of phpBB-3.2.8-deutsch

title

Body

[close]

/vendor/twig/twig/src/ -> Environment.php (summary)

(no description)

File Size: 1638 lines (53 kb)
Included or required:0 times
Referenced: 0 times
Includes or requires: 0 files

Defines 1 class

Environment:: (77 methods):
  __construct()
  getBaseTemplateClass()
  setBaseTemplateClass()
  enableDebug()
  disableDebug()
  isDebug()
  enableAutoReload()
  disableAutoReload()
  isAutoReload()
  enableStrictVariables()
  disableStrictVariables()
  isStrictVariables()
  getCache()
  setCache()
  getCacheFilename()
  getTemplateClass()
  getTemplateClassPrefix()
  render()
  display()
  load()
  loadTemplate()
  loadClass()
  createTemplate()
  isTemplateFresh()
  resolveTemplate()
  clearTemplateCache()
  clearCacheFiles()
  getLexer()
  setLexer()
  tokenize()
  getParser()
  setParser()
  parse()
  getCompiler()
  setCompiler()
  compile()
  compileSource()
  setLoader()
  getLoader()
  setCharset()
  getCharset()
  initRuntime()
  hasExtension()
  addRuntimeLoader()
  getExtension()
  getRuntime()
  addExtension()
  removeExtension()
  setExtensions()
  getExtensions()
  addTokenParser()
  getTokenParsers()
  getTags()
  addNodeVisitor()
  getNodeVisitors()
  addFilter()
  getFilter()
  registerUndefinedFilterCallback()
  getFilters()
  addTest()
  getTests()
  getTest()
  addFunction()
  getFunction()
  registerUndefinedFunctionCallback()
  getFunctions()
  addGlobal()
  getGlobals()
  mergeGlobals()
  getUnaryOperators()
  getBinaryOperators()
  computeAlternatives()
  initGlobals()
  initExtensions()
  initExtension()
  writeCacheFile()
  updateOptionsHash()


Class: Environment  - X-Ref

Stores the Twig configuration.

__construct(LoaderInterface $loader = null, $options = [])   X-Ref
Constructor.

Available options:

* debug: When set to true, it automatically set "auto_reload" to true as
well (default to false).

* charset: The charset used by the templates (default to UTF-8).

* base_template_class: The base template class to use for generated
templates (default to \Twig\Template).

* cache: An absolute path where to store the compiled templates,
a \Twig\Cache\CacheInterface implementation,
or false to disable compilation cache (default).

* auto_reload: Whether to reload the template if the original source changed.
If you don't provide the auto_reload option, it will be
determined automatically based on the debug value.

* strict_variables: Whether to ignore invalid variables in templates
(default to false).

* autoescape: Whether to enable auto-escaping (default to html):
* false: disable auto-escaping
* true: equivalent to html
* html, js: set the autoescaping to one of the supported strategies
* name: set the autoescaping strategy based on the template name extension
* PHP callback: a PHP callback that returns an escaping strategy based on the template "name"

* optimizations: A flag that indicates which optimizations to apply
(default to -1 which means that all optimizations are enabled;
set it to 0 to disable).

getBaseTemplateClass()   X-Ref
Gets the base template class for compiled templates.

return: string The base template class name

setBaseTemplateClass($class)   X-Ref
Sets the base template class for compiled templates.

param: string $class The base template class name

enableDebug()   X-Ref
Enables debugging mode.


disableDebug()   X-Ref
Disables debugging mode.


isDebug()   X-Ref
Checks if debug mode is enabled.

return: bool true if debug mode is enabled, false otherwise

enableAutoReload()   X-Ref
Enables the auto_reload option.


disableAutoReload()   X-Ref
Disables the auto_reload option.


isAutoReload()   X-Ref
Checks if the auto_reload option is enabled.

return: bool true if auto_reload is enabled, false otherwise

enableStrictVariables()   X-Ref
Enables the strict_variables option.


disableStrictVariables()   X-Ref
Disables the strict_variables option.


isStrictVariables()   X-Ref
Checks if the strict_variables option is enabled.

return: bool true if strict_variables is enabled, false otherwise

getCache($original = true)   X-Ref
Gets the current cache implementation.

param: bool $original Whether to return the original cache option or the real cache instance
return: CacheInterface|string|false A Twig\Cache\CacheInterface implementation,

setCache($cache)   X-Ref
Sets the current cache implementation.

param: CacheInterface|string|false $cache A Twig\Cache\CacheInterface implementation,

getCacheFilename($name)   X-Ref
Gets the cache filename for a given template.

param: string $name The template name
return: string|false The cache file name or false when caching is disabled

getTemplateClass($name, $index = null)   X-Ref
Gets the template class associated with the given string.

The generated template class is based on the following parameters:

* The cache key for the given template;
* The currently enabled extensions;
* Whether the Twig C extension is available or not;
* PHP version;
* Twig version;
* Options with what environment was created.

param: string   $name  The name for which to calculate the template class name
param: int|null $index The index if it is an embedded template
return: string The template class name

getTemplateClassPrefix()   X-Ref
Gets the template class prefix.

return: string The template class prefix

render($name, array $context = [])   X-Ref
Renders a template.

param: string|TemplateWrapper $name    The template name
param: array                  $context An array of parameters to pass to the template
return: string The rendered template

display($name, array $context = [])   X-Ref
Displays a template.

param: string|TemplateWrapper $name    The template name
param: array                  $context An array of parameters to pass to the template

load($name)   X-Ref
Loads a template.

param: string|TemplateWrapper|\Twig\Template $name The template name
return: TemplateWrapper

loadTemplate($name, $index = null)   X-Ref
Loads a template internal representation.

This method is for internal use only and should never be called
directly.

param: string $name  The template name
param: int    $index The index if it is an embedded template
return: \Twig_TemplateInterface A template instance representing the given template name

loadClass($cls, $name, $index = null)   X-Ref


createTemplate($template, $name = null)   X-Ref
Creates a template from source.

This method should not be used as a generic way to load templates.

param: string $template The template name
param: string $name     An optional name of the template to be used in error messages
return: TemplateWrapper A template instance representing the given template name

isTemplateFresh($name, $time)   X-Ref
Returns true if the template is still fresh.

Besides checking the loader for freshness information,
this method also checks if the enabled extensions have
not changed.

param: string $name The template name
param: int    $time The last modification time of the cached template
return: bool true if the template is fresh, false otherwise

resolveTemplate($names)   X-Ref
Tries to load a template consecutively from an array.

Similar to load() but it also accepts instances of \Twig\Template and
\Twig\TemplateWrapper, and an array of templates where each is tried to be loaded.

param: string|Template|\Twig\TemplateWrapper|array $names A template or an array of templates to try consecutively
return: TemplateWrapper|Template

clearTemplateCache()   X-Ref
Clears the internal template cache.


clearCacheFiles()   X-Ref
Clears the template cache files on the filesystem.


getLexer()   X-Ref
Gets the Lexer instance.

return: \Twig_LexerInterface

setLexer(\Twig_LexerInterface $lexer)   X-Ref
No description

tokenize($source, $name = null)   X-Ref
Tokenizes a source code.

param: string|Source $source The template source code
param: string        $name   The template name (deprecated)
return: TokenStream

getParser()   X-Ref
Gets the Parser instance.

return: \Twig_ParserInterface

setParser(\Twig_ParserInterface $parser)   X-Ref
No description

parse(TokenStream $stream)   X-Ref
Converts a token stream to a node tree.

return: ModuleNode

getCompiler()   X-Ref
Gets the Compiler instance.

return: \Twig_CompilerInterface

setCompiler(\Twig_CompilerInterface $compiler)   X-Ref
No description

compile(\Twig_NodeInterface $node)   X-Ref
Compiles a node and returns the PHP code.

return: string The compiled PHP source code

compileSource($source, $name = null)   X-Ref
Compiles a template source code.

param: string|Source $source The template source code
param: string        $name   The template name (deprecated)
return: string The compiled PHP source code

setLoader(LoaderInterface $loader)   X-Ref
No description

getLoader()   X-Ref
Gets the Loader instance.

return: LoaderInterface

setCharset($charset)   X-Ref
Sets the default template charset.

param: string $charset The default charset

getCharset()   X-Ref
Gets the default template charset.

return: string The default charset

initRuntime()   X-Ref
Initializes the runtime environment.


hasExtension($class)   X-Ref
Returns true if the given extension is registered.

param: string $class The extension class name
return: bool Whether the extension is registered or not

addRuntimeLoader(RuntimeLoaderInterface $loader)   X-Ref
Adds a runtime loader.


getExtension($class)   X-Ref
Gets an extension by class name.

param: string $class The extension class name
return: ExtensionInterface

getRuntime($class)   X-Ref
Returns the runtime implementation of a Twig element (filter/function/test).

param: string $class A runtime class name
return: object The runtime implementation

addExtension(ExtensionInterface $extension)   X-Ref
No description

removeExtension($name)   X-Ref
Removes an extension by name.

This method is deprecated and you should not use it.

param: string $name The extension name

setExtensions(array $extensions)   X-Ref
Registers an array of extensions.

param: array $extensions An array of extensions

getExtensions()   X-Ref
Returns all registered extensions.

return: ExtensionInterface[] An array of extensions (keys are for internal usage only and should not be relied on)

addTokenParser(TokenParserInterface $parser)   X-Ref
No description

getTokenParsers()   X-Ref
Gets the registered Token Parsers.

return: \Twig_TokenParserBrokerInterface

getTags()   X-Ref
Gets registered tags.

Be warned that this method cannot return tags defined by \Twig_TokenParserBrokerInterface classes.

return: TokenParserInterface[]

addNodeVisitor(NodeVisitorInterface $visitor)   X-Ref
No description

getNodeVisitors()   X-Ref
Gets the registered Node Visitors.

return: NodeVisitorInterface[]

addFilter($name, $filter = null)   X-Ref
Registers a Filter.

param: string|TwigFilter                $name   The filter name or a \Twig_SimpleFilter instance
param: \Twig_FilterInterface|TwigFilter $filter

getFilter($name)   X-Ref
Get a filter by name.

Subclasses may override this method and load filters differently;
so no list of filters is available.

param: string $name The filter name
return: \Twig_Filter|false

registerUndefinedFilterCallback($callable)   X-Ref
No description

getFilters()   X-Ref
Gets the registered Filters.

Be warned that this method cannot return filters defined with registerUndefinedFilterCallback.

return: \Twig_FilterInterface[]

addTest($name, $test = null)   X-Ref
Registers a Test.

param: string|TwigTest              $name The test name or a \Twig_SimpleTest instance
param: \Twig_TestInterface|TwigTest $test A \Twig_TestInterface instance or a \Twig_SimpleTest instance

getTests()   X-Ref
Gets the registered Tests.

return: \Twig_TestInterface[]

getTest($name)   X-Ref
Gets a test by name.

param: string $name The test name
return: \Twig_Test|false

addFunction($name, $function = null)   X-Ref
Registers a Function.

param: string|TwigFunction                  $name     The function name or a \Twig_SimpleFunction instance
param: \Twig_FunctionInterface|TwigFunction $function

getFunction($name)   X-Ref
Get a function by name.

Subclasses may override this method and load functions differently;
so no list of functions is available.

param: string $name function name
return: \Twig_Function|false

registerUndefinedFunctionCallback($callable)   X-Ref
No description

getFunctions()   X-Ref
Gets registered functions.

Be warned that this method cannot return functions defined with registerUndefinedFunctionCallback.

return: \Twig_FunctionInterface[]

addGlobal($name, $value)   X-Ref
Registers a Global.

New globals can be added before compiling or rendering a template;
but after, you can only update existing globals.

param: string $name  The global name
param: mixed  $value The global value

getGlobals()   X-Ref
Gets the registered Globals.

return: array An array of globals

mergeGlobals(array $context)   X-Ref
Merges a context with the defined globals.

param: array $context An array representing the context
return: array The context merged with the globals

getUnaryOperators()   X-Ref
Gets the registered unary Operators.

return: array An array of unary operators

getBinaryOperators()   X-Ref
Gets the registered binary Operators.

return: array An array of binary operators

computeAlternatives($name, $items)   X-Ref


initGlobals()   X-Ref


initExtensions()   X-Ref


initExtension(ExtensionInterface $extension)   X-Ref


writeCacheFile($file, $content)   X-Ref


updateOptionsHash()   X-Ref
No description



Generated: Tue Apr 7 19:42:26 2020 Cross-referenced by PHPXref 0.7.1