{layout '@layout.latte'} {var $active = 'class'} {block title}{if $class->deprecated}Deprecated {/if}{if $class->interface}Interface{elseif $class->trait}Trait{else}Class{/if} {$class->name}{/block} {block content}

{if $class->interface}Interface{elseif $class->trait}Trait{else}Class{/if} {$class->shortName}

{if $class->valid}
{$class|longDescription|noescape}
Extended by {if $item->documented} {last}{/last}{$item->name}{last}{/last} {else}{$item->name}{/if} {var $itemOwnInterfaces = $item->ownInterfaces} {if $itemOwnInterfaces} implements {foreach $itemOwnInterfaces as $interface} {$interface->name}{sep}, {/sep} {/foreach}{/if} {var $itemOwnTraits = $item->ownTraits} {if $itemOwnTraits} uses {foreach $itemOwnTraits as $trait} {if is_string($trait)} {$trait} (not available) {else} {$trait->name}{sep}, {/sep} {/} {/foreach}{/if}
{define children}

{foreach $children as $child} {$child->name}{sep}, {/sep} {/foreach}

{/define}

Direct known subclasses

{include children, children => $directSubClasses}

Indirect known subclasses

{include children, children => $indirectSubClasses}

Direct known implementers

{include children, children => $directImplementers}

Indirect known implementers

{include children, children => $indirectImplementers}

Direct Known Users

{include children, children => $directUsers}

Indirect Known Users

{include children, children => $indirectUsers}
{if !$class->interface && !$class->trait && ($class->abstract || $class->final)}{if $class->abstract}Abstract{else}Final{/if}
{/if} {if $class->internal}PHP Extension: {$class->extension->name|firstUpper}
{/if} {if $class->inNamespace()}Namespace: {$class->namespaceName|namespaceLinks|noescape}
{/if} {if $class->inPackage()}Package: {$class->packageName|packageLinks|noescape}
{/if} {foreach $template->annotationSort($template->annotationFilter($class->annotations)) as $annotation => $values} {foreach $values as $value} {$annotation|annotationBeautify}{if $value}:{/if} {$value|annotation:$annotation:$class|noescape}
{/foreach} {/foreach} {if $class->internal} Documented at php.net {else} Located at {$class->fileName|relativePath} {/if}
{var $ownMethods = $class->ownMethods} {var $inheritedMethods = $class->inheritedMethods} {var $usedMethods = $class->usedMethods} {var $ownMagicMethods = $class->ownMagicMethods} {var $inheritedMagicMethods = $class->inheritedMagicMethods} {var $usedMagicMethods = $class->usedMagicMethods} {if $ownMethods || $inheritedMethods || $usedMethods || $ownMagicMethods || $usedMagicMethods} {define method} {var $annotations = $method->annotations} {if !$class->interface && $method->abstract}abstract{elseif $method->final}final{/if} {if $method->protected}protected{elseif $method->private}private{else}public{/if} {if $method->static}static{/if} {ifset $annotations['return']}{$annotations['return'][0]|typeLinks:$method|noescape}{/ifset} {if $method->returnsReference()}&{/if}
# {block|strip} {if $class->internal} {$method->name}( {else} {$method->name}( {/if} {foreach $method->parameters as $parameter} {$parameter->typeHint|typeLinks:$method|noescape} {if $parameter->passedByReference}& {/if}${$parameter->name}{if $parameter->defaultValueAvailable} = {$parameter->defaultValueDefinition|highlightPHP:$class|noescape}{elseif $parameter->unlimited},…{/if}{sep}, {/sep} {/foreach} ){/block} {if $config->template['options']['elementDetailsCollapsed']}
{$method|shortDescription:true|noescape}
{/if}
{$method|longDescription|noescape} {if !$class->deprecated && $method->deprecated}

Deprecated

{ifset $annotations['deprecated']}
{foreach $annotations['deprecated'] as $description} {if $description} {$description|annotation:'deprecated':$method|noescape}
{/if} {/foreach}
{/ifset} {/if} {if $method->parameters && isset($annotations['param'])}

Parameters

{foreach $method->parameters as $parameter}
${$parameter->name}{if $parameter->unlimited},…{/if}
{$parameter->description|description:$method|noescape}
{/foreach}
{/if} {if isset($annotations['return']) && 'void' !== $annotations['return'][0]}

Returns

{foreach $annotations['return'] as $description} {$description|annotation:'return':$method|noescape}{sep}
{/} {/foreach}
{/if} {ifset $annotations['throws']}

Throws

{foreach $annotations['throws'] as $description} {$description|annotation:'throws':$method|noescape}{sep}
{/} {/foreach}
{/ifset} {foreach $template->annotationSort($template->annotationFilter($annotations, array('deprecated', 'param', 'return', 'throws'))) as $annotation => $descriptions}

{$annotation|annotationBeautify}

{foreach $descriptions as $description} {if $description} {$description|annotation:$annotation:$method|noescape}
{/if} {/foreach}
{/foreach} {var $overriddenMethod = $method->overriddenMethod} {if $overriddenMethod}

Overrides

{/if} {var $implementedMethod = $method->implementedMethod} {if $implementedMethod}

Implementation of

{/if}
{/define}

Methods summary

{foreach $ownMethods as $method} {include method, method => $method} {/foreach}
{foreach $inheritedMethods as $parentName => $methods}

Methods inherited from {$parentName}

{foreach $methods as $method} {$method->name}(){sep}, {/sep} {/foreach}

{/foreach} {foreach $usedMethods as $traitName => $methods}

Methods used from {$traitName}

{foreach $methods as $data} {$data['method']->name}(){if $data['aliases']}(as {foreach $data['aliases'] as $alias}{$alias->name}(){sep}, {/sep}{/foreach}){/if}{sep}, {/sep} {/foreach}

{/foreach} {if $ownMagicMethods}

Magic methods summary

{foreach $ownMagicMethods as $method} {include method, method => $method} {/foreach}
{/if} {foreach $inheritedMagicMethods as $parentName => $methods}

Magic methods inherited from {$parentName}

{foreach $methods as $method} {$method->name}(){sep}, {/sep} {/foreach}

{/foreach} {foreach $usedMagicMethods as $traitName => $methods}

Magic methods used from {$traitName}

{foreach $methods as $data} {$data['method']->name}(){if $data['aliases']}(as {foreach $data['aliases'] as $alias}{$alias->name}(){sep}, {/sep}{/foreach}){/if}{sep}, {/sep} {/foreach}

{/foreach} {/if} {var $ownConstants = $class->ownConstants} {var $inheritedConstants = $class->inheritedConstants} {if $ownConstants || $inheritedConstants}

Constants summary

{var $annotations = $constant->annotations}
{$constant->typeHint|typeLinks:$constant|noescape} {if $class->internal} {$constant->name} {else} {$constant->name} {/if}
{$constant|shortDescription:true|noescape}
{$constant|longDescription|noescape} {foreach $template->annotationSort($template->annotationFilter($annotations, array('var'))) as $annotation => $descriptions}

{$annotation|annotationBeautify}

{foreach $descriptions as $description} {if $description} {$description|annotation:$annotation:$constant|noescape}
{/if} {/foreach}
{/foreach}
# {$constant->valueDefinition|highlightValue:$class|noescape}
{foreach $inheritedConstants as $parentName => $constants}

Constants inherited from {$parentName}

{foreach $constants as $constant} {$constant->name}{sep}, {/sep} {/foreach}

{/foreach} {/if} {var $ownProperties = $class->ownProperties} {var $inheritedProperties = $class->inheritedProperties} {var $usedProperties = $class->usedProperties} {var $ownMagicProperties = $class->ownMagicProperties} {var $inheritedMagicProperties = $class->inheritedMagicProperties} {var $usedMagicProperties = $class->usedMagicProperties} {if $ownProperties || $inheritedProperties || $usedProperties || $ownMagicProperties || $inheritedMagicProperties || $usedMagicProperties} {define property} {if $property->protected}protected{elseif $property->private}private{else}public{/if} {if $property->static}static{/if} {if $property->readOnly}read-only{elseif $property->writeOnly}write-only{/if} {$property->typeHint|typeLinks:$property|noescape} {if $class->internal} ${$property->name} {else} ${$property->name} {/if}
{$property|shortDescription:true|noescape}
{$property|longDescription|noescape} {foreach $template->annotationSort($template->annotationFilter($property->annotations, array('var'))) as $annotation => $descriptions}

{$annotation|annotationBeautify}

{foreach $descriptions as $description} {if $description} {$description|annotation:$annotation:$property|noescape}
{/if} {/foreach}
{/foreach}
# {$property->defaultValueDefinition|highlightValue:$class|noescape}
{/define}

Properties summary

{foreach $ownProperties as $property} {include property, property => $property} {/foreach}
{foreach $inheritedProperties as $parentName => $properties}

Properties inherited from {$parentName}

{foreach $properties as $property} ${$property->name}{sep}, {/sep} {/foreach}

{/foreach} {foreach $usedProperties as $traitName => $properties}

Properties used from {$traitName}

{foreach $properties as $property} ${$property->name}{sep}, {/sep} {/foreach}

{/foreach} {if $ownMagicProperties}

Magic properties

{foreach $ownMagicProperties as $property} {include property, property => $property} {/foreach}
{/if} {foreach $inheritedMagicProperties as $parentName => $properties}

Magic properties inherited from {$parentName}

{foreach $properties as $property} ${$property->name}{sep}, {/sep} {/foreach}

{/foreach} {foreach $usedMagicProperties as $traitName => $properties}

Magic properties used from {$traitName}

{foreach $properties as $property} ${$property->name}{sep}, {/sep} {/foreach}

{/foreach} {/if} {else}

Documentation of this class could not be generated.

Class was originally declared in {$class->fileName|relativePath} and is invalid because of:

{/if}
{/block}